nserver

Unnamed repository; edit this file 'description' to name the repository.
Log | Files | Refs | LICENSE

commit b924fc2f66d46ee10aa3b800a6521d3940919f9f
parent 1bab8e87d3875f672e7c36d10aea9e05f657c664
Author: rsiddharth <s@ricketyspace.net>
Date:   Fri, 17 Apr 2020 21:02:35 -0400

nserver/ -> ./

Diffstat:
.gitignore | 9+++++++++
LICENSE | 29+++++++++++++++++++++++++++++
Makefile | 64++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
README.md | 71+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
bin/statserve.c | 54++++++++++++++++++++++++++++++++++++++++++++++++++++++
nserver/.gitignore | 9---------
nserver/LICENSE | 29-----------------------------
nserver/Makefile | 64----------------------------------------------------------------
nserver/README.md | 71-----------------------------------------------------------------------
nserver/bin/statserve.c | 54------------------------------------------------------
nserver/src/bstrlib.c | 3149-------------------------------------------------------------------------------
nserver/src/bstrlib.h | 332-------------------------------------------------------------------------------
nserver/src/darray.c | 198-------------------------------------------------------------------------------
nserver/src/darray.h | 126-------------------------------------------------------------------------------
nserver/src/darray_algos.c | 234-------------------------------------------------------------------------------
nserver/src/darray_algos.h | 26--------------------------
nserver/src/db.c | 138-------------------------------------------------------------------------------
nserver/src/db.h | 20--------------------
nserver/src/dbg.h | 48------------------------------------------------
nserver/src/hashmap.c | 341-------------------------------------------------------------------------------
nserver/src/hashmap.h | 49-------------------------------------------------
nserver/src/ncmd.c | 351-------------------------------------------------------------------------------
nserver/src/ncmd.h | 41-----------------------------------------
nserver/src/nserve.c | 78------------------------------------------------------------------------------
nserver/src/nserve.h | 20--------------------
nserver/src/nsocket.c | 61-------------------------------------------------------------
nserver/src/nsocket.h | 19-------------------
nserver/src/protocol.c | 310-------------------------------------------------------------------------------
nserver/src/protocol.h | 34----------------------------------
nserver/src/stats.c | 128-------------------------------------------------------------------------------
nserver/src/stats.h | 47-----------------------------------------------
nserver/src/tstree.c | 256-------------------------------------------------------------------------------
nserver/src/tstree.h | 36------------------------------------
nserver/tests/darray_algos_tests.c | 102-------------------------------------------------------------------------------
nserver/tests/darray_tests.c | 361-------------------------------------------------------------------------------
nserver/tests/db_tests.c | 55-------------------------------------------------------
nserver/tests/hashmap_tests.c | 311-------------------------------------------------------------------------------
nserver/tests/minunit.h | 38--------------------------------------
nserver/tests/ncmd_tests.c | 492-------------------------------------------------------------------------------
nserver/tests/protocol_tests.c | 202-------------------------------------------------------------------------------
nserver/tests/runtests.sh | 19-------------------
nserver/tests/stats_tests.c | 132-------------------------------------------------------------------------------
nserver/tests/tstree_tests.c | 132-------------------------------------------------------------------------------
src/bstrlib.c | 3149+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/bstrlib.h | 332+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/darray.c | 198+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/darray.h | 126+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/darray_algos.c | 234+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/darray_algos.h | 26++++++++++++++++++++++++++
src/db.c | 138+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/db.h | 20++++++++++++++++++++
src/dbg.h | 48++++++++++++++++++++++++++++++++++++++++++++++++
src/hashmap.c | 341+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/hashmap.h | 49+++++++++++++++++++++++++++++++++++++++++++++++++
src/ncmd.c | 351+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/ncmd.h | 41+++++++++++++++++++++++++++++++++++++++++
src/nserve.c | 78++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/nserve.h | 20++++++++++++++++++++
src/nsocket.c | 61+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/nsocket.h | 19+++++++++++++++++++
src/protocol.c | 310+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/protocol.h | 34++++++++++++++++++++++++++++++++++
src/stats.c | 128+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/stats.h | 47+++++++++++++++++++++++++++++++++++++++++++++++
src/tstree.c | 256+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/tstree.h | 36++++++++++++++++++++++++++++++++++++
tests/darray_algos_tests.c | 102+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
tests/darray_tests.c | 361+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
tests/db_tests.c | 55+++++++++++++++++++++++++++++++++++++++++++++++++++++++
tests/hashmap_tests.c | 311+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
tests/minunit.h | 38++++++++++++++++++++++++++++++++++++++
tests/ncmd_tests.c | 492+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
tests/protocol_tests.c | 202+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
tests/runtests.sh | 19+++++++++++++++++++
tests/stats_tests.c | 132+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
tests/tstree_tests.c | 132+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
76 files changed, 8113 insertions(+), 8113 deletions(-)

diff --git a/.gitignore b/.gitignore @@ -0,0 +1,9 @@ +*.o +*.log + +build/ + +TAGS +nserver.db +bin/statserve +tests/*_tests diff --git a/LICENSE b/LICENSE @@ -0,0 +1,28 @@ +Copyright © 2020 rsiddharth <s@ricketyspace.net>. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +1. Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + +2. 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. + +3. Neither the name of the copyright holder nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +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 +HOLDER 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.+ \ No newline at end of file diff --git a/Makefile b/Makefile @@ -0,0 +1,64 @@ +CFLAGS=-g -O2 -Wall -Wextra -Isrc -I/usr/local/include -DNDEBUG $(OPTFLAGS) +LIBS=-ldl $(OPTLIBS) +PREFIX?=/usr/local +CTAGS=`which ectags` + +SOURCES=$(wildcard src/**/*.c src/*.c) +OBJECTS=$(patsubst %.c,%.o,$(SOURCES)) + +TEST_SRC=$(wildcard tests/*_tests.c) +TESTS=$(patsubst %.c,%,$(TEST_SRC)) + +PROGRAMS_SRC=$(wildcard bin/*.c) +PROGRAMS=$(patsubst %.c,%,$(PROGRAMS_SRC)) + +TARGET=build/libnserve.a +SO_TARGET=$(patsubst %.a,%.so,$(TARGET)) + +# The Target Build +all: $(TARGET) $(SO_TARGET) $(PROGRAMS) TAGS tests + +dev: CFLAGS=-g -Wall -Isrc -I/usr/local/include -Wall -Wextra $(OPTFLAGS) +dev: all + +$(TARGET): CFLAGS += -fPIC +$(TARGET): build $(OBJECTS) + ar rcs $@ $(OBJECTS) + ranlib $@ +$(SO_TARGET): $(TARGET) $(OBJECTS) + $(CC) -shared -o $@ $(OBJECTS) + +$(PROGRAMS): LDLIBS += $(TARGET) -lm -L/usr/local/lib -lgdbm + +build: + @mkdir -p build + @mkdir -p bin + +# The Unit Tests +.PHONY: tests +tests: LDLIBS += $(TARGET) -lm -L/usr/local/lib -lgdbm +tests: $(TESTS) + sh ./tests/runtests.sh + +# The Cleaner +clean: + rm -rf TAGS build $(OBJECTS) $(TESTS) $(PROGRAMS) + rm -f tests/tests.log + find . -name "*.gc" -exec rm {} \; + rm -rf `find . -name "*.dSYM" -print` + rm -rf nserver.db + +# The Install +install: all + install -d $(DESTDIR)/$(PREFIX)/lib/ + install $(TARGET) $(DESTDIR)/$(PREFIX)/lib/ + +# Generate TAGS file +TAGS: $(SOURCES) $(TEST_SRC) + find ./ -type f -name '*.h' -or -name '*.c' | $(CTAGS) -e -L - + +# The Checker +check: + @echo Files with potentially dangerous functions. + @egrep '[^_.>a-zA-Z0-9](str(n?cpy|n?cat|xfrm|n?dup|str|pbrk|tok|_)\ + |stpn?cpy|a?sn?printf|byte_)' $(SOURCES) || true diff --git a/README.md b/README.md @@ -0,0 +1,71 @@ +# nserver + +A nihilistic stats server written is part of reading Learn C the +Harday. + + +## compiling + +You'll need a C compiler (clang or gcc), the [gdbm][1] library and +[GNU make][2]. + +[1]: https://www.gnu.org.ua/software/gdbm +[2]: https://www.gnu.org/software/make + +To compile the server, do: + +``` +make +``` + +To compile a debuggable version of the server, do: + +``` +make dev +``` + +The usual: + +``` +make clean +``` + +clean up things. + + +## statserve + +To start this server, do: + +``` +./bin/statserve +``` + +It'll be listening on port 7899. + +You can connect as a client to the server via `nc`: + +``` +nc 127.0.0.1 7899 +``` + + +### client commands + +Recognized commands: + + +``` +/create NAME +/sample NAME +/mean NAME +/dump NAME +/list +/store NAME +/load NAME ANOTHER_NAME +``` + +The `/store` command stores `NAME` in a persistent database on the disk. + +The `/load` command loads the `NAME` from the persistent database into +memory at ANOTHER_NAME. diff --git a/bin/statserve.c b/bin/statserve.c @@ -0,0 +1,54 @@ +/* SPDX-License-Identifier: BSD-3-Clause */ +/* + * Copyright © 2020 rsiddharth <s@ricketyspace.net> + */ + +#include <nserve.h> +#include <nsocket.h> + +#define BACKLOG 10 + +int main(void) +{ + int rc = 0; + int sockfd_s = 0, sockfd_c = 0; + struct sockaddr sockaddr_c; + socklen_t sockaddr_c_len; + pid_t pidc; + + sockfd_s = get_socket(); + check(sockfd_s > 0, "stateserv: unable to get socket"); + + rc = listen(sockfd_s, BACKLOG); + check(rc == 0, "statserve: listen failed"); + + do { + printf("Waiting for connection...\n"); + sockfd_c = accept(sockfd_s, &sockaddr_c, &sockaddr_c_len); + + pidc = fork(); + check(pidc != -1, "statserve: fork failed"); + + if (pidc == 0) { + nserve(sockfd_c); + } + + rc = close(sockfd_c); + check(rc == 0, "statserv: close failed"); + } while(1); + + rc = close(sockfd_s); + check(rc == 0, "statserv: close failed"); + + return 0; + + error: + if (sockfd_s) { + rc = close(sockfd_s); + } + if (sockfd_c) { + rc = close(sockfd_c); + } + + return -1; +} diff --git a/nserver/.gitignore b/nserver/.gitignore @@ -1,9 +0,0 @@ -*.o -*.log - -build/ - -TAGS -nserver.db -bin/statserve -tests/*_tests diff --git a/nserver/LICENSE b/nserver/LICENSE @@ -1,28 +0,0 @@ -Copyright © 2020 rsiddharth <s@ricketyspace.net>. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - -1. Redistributions of source code must retain the above copyright -notice, this list of conditions and the following disclaimer. - -2. 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. - -3. Neither the name of the copyright holder nor the names of its -contributors may be used to endorse or promote products derived from -this software without specific prior written permission. - -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 -HOLDER 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.- \ No newline at end of file diff --git a/nserver/Makefile b/nserver/Makefile @@ -1,64 +0,0 @@ -CFLAGS=-g -O2 -Wall -Wextra -Isrc -I/usr/local/include -DNDEBUG $(OPTFLAGS) -LIBS=-ldl $(OPTLIBS) -PREFIX?=/usr/local -CTAGS=`which ectags` - -SOURCES=$(wildcard src/**/*.c src/*.c) -OBJECTS=$(patsubst %.c,%.o,$(SOURCES)) - -TEST_SRC=$(wildcard tests/*_tests.c) -TESTS=$(patsubst %.c,%,$(TEST_SRC)) - -PROGRAMS_SRC=$(wildcard bin/*.c) -PROGRAMS=$(patsubst %.c,%,$(PROGRAMS_SRC)) - -TARGET=build/libnserve.a -SO_TARGET=$(patsubst %.a,%.so,$(TARGET)) - -# The Target Build -all: $(TARGET) $(SO_TARGET) $(PROGRAMS) TAGS tests - -dev: CFLAGS=-g -Wall -Isrc -I/usr/local/include -Wall -Wextra $(OPTFLAGS) -dev: all - -$(TARGET): CFLAGS += -fPIC -$(TARGET): build $(OBJECTS) - ar rcs $@ $(OBJECTS) - ranlib $@ -$(SO_TARGET): $(TARGET) $(OBJECTS) - $(CC) -shared -o $@ $(OBJECTS) - -$(PROGRAMS): LDLIBS += $(TARGET) -lm -L/usr/local/lib -lgdbm - -build: - @mkdir -p build - @mkdir -p bin - -# The Unit Tests -.PHONY: tests -tests: LDLIBS += $(TARGET) -lm -L/usr/local/lib -lgdbm -tests: $(TESTS) - sh ./tests/runtests.sh - -# The Cleaner -clean: - rm -rf TAGS build $(OBJECTS) $(TESTS) $(PROGRAMS) - rm -f tests/tests.log - find . -name "*.gc" -exec rm {} \; - rm -rf `find . -name "*.dSYM" -print` - rm -rf nserver.db - -# The Install -install: all - install -d $(DESTDIR)/$(PREFIX)/lib/ - install $(TARGET) $(DESTDIR)/$(PREFIX)/lib/ - -# Generate TAGS file -TAGS: $(SOURCES) $(TEST_SRC) - find ./ -type f -name '*.h' -or -name '*.c' | $(CTAGS) -e -L - - -# The Checker -check: - @echo Files with potentially dangerous functions. - @egrep '[^_.>a-zA-Z0-9](str(n?cpy|n?cat|xfrm|n?dup|str|pbrk|tok|_)\ - |stpn?cpy|a?sn?printf|byte_)' $(SOURCES) || true diff --git a/nserver/README.md b/nserver/README.md @@ -1,71 +0,0 @@ -# nserver - -A nihilistic stats server written is part of reading Learn C the -Harday. - - -## compiling - -You'll need a C compiler (clang or gcc), the [gdbm][1] library and -[GNU make][2]. - -[1]: https://www.gnu.org.ua/software/gdbm -[2]: https://www.gnu.org/software/make - -To compile the server, do: - -``` -make -``` - -To compile a debuggable version of the server, do: - -``` -make dev -``` - -The usual: - -``` -make clean -``` - -clean up things. - - -## statserve - -To start this server, do: - -``` -./bin/statserve -``` - -It'll be listening on port 7899. - -You can connect as a client to the server via `nc`: - -``` -nc 127.0.0.1 7899 -``` - - -### client commands - -Recognized commands: - - -``` -/create NAME -/sample NAME -/mean NAME -/dump NAME -/list -/store NAME -/load NAME ANOTHER_NAME -``` - -The `/store` command stores `NAME` in a persistent database on the disk. - -The `/load` command loads the `NAME` from the persistent database into -memory at ANOTHER_NAME. diff --git a/nserver/bin/statserve.c b/nserver/bin/statserve.c @@ -1,54 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#include <nserve.h> -#include <nsocket.h> - -#define BACKLOG 10 - -int main(void) -{ - int rc = 0; - int sockfd_s = 0, sockfd_c = 0; - struct sockaddr sockaddr_c; - socklen_t sockaddr_c_len; - pid_t pidc; - - sockfd_s = get_socket(); - check(sockfd_s > 0, "stateserv: unable to get socket"); - - rc = listen(sockfd_s, BACKLOG); - check(rc == 0, "statserve: listen failed"); - - do { - printf("Waiting for connection...\n"); - sockfd_c = accept(sockfd_s, &sockaddr_c, &sockaddr_c_len); - - pidc = fork(); - check(pidc != -1, "statserve: fork failed"); - - if (pidc == 0) { - nserve(sockfd_c); - } - - rc = close(sockfd_c); - check(rc == 0, "statserv: close failed"); - } while(1); - - rc = close(sockfd_s); - check(rc == 0, "statserv: close failed"); - - return 0; - - error: - if (sockfd_s) { - rc = close(sockfd_s); - } - if (sockfd_c) { - rc = close(sockfd_c); - } - - return -1; -} diff --git a/nserver/src/bstrlib.c b/nserver/src/bstrlib.c @@ -1,3149 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2014 Paul Hsieh - * Copyright © 2020 rsiddharth - */ - -/* - * This is a slightly modified version of bstrlib.c from the bstrlib - * library (https://github.com/websnarf/bstrlib/releases/tag/v1.0.0). - */ - -/* - * This source file is part of the bstring string library. This code was - * written by Paul Hsieh in 2002-2015, and is covered by the BSD open source - * license and the GPL. Refer to the accompanying documentation for details - * on usage and license. - */ - -/* - * bstrlib.c - * - * This file is the core module for implementing the bstring functions. - */ - -#if defined (_MSC_VER) -# define _CRT_SECURE_NO_WARNINGS -#endif - -#include <stdio.h> -#include <stddef.h> -#include <stdarg.h> -#include <stdlib.h> -#include <string.h> -#include <ctype.h> -#include <limits.h> -#include <bstrlib.h> - -/* Optionally include a mechanism for debugging memory */ - -#if defined(MEMORY_DEBUG) || defined(BSTRLIB_MEMORY_DEBUG) -#include "memdbg.h" -#endif - -#ifndef bstr__alloc -#if defined (BSTRLIB_TEST_CANARY) -void* bstr__alloc (size_t sz) { - char* p = (char *) malloc (sz); - memset (p, 'X', sz); - return p; -} -#else -#define bstr__alloc(x) malloc (x) -#endif -#endif - -#ifndef bstr__free -#define bstr__free(p) free (p) -#endif - -#ifndef bstr__realloc -#define bstr__realloc(p,x) realloc ((p), (x)) -#endif - -#ifndef bstr__memcpy -#define bstr__memcpy(d,s,l) memcpy ((d), (s), (l)) -#endif - -#ifndef bstr__memmove -#define bstr__memmove(d,s,l) memmove ((d), (s), (l)) -#endif - -#ifndef bstr__memset -#define bstr__memset(d,c,l) memset ((d), (c), (l)) -#endif - -#ifndef bstr__memcmp -#define bstr__memcmp(d,c,l) memcmp ((d), (c), (l)) -#endif - -#ifndef bstr__memchr -#define bstr__memchr(s,c,l) memchr ((s), (c), (l)) -#endif - -/* Just a length safe wrapper for memmove. */ - -#define bBlockCopy(D,S,L) { if ((L) > 0) bstr__memmove ((D),(S),(L)); } - -/* Compute the snapped size for a given requested size. By snapping to powers - of 2 like this, repeated reallocations are avoided. */ -static int snapUpSize (int i) { - if (i < 8) { - i = 8; - } else { - unsigned int j; - j = (unsigned int) i; - - j |= (j >> 1); - j |= (j >> 2); - j |= (j >> 4); - j |= (j >> 8); /* Ok, since int >= 16 bits */ -#if (UINT_MAX != 0xffff) - j |= (j >> 16); /* For 32 bit int systems */ -#if (UINT_MAX > 0xffffffffUL) - j |= (j >> 32); /* For 64 bit int systems */ -#endif -#endif - /* Least power of two greater than i */ - j++; - if ((int) j >= i) i = (int) j; - } - return i; -} - -/* int balloc (bstring b, int len) - * - * Increase the size of the memory backing the bstring b to at least len. - */ -int balloc (bstring b, int olen) { - int len; - if (b == NULL || b->data == NULL || b->slen < 0 || b->mlen <= 0 || - b->mlen < b->slen || olen <= 0) { - return BSTR_ERR; - } - - if (olen >= b->mlen) { - unsigned char * x; - - if ((len = snapUpSize (olen)) <= b->mlen) return BSTR_OK; - - /* Assume probability of a non-moving realloc is 0.125 */ - if (7 * b->mlen < 8 * b->slen) { - - /* If slen is close to mlen in size then use realloc to reduce - the memory defragmentation */ - - reallocStrategy:; - - x = (unsigned char *) bstr__realloc (b->data, (size_t) len); - if (x == NULL) { - - /* Since we failed, try allocating the tighest possible - allocation */ - - len = olen; - x = (unsigned char *) bstr__realloc (b->data, (size_t) olen); - if (NULL == x) { - return BSTR_ERR; - } - } - } else { - - /* If slen is not close to mlen then avoid the penalty of copying - the extra bytes that are allocated, but not considered part of - the string */ - - if (NULL == (x = (unsigned char *) bstr__alloc ((size_t) len))) { - - /* Perhaps there is no available memory for the two - allocations to be in memory at once */ - - goto reallocStrategy; - - } else { - if (b->slen) bstr__memcpy ((char *) x, (char *) b->data, - (size_t) b->slen); - bstr__free (b->data); - } - } - b->data = x; - b->mlen = len; - b->data[b->slen] = (unsigned char) '\0'; - -#if defined (BSTRLIB_TEST_CANARY) - if (len > b->slen + 1) { - memchr (b->data + b->slen + 1, 'X', len - (b->slen + 1)); - } -#endif - } - - return BSTR_OK; -} - -/* int ballocmin (bstring b, int len) - * - * Set the size of the memory backing the bstring b to len or b->slen+1, - * whichever is larger. Note that repeated use of this function can degrade - * performance. - */ -int ballocmin (bstring b, int len) { - unsigned char * s; - - if (b == NULL || b->data == NULL) return BSTR_ERR; - if (b->slen >= INT_MAX || b->slen < 0) return BSTR_ERR; - if (b->mlen <= 0 || b->mlen < b->slen || len <= 0) { - return BSTR_ERR; - } - - if (len < b->slen + 1) len = b->slen + 1; - - if (len != b->mlen) { - s = (unsigned char *) bstr__realloc (b->data, (size_t) len); - if (NULL == s) return BSTR_ERR; - s[b->slen] = (unsigned char) '\0'; - b->data = s; - b->mlen = len; - } - - return BSTR_OK; -} - -/* bstring bfromcstr (const char * str) - * - * Create a bstring which contains the contents of the '\0' terminated char * - * buffer str. - */ -bstring bfromcstr (const char * str) { -bstring b; -int i; -size_t j; - - if (str == NULL) return NULL; - j = (strlen) (str); - i = snapUpSize ((int) (j + (2 - (j != 0)))); - if (i <= (int) j) return NULL; - - b = (bstring) bstr__alloc (sizeof (struct tagbstring)); - if (NULL == b) return NULL; - b->slen = (int) j; - if (NULL == (b->data = (unsigned char *) bstr__alloc (b->mlen = i))) { - bstr__free (b); - return NULL; - } - - bstr__memcpy (b->data, str, j+1); - return b; -} - -/* bstring bfromcstrrangealloc (int minl, int maxl, const char* str) - * - * Create a bstring which contains the contents of the '\0' terminated - * char* buffer str. The memory buffer backing the string is at least - * minl characters in length, but an attempt is made to allocate up to - * maxl characters. - */ -bstring bfromcstrrangealloc (int minl, int maxl, const char* str) { -bstring b; -int i; -size_t j; - - /* Bad parameters? */ - if (str == NULL) return NULL; - if (maxl < minl || minl < 0) return NULL; - - /* Adjust lengths */ - j = (strlen) (str); - if ((size_t) minl < (j+1)) minl = (int) (j+1); - if (maxl < minl) maxl = minl; - i = maxl; - - b = (bstring) bstr__alloc (sizeof (struct tagbstring)); - if (b == NULL) return NULL; - b->slen = (int) j; - - while (NULL == (b->data = (unsigned char *) bstr__alloc (b->mlen = i))) { - int k = (i >> 1) + (minl >> 1); - if (i == k || i < minl) { - bstr__free (b); - return NULL; - } - i = k; - } - - bstr__memcpy (b->data, str, j+1); - return b; -} - -/* bstring bfromcstralloc (int mlen, const char * str) - * - * Create a bstring which contains the contents of the '\0' terminated - * char* buffer str. The memory buffer backing the string is at least - * mlen characters in length. - */ -bstring bfromcstralloc (int mlen, const char * str) { - return bfromcstrrangealloc (mlen, mlen, str); -} - -/* bstring blk2bstr (const void * blk, int len) - * - * Create a bstring which contains the content of the block blk of length - * len. - */ -bstring blk2bstr (const void * blk, int len) { -bstring b; -int i; - - if (blk == NULL || len < 0) return NULL; - b = (bstring) bstr__alloc (sizeof (struct tagbstring)); - if (b == NULL) return NULL; - b->slen = len; - - i = len + (2 - (len != 0)); - i = snapUpSize (i); - - b->mlen = i; - - b->data = (unsigned char *) bstr__alloc ((size_t) b->mlen); - if (b->data == NULL) { - bstr__free (b); - return NULL; - } - - if (len > 0) bstr__memcpy (b->data, blk, (size_t) len); - b->data[len] = (unsigned char) '\0'; - - return b; -} - -/* char * bstr2cstr (const_bstring s, char z) - * - * Create a '\0' terminated char * buffer which is equal to the contents of - * the bstring s, except that any contained '\0' characters are converted - * to the character in z. This returned value should be freed with a - * bcstrfree () call, by the calling application. - */ -char * bstr2cstr (const_bstring b, char z) { -int i, l; -char * r; - - if (b == NULL || b->slen < 0 || b->data == NULL) return NULL; - l = b->slen; - r = (char *) bstr__alloc ((size_t) (l + 1)); - if (r == NULL) return r; - - for (i=0; i < l; i ++) { - r[i] = (char) ((b->data[i] == '\0') ? z : (char) (b->data[i])); - } - - r[l] = (unsigned char) '\0'; - - return r; -} - -/* int bcstrfree (char * s) - * - * Frees a C-string generated by bstr2cstr (). This is normally unnecessary - * since it just wraps a call to bstr__free (), however, if bstr__alloc () - * and bstr__free () have been redefined as a macros within the bstrlib - * module (via defining them in memdbg.h after defining - * BSTRLIB_MEMORY_DEBUG) with some difference in behaviour from the std - * library functions, then this allows a correct way of freeing the memory - * that allows higher level code to be independent from these macro - * redefinitions. - */ -int bcstrfree (char * s) { - if (s) { - bstr__free (s); - return BSTR_OK; - } - return BSTR_ERR; -} - -/* int bconcat (bstring b0, const_bstring b1) - * - * Concatenate the bstring b1 to the bstring b0. - */ -int bconcat (bstring b0, const_bstring b1) { -int len, d; -bstring aux = (bstring) b1; - - if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL) - return BSTR_ERR; - - d = b0->slen; - len = b1->slen; - if ((d | (b0->mlen - d) | len | (d + len)) < 0) return BSTR_ERR; - - if (b0->mlen <= d + len + 1) { - ptrdiff_t pd = b1->data - b0->data; - if (0 <= pd && pd < b0->mlen) { - if (NULL == (aux = bstrcpy (b1))) return BSTR_ERR; - } - if (balloc (b0, d + len + 1) != BSTR_OK) { - if (aux != b1) bdestroy (aux); - return BSTR_ERR; - } - } - - bBlockCopy (&b0->data[d], &aux->data[0], (size_t) len); - b0->data[d + len] = (unsigned char) '\0'; - b0->slen = d + len; - if (aux != b1) bdestroy (aux); - return BSTR_OK; -} - -/* int bconchar (bstring b, char c) - * - * Concatenate the single character c to the bstring b. - */ -int bconchar (bstring b, char c) { -int d; - - if (b == NULL) return BSTR_ERR; - d = b->slen; - if ((d | (b->mlen - d)) < 0 || balloc (b, d + 2) != BSTR_OK) - return BSTR_ERR; - b->data[d] = (unsigned char) c; - b->data[d + 1] = (unsigned char) '\0'; - b->slen++; - return BSTR_OK; -} - -/* int bcatcstr (bstring b, const char * s) - * - * Concatenate a char * string to a bstring. - */ -int bcatcstr (bstring b, const char * s) { -char * d; -int i, l; - - if (b == NULL || b->data == NULL || b->slen < 0 || b->mlen < b->slen - || b->mlen <= 0 || s == NULL) return BSTR_ERR; - - /* Optimistically concatenate directly */ - l = b->mlen - b->slen; - d = (char *) &b->data[b->slen]; - for (i=0; i < l; i++) { - if ((*d++ = *s++) == '\0') { - b->slen += i; - return BSTR_OK; - } - } - b->slen += i; - - /* Need to explicitely resize and concatenate tail */ - return bcatblk (b, (const void *) s, (int) strlen (s)); -} - -/* int bcatblk (bstring b, const void * s, int len) - * - * Concatenate a fixed length buffer to a bstring. - */ -int bcatblk (bstring b, const void * s, int len) { -int nl; - - if (b == NULL || b->data == NULL || b->slen < 0 || b->mlen < b->slen - || b->mlen <= 0 || s == NULL || len < 0) return BSTR_ERR; - - if (0 > (nl = b->slen + len)) return BSTR_ERR; /* Overflow? */ - if (b->mlen <= nl && 0 > balloc (b, nl + 1)) return BSTR_ERR; - - bBlockCopy (&b->data[b->slen], s, (size_t) len); - b->slen = nl; - b->data[nl] = (unsigned char) '\0'; - return BSTR_OK; -} - -/* bstring bstrcpy (const_bstring b) - * - * Create a copy of the bstring b. - */ -bstring bstrcpy (const_bstring b) { -bstring b0; -int i,j; - - /* Attempted to copy an invalid string? */ - if (b == NULL || b->slen < 0 || b->data == NULL) return NULL; - - b0 = (bstring) bstr__alloc (sizeof (struct tagbstring)); - if (b0 == NULL) { - /* Unable to allocate memory for string header */ - return NULL; - } - - i = b->slen; - j = snapUpSize (i + 1); - - b0->data = (unsigned char *) bstr__alloc (j); - if (b0->data == NULL) { - j = i + 1; - b0->data = (unsigned char *) bstr__alloc (j); - if (b0->data == NULL) { - /* Unable to allocate memory for string data */ - bstr__free (b0); - return NULL; - } - } - - b0->mlen = j; - b0->slen = i; - - if (i) bstr__memcpy ((char *) b0->data, (char *) b->data, i); - b0->data[b0->slen] = (unsigned char) '\0'; - - return b0; -} - -/* int bassign (bstring a, const_bstring b) - * - * Overwrite the string a with the contents of string b. - */ -int bassign (bstring a, const_bstring b) { - if (b == NULL || b->data == NULL || b->slen < 0) - return BSTR_ERR; - if (b->slen != 0) { - if (balloc (a, b->slen) != BSTR_OK) return BSTR_ERR; - bstr__memmove (a->data, b->data, b->slen); - } else { - if (a == NULL || a->data == NULL || a->mlen < a->slen || - a->slen < 0 || a->mlen == 0) - return BSTR_ERR; - } - a->data[b->slen] = (unsigned char) '\0'; - a->slen = b->slen; - return BSTR_OK; -} - -/* int bassignmidstr (bstring a, const_bstring b, int left, int len) - * - * Overwrite the string a with the middle of contents of string b - * starting from position left and running for a length len. left and - * len are clamped to the ends of b as with the function bmidstr. - */ -int bassignmidstr (bstring a, const_bstring b, int left, int len) { - if (b == NULL || b->data == NULL || b->slen < 0) - return BSTR_ERR; - - if (left < 0) { - len += left; - left = 0; - } - - if (len > b->slen - left) len = b->slen - left; - - if (a == NULL || a->data == NULL || a->mlen < a->slen || - a->slen < 0 || a->mlen == 0) - return BSTR_ERR; - - if (len > 0) { - if (balloc (a, len) != BSTR_OK) return BSTR_ERR; - bstr__memmove (a->data, b->data + left, len); - a->slen = len; - } else { - a->slen = 0; - } - a->data[a->slen] = (unsigned char) '\0'; - return BSTR_OK; -} - -/* int bassigncstr (bstring a, const char * str) - * - * Overwrite the string a with the contents of char * string str. Note that - * the bstring a must be a well defined and writable bstring. If an error - * occurs BSTR_ERR is returned however a may be partially overwritten. - */ -int bassigncstr (bstring a, const char * str) { -int i; -size_t len; - if (a == NULL || a->data == NULL || a->mlen < a->slen || - a->slen < 0 || a->mlen == 0 || NULL == str) - return BSTR_ERR; - - for (i=0; i < a->mlen; i++) { - if ('\0' == (a->data[i] = str[i])) { - a->slen = i; - return BSTR_OK; - } - } - - a->slen = i; - len = strlen (str + i); - if (len + 1 > (size_t) INT_MAX - i || - 0 > balloc (a, (int) (i + len + 1))) return BSTR_ERR; - bBlockCopy (a->data + i, str + i, (size_t) len + 1); - a->slen += (int) len; - return BSTR_OK; -} - -/* int bassignblk (bstring a, const void * s, int len) - * - * Overwrite the string a with the contents of the block (s, len). Note that - * the bstring a must be a well defined and writable bstring. If an error - * occurs BSTR_ERR is returned and a is not overwritten. - */ -int bassignblk (bstring a, const void * s, int len) { - if (a == NULL || a->data == NULL || a->mlen < a->slen || - a->slen < 0 || a->mlen == 0 || NULL == s || len < 0 || len >= INT_MAX) - return BSTR_ERR; - if (len + 1 > a->mlen && 0 > balloc (a, len + 1)) return BSTR_ERR; - bBlockCopy (a->data, s, (size_t) len); - a->data[len] = (unsigned char) '\0'; - a->slen = len; - return BSTR_OK; -} - -/* int btrunc (bstring b, int n) - * - * Truncate the bstring to at most n characters. - */ -int btrunc (bstring b, int n) { - if (n < 0 || b == NULL || b->data == NULL || b->mlen < b->slen || - b->slen < 0 || b->mlen <= 0) return BSTR_ERR; - if (b->slen > n) { - b->slen = n; - b->data[n] = (unsigned char) '\0'; - } - return BSTR_OK; -} - -#define upcase(c) (toupper ((unsigned char) c)) -#define downcase(c) (tolower ((unsigned char) c)) -#define wspace(c) (isspace ((unsigned char) c)) - -/* int btoupper (bstring b) - * - * Convert contents of bstring to upper case. - */ -int btoupper (bstring b) { -int i, len; - if (b == NULL || b->data == NULL || b->mlen < b->slen || - b->slen < 0 || b->mlen <= 0) return BSTR_ERR; - for (i=0, len = b->slen; i < len; i++) { - b->data[i] = (unsigned char) upcase (b->data[i]); - } - return BSTR_OK; -} - -/* int btolower (bstring b) - * - * Convert contents of bstring to lower case. - */ -int btolower (bstring b) { -int i, len; - if (b == NULL || b->data == NULL || b->mlen < b->slen || - b->slen < 0 || b->mlen <= 0) return BSTR_ERR; - for (i=0, len = b->slen; i < len; i++) { - b->data[i] = (unsigned char) downcase (b->data[i]); - } - return BSTR_OK; -} - -/* int bstricmp (const_bstring b0, const_bstring b1) - * - * Compare two strings without differentiating between case. The return - * value is the difference of the values of the characters where the two - * strings first differ after lower case transformation, otherwise 0 is - * returned indicating that the strings are equal. If the lengths are - * different, then a difference from 0 is given, but if the first extra - * character is '\0', then it is taken to be the value UCHAR_MAX+1. - */ -int bstricmp (const_bstring b0, const_bstring b1) { -int i, v, n; - - if (bdata (b0) == NULL || b0->slen < 0 || - bdata (b1) == NULL || b1->slen < 0) return SHRT_MIN; - if ((n = b0->slen) > b1->slen) n = b1->slen; - else if (b0->slen == b1->slen && b0->data == b1->data) return BSTR_OK; - - for (i = 0; i < n; i ++) { - v = (char) downcase (b0->data[i]) - - (char) downcase (b1->data[i]); - if (0 != v) return v; - } - - if (b0->slen > n) { - v = (char) downcase (b0->data[n]); - if (v) return v; - return UCHAR_MAX + 1; - } - if (b1->slen > n) { - v = - (char) downcase (b1->data[n]); - if (v) return v; - return - (int) (UCHAR_MAX + 1); - } - return BSTR_OK; -} - -/* int bstrnicmp (const_bstring b0, const_bstring b1, int n) - * - * Compare two strings without differentiating between case for at most n - * characters. If the position where the two strings first differ is - * before the nth position, the return value is the difference of the values - * of the characters, otherwise 0 is returned. If the lengths are different - * and less than n characters, then a difference from 0 is given, but if the - * first extra character is '\0', then it is taken to be the value - * UCHAR_MAX+1. - */ -int bstrnicmp (const_bstring b0, const_bstring b1, int n) { -int i, v, m; - - if (bdata (b0) == NULL || b0->slen < 0 || - bdata (b1) == NULL || b1->slen < 0 || n < 0) return SHRT_MIN; - m = n; - if (m > b0->slen) m = b0->slen; - if (m > b1->slen) m = b1->slen; - - if (b0->data != b1->data) { - for (i = 0; i < m; i ++) { - v = (char) downcase (b0->data[i]); - v -= (char) downcase (b1->data[i]); - if (v != 0) return b0->data[i] - b1->data[i]; - } - } - - if (n == m || b0->slen == b1->slen) return BSTR_OK; - - if (b0->slen > m) { - v = (char) downcase (b0->data[m]); - if (v) return v; - return UCHAR_MAX + 1; - } - - v = - (char) downcase (b1->data[m]); - if (v) return v; - return - (int) (UCHAR_MAX + 1); -} - -/* int biseqcaselessblk (const_bstring b, const void * blk, int len) - * - * Compare content of b and the array of bytes in blk for length len for - * equality without differentiating between character case. If the content - * differs other than in case, 0 is returned, if, ignoring case, the content - * is the same, 1 is returned, if there is an error, -1 is returned. If the - * length of the strings are different, this function is O(1). '\0' - * characters are not treated in any special way. - */ -int biseqcaselessblk (const_bstring b, const void * blk, int len) { -int i; - - if (bdata (b) == NULL || b->slen < 0 || - blk == NULL || len < 0) return BSTR_ERR; - if (b->slen != len) return 0; - if (len == 0 || b->data == blk) return 1; - for (i=0; i < len; i++) { - if (b->data[i] != ((unsigned char*)blk)[i]) { - unsigned char c = (unsigned char) downcase (b->data[i]); - if (c != (unsigned char) downcase (((unsigned char*)blk)[i])) - return 0; - } - } - return 1; -} - - -/* int biseqcaseless (const_bstring b0, const_bstring b1) - * - * Compare two strings for equality without differentiating between case. - * If the strings differ other than in case, 0 is returned, if the strings - * are the same, 1 is returned, if there is an error, -1 is returned. If - * the length of the strings are different, this function is O(1). '\0' - * termination characters are not treated in any special way. - */ -int biseqcaseless (const_bstring b0, const_bstring b1) { - if (NULL == b1) return BSTR_ERR; - return biseqcaselessblk (b0, b1->data, b1->slen); -} - -/* int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len) - * - * Compare beginning of string b0 with a block of memory of length len - * without differentiating between case for equality. If the beginning of b0 - * differs from the memory block other than in case (or if b0 is too short), - * 0 is returned, if the strings are the same, 1 is returned, if there is an - * error, -1 is returned. '\0' characters are not treated in any special - * way. - */ -int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len) { -int i; - - if (bdata (b0) == NULL || b0->slen < 0 || NULL == blk || len < 0) - return BSTR_ERR; - if (b0->slen < len) return BSTR_OK; - if (b0->data == (const unsigned char *) blk || len == 0) return 1; - - for (i = 0; i < len; i ++) { - if (b0->data[i] != ((const unsigned char *) blk)[i]) { - if (downcase (b0->data[i]) != - downcase (((const unsigned char *) blk)[i])) return 0; - } - } - return 1; -} - -/* - * int bltrimws (bstring b) - * - * Delete whitespace contiguous from the left end of the string. - */ -int bltrimws (bstring b) { -int i, len; - - if (b == NULL || b->data == NULL || b->mlen < b->slen || - b->slen < 0 || b->mlen <= 0) return BSTR_ERR; - - for (len = b->slen, i = 0; i < len; i++) { - if (!wspace (b->data[i])) { - return bdelete (b, 0, i); - } - } - - b->data[0] = (unsigned char) '\0'; - b->slen = 0; - return BSTR_OK; -} - -/* - * int brtrimws (bstring b) - * - * Delete whitespace contiguous from the right end of the string. - */ -int brtrimws (bstring b) { -int i; - - if (b == NULL || b->data == NULL || b->mlen < b->slen || - b->slen < 0 || b->mlen <= 0) return BSTR_ERR; - - for (i = b->slen - 1; i >= 0; i--) { - if (!wspace (b->data[i])) { - if (b->mlen > i) b->data[i+1] = (unsigned char) '\0'; - b->slen = i + 1; - return BSTR_OK; - } - } - - b->data[0] = (unsigned char) '\0'; - b->slen = 0; - return BSTR_OK; -} - -/* - * int btrimws (bstring b) - * - * Delete whitespace contiguous from both ends of the string. - */ -int btrimws (bstring b) { -int i, j; - - if (b == NULL || b->data == NULL || b->mlen < b->slen || - b->slen < 0 || b->mlen <= 0) return BSTR_ERR; - - for (i = b->slen - 1; i >= 0; i--) { - if (!wspace (b->data[i])) { - if (b->mlen > i) b->data[i+1] = (unsigned char) '\0'; - b->slen = i + 1; - for (j = 0; wspace (b->data[j]); j++) {} - return bdelete (b, 0, j); - } - } - - b->data[0] = (unsigned char) '\0'; - b->slen = 0; - return BSTR_OK; -} - -/* int biseqblk (const_bstring b, const void * blk, int len) - * - * Compare the string b with the character block blk of length len. If the - * content differs, 0 is returned, if the content is the same, 1 is returned, - * if there is an error, -1 is returned. If the length of the strings are - * different, this function is O(1). '\0' characters are not treated in any - * special way. - */ -int biseqblk (const_bstring b, const void * blk, int len) { - if (len < 0 || b == NULL || blk == NULL || b->data == NULL || b->slen < 0) - return BSTR_ERR; - if (b->slen != len) return 0; - if (len == 0 || b->data == blk) return 1; - return !bstr__memcmp (b->data, blk, len); -} - -/* int biseq (const_bstring b0, const_bstring b1) - * - * Compare the string b0 and b1. If the strings differ, 0 is returned, if - * the strings are the same, 1 is returned, if there is an error, -1 is - * returned. If the length of the strings are different, this function is - * O(1). '\0' termination characters are not treated in any special way. - */ -int biseq (const_bstring b0, const_bstring b1) { - if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL || - b0->slen < 0 || b1->slen < 0) return BSTR_ERR; - if (b0->slen != b1->slen) return BSTR_OK; - if (b0->data == b1->data || b0->slen == 0) return 1; - return !bstr__memcmp (b0->data, b1->data, b0->slen); -} - -/* int bisstemeqblk (const_bstring b0, const void * blk, int len) - * - * Compare beginning of string b0 with a block of memory of length len for - * equality. If the beginning of b0 differs from the memory block (or if b0 - * is too short), 0 is returned, if the strings are the same, 1 is returned, - * if there is an error, -1 is returned. '\0' characters are not treated in - * any special way. - */ -int bisstemeqblk (const_bstring b0, const void * blk, int len) { -int i; - - if (bdata (b0) == NULL || b0->slen < 0 || NULL == blk || len < 0) - return BSTR_ERR; - if (b0->slen < len) return BSTR_OK; - if (b0->data == (const unsigned char *) blk || len == 0) return 1; - - for (i = 0; i < len; i ++) { - if (b0->data[i] != ((const unsigned char *) blk)[i]) return BSTR_OK; - } - return 1; -} - -/* int biseqcstr (const_bstring b, const char *s) - * - * Compare the bstring b and char * string s. The C string s must be '\0' - * terminated at exactly the length of the bstring b, and the contents - * between the two must be identical with the bstring b with no '\0' - * characters for the two contents to be considered equal. This is - * equivalent to the condition that their current contents will be always be - * equal when comparing them in the same format after converting one or the - * other. If the strings are equal 1 is returned, if they are unequal 0 is - * returned and if there is a detectable error BSTR_ERR is returned. - */ -int biseqcstr (const_bstring b, const char * s) { -int i; - if (b == NULL || s == NULL || b->data == NULL || b->slen < 0) - return BSTR_ERR; - for (i=0; i < b->slen; i++) { - if (s[i] == '\0' || b->data[i] != (unsigned char) s[i]) - return BSTR_OK; - } - return s[i] == '\0'; -} - -/* int biseqcstrcaseless (const_bstring b, const char *s) - * - * Compare the bstring b and char * string s. The C string s must be '\0' - * terminated at exactly the length of the bstring b, and the contents - * between the two must be identical except for case with the bstring b with - * no '\0' characters for the two contents to be considered equal. This is - * equivalent to the condition that their current contents will be always be - * equal ignoring case when comparing them in the same format after - * converting one or the other. If the strings are equal, except for case, - * 1 is returned, if they are unequal regardless of case 0 is returned and - * if there is a detectable error BSTR_ERR is returned. - */ -int biseqcstrcaseless (const_bstring b, const char * s) { -int i; - if (b == NULL || s == NULL || b->data == NULL || b->slen < 0) - return BSTR_ERR; - for (i=0; i < b->slen; i++) { - if (s[i] == '\0' || - (b->data[i] != (unsigned char) s[i] && - downcase (b->data[i]) != (unsigned char) downcase (s[i]))) - return BSTR_OK; - } - return s[i] == '\0'; -} - -/* int bstrcmp (const_bstring b0, const_bstring b1) - * - * Compare the string b0 and b1. If there is an error, SHRT_MIN is returned, - * otherwise a value less than or greater than zero, indicating that the - * string pointed to by b0 is lexicographically less than or greater than - * the string pointed to by b1 is returned. If the the string lengths are - * unequal but the characters up until the length of the shorter are equal - * then a value less than, or greater than zero, indicating that the string - * pointed to by b0 is shorter or longer than the string pointed to by b1 is - * returned. 0 is returned if and only if the two strings are the same. If - * the length of the strings are different, this function is O(n). Like its - * standard C library counter part strcmp, the comparison does not proceed - * past any '\0' termination characters encountered. - */ -int bstrcmp (const_bstring b0, const_bstring b1) { -int i, v, n; - - if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL || - b0->slen < 0 || b1->slen < 0) return SHRT_MIN; - n = b0->slen; if (n > b1->slen) n = b1->slen; - if (b0->slen == b1->slen && (b0->data == b1->data || b0->slen == 0)) - return BSTR_OK; - - for (i = 0; i < n; i ++) { - v = ((char) b0->data[i]) - ((char) b1->data[i]); - if (v != 0) return v; - if (b0->data[i] == (unsigned char) '\0') return BSTR_OK; - } - - if (b0->slen > n) return 1; - if (b1->slen > n) return -1; - return BSTR_OK; -} - -/* int bstrncmp (const_bstring b0, const_bstring b1, int n) - * - * Compare the string b0 and b1 for at most n characters. If there is an - * error, SHRT_MIN is returned, otherwise a value is returned as if b0 and - * b1 were first truncated to at most n characters then bstrcmp was called - * with these new strings are paremeters. If the length of the strings are - * different, this function is O(n). Like its standard C library counter - * part strcmp, the comparison does not proceed past any '\0' termination - * characters encountered. - */ -int bstrncmp (const_bstring b0, const_bstring b1, int n) { -int i, v, m; - - if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL || - b0->slen < 0 || b1->slen < 0) return SHRT_MIN; - m = n; - if (m > b0->slen) m = b0->slen; - if (m > b1->slen) m = b1->slen; - - if (b0->data != b1->data) { - for (i = 0; i < m; i ++) { - v = ((char) b0->data[i]) - ((char) b1->data[i]); - if (v != 0) return v; - if (b0->data[i] == (unsigned char) '\0') return BSTR_OK; - } - } - - if (n == m || b0->slen == b1->slen) return BSTR_OK; - - if (b0->slen > m) return 1; - return -1; -} - -/* bstring bmidstr (const_bstring b, int left, int len) - * - * Create a bstring which is the substring of b starting from position left - * and running for a length len (clamped by the end of the bstring b.) If - * b is detectably invalid, then NULL is returned. The section described - * by (left, len) is clamped to the boundaries of b. - */ -bstring bmidstr (const_bstring b, int left, int len) { - - if (b == NULL || b->slen < 0 || b->data == NULL) return NULL; - - if (left < 0) { - len += left; - left = 0; - } - - if (len > b->slen - left) len = b->slen - left; - - if (len <= 0) return bfromcstr (""); - return blk2bstr (b->data + left, len); -} - -/* int bdelete (bstring b, int pos, int len) - * - * Removes characters from pos to pos+len-1 inclusive and shifts the tail of - * the bstring starting from pos+len to pos. len must be positive for this - * call to have any effect. The section of the string described by (pos, - * len) is clamped to boundaries of the bstring b. - */ -int bdelete (bstring b, int pos, int len) { - /* Clamp to left side of bstring */ - if (pos < 0) { - len += pos; - pos = 0; - } - - if (len < 0 || b == NULL || b->data == NULL || b->slen < 0 || - b->mlen < b->slen || b->mlen <= 0) - return BSTR_ERR; - if (len > 0 && pos < b->slen) { - if (pos + len >= b->slen) { - b->slen = pos; - } else { - bBlockCopy ((char *) (b->data + pos), - (char *) (b->data + pos + len), - b->slen - (pos+len)); - b->slen -= len; - } - b->data[b->slen] = (unsigned char) '\0'; - } - return BSTR_OK; -} - -/* int bdestroy (bstring b) - * - * Free up the bstring. Note that if b is detectably invalid or not writable - * then no action is performed and BSTR_ERR is returned. Like a freed memory - * allocation, dereferences, writes or any other action on b after it has - * been bdestroyed is undefined. - */ -int bdestroy (bstring b) { - if (b == NULL || b->slen < 0 || b->mlen <= 0 || b->mlen < b->slen || - b->data == NULL) - return BSTR_ERR; - - bstr__free (b->data); - - /* In case there is any stale usage, there is one more chance to - notice this error. */ - - b->slen = -1; - b->mlen = -__LINE__; - b->data = NULL; - - bstr__free (b); - return BSTR_OK; -} - -/* int binstr (const_bstring b1, int pos, const_bstring b2) - * - * Search for the bstring b2 in b1 starting from position pos, and searching - * forward. If it is found then return with the first position where it is - * found, otherwise return BSTR_ERR. Note that this is just a brute force - * string searcher that does not attempt clever things like the Boyer-Moore - * search algorithm. Because of this there are many degenerate cases where - * this can take much longer than it needs to. - */ -int binstr (const_bstring b1, int pos, const_bstring b2) { -int j, ii, ll, lf; -unsigned char * d0; -unsigned char c0; -register unsigned char * d1; -register unsigned char c1; -register int i; - - if (b1 == NULL || b1->data == NULL || b1->slen < 0 || - b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR; - if (b1->slen == pos) return (b2->slen == 0)?pos:BSTR_ERR; - if (b1->slen < pos || pos < 0) return BSTR_ERR; - if (b2->slen == 0) return pos; - - /* No space to find such a string? */ - if ((lf = b1->slen - b2->slen + 1) <= pos) return BSTR_ERR; - - /* An obvious alias case */ - if (b1->data == b2->data && pos == 0) return 0; - - i = pos; - - d0 = b2->data; - d1 = b1->data; - ll = b2->slen; - - /* Peel off the b2->slen == 1 case */ - c0 = d0[0]; - if (1 == ll) { - for (;i < lf; i++) if (c0 == d1[i]) return i; - return BSTR_ERR; - } - - c1 = c0; - j = 0; - lf = b1->slen - 1; - - ii = -1; - if (i < lf) do { - /* Unrolled current character test */ - if (c1 != d1[i]) { - if (c1 != d1[1+i]) { - i += 2; - continue; - } - i++; - } - - /* Take note if this is the start of a potential match */ - if (0 == j) ii = i; - - /* Shift the test character down by one */ - j++; - i++; - - /* If this isn't past the last character continue */ - if (j < ll) { - c1 = d0[j]; - continue; - } - - N0:; - - /* If no characters mismatched, then we matched */ - if (i == ii+j) return ii; - - /* Shift back to the beginning */ - i -= j; - j = 0; - c1 = c0; - } while (i < lf); - - /* Deal with last case if unrolling caused a misalignment */ - if (i == lf && ll == j+1 && c1 == d1[i]) goto N0; - - return BSTR_ERR; -} - -/* int binstrr (const_bstring b1, int pos, const_bstring b2) - * - * Search for the bstring b2 in b1 starting from position pos, and searching - * backward. If it is found then return with the first position where it is - * found, otherwise return BSTR_ERR. Note that this is just a brute force - * string searcher that does not attempt clever things like the Boyer-Moore - * search algorithm. Because of this there are many degenerate cases where - * this can take much longer than it needs to. - */ -int binstrr (const_bstring b1, int pos, const_bstring b2) { -int j, i, l; -unsigned char * d0, * d1; - - if (b1 == NULL || b1->data == NULL || b1->slen < 0 || - b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR; - if (b1->slen == pos && b2->slen == 0) return pos; - if (b1->slen < pos || pos < 0) return BSTR_ERR; - if (b2->slen == 0) return pos; - - /* Obvious alias case */ - if (b1->data == b2->data && pos == 0 && b2->slen <= b1->slen) return 0; - - i = pos; - if ((l = b1->slen - b2->slen) < 0) return BSTR_ERR; - - /* If no space to find such a string then snap back */ - if (l + 1 <= i) i = l; - j = 0; - - d0 = b2->data; - d1 = b1->data; - l = b2->slen; - - for (;;) { - if (d0[j] == d1[i + j]) { - j ++; - if (j >= l) return i; - } else { - i --; - if (i < 0) break; - j=0; - } - } - - return BSTR_ERR; -} - -/* int binstrcaseless (const_bstring b1, int pos, const_bstring b2) - * - * Search for the bstring b2 in b1 starting from position pos, and searching - * forward but without regard to case. If it is found then return with the - * first position where it is found, otherwise return BSTR_ERR. Note that - * this is just a brute force string searcher that does not attempt clever - * things like the Boyer-Moore search algorithm. Because of this there are - * many degenerate cases where this can take much longer than it needs to. - */ -int binstrcaseless (const_bstring b1, int pos, const_bstring b2) { -int j, i, l, ll; -unsigned char * d0, * d1; - - if (b1 == NULL || b1->data == NULL || b1->slen < 0 || - b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR; - if (b1->slen == pos) return (b2->slen == 0)?pos:BSTR_ERR; - if (b1->slen < pos || pos < 0) return BSTR_ERR; - if (b2->slen == 0) return pos; - - l = b1->slen - b2->slen + 1; - - /* No space to find such a string? */ - if (l <= pos) return BSTR_ERR; - - /* An obvious alias case */ - if (b1->data == b2->data && pos == 0) return BSTR_OK; - - i = pos; - j = 0; - - d0 = b2->data; - d1 = b1->data; - ll = b2->slen; - - for (;;) { - if (d0[j] == d1[i + j] || downcase (d0[j]) == downcase (d1[i + j])) { - j ++; - if (j >= ll) return i; - } else { - i ++; - if (i >= l) break; - j=0; - } - } - - return BSTR_ERR; -} - -/* int binstrrcaseless (const_bstring b1, int pos, const_bstring b2) - * - * Search for the bstring b2 in b1 starting from position pos, and searching - * backward but without regard to case. If it is found then return with the - * first position where it is found, otherwise return BSTR_ERR. Note that - * this is just a brute force string searcher that does not attempt clever - * things like the Boyer-Moore search algorithm. Because of this there are - * many degenerate cases where this can take much longer than it needs to. - */ -int binstrrcaseless (const_bstring b1, int pos, const_bstring b2) { -int j, i, l; -unsigned char * d0, * d1; - - if (b1 == NULL || b1->data == NULL || b1->slen < 0 || - b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR; - if (b1->slen == pos && b2->slen == 0) return pos; - if (b1->slen < pos || pos < 0) return BSTR_ERR; - if (b2->slen == 0) return pos; - - /* Obvious alias case */ - if (b1->data == b2->data && pos == 0 && b2->slen <= b1->slen) - return BSTR_OK; - - i = pos; - if ((l = b1->slen - b2->slen) < 0) return BSTR_ERR; - - /* If no space to find such a string then snap back */ - if (l + 1 <= i) i = l; - j = 0; - - d0 = b2->data; - d1 = b1->data; - l = b2->slen; - - for (;;) { - if (d0[j] == d1[i + j] || downcase (d0[j]) == downcase (d1[i + j])) { - j ++; - if (j >= l) return i; - } else { - i --; - if (i < 0) break; - j=0; - } - } - - return BSTR_ERR; -} - - -/* int bstrchrp (const_bstring b, int c, int pos) - * - * Search for the character c in b forwards from the position pos - * (inclusive). - */ -int bstrchrp (const_bstring b, int c, int pos) { -unsigned char * p; - - if (b == NULL || b->data == NULL || b->slen <= pos || pos < 0) - return BSTR_ERR; - p = (unsigned char *) bstr__memchr ((b->data + pos), (unsigned char) c, - (b->slen - pos)); - if (p) return (int) (p - b->data); - return BSTR_ERR; -} - -/* int bstrrchrp (const_bstring b, int c, int pos) - * - * Search for the character c in b backwards from the position pos in string - * (inclusive). - */ -int bstrrchrp (const_bstring b, int c, int pos) { -int i; - - if (b == NULL || b->data == NULL || b->slen <= pos || pos < 0) - return BSTR_ERR; - for (i=pos; i >= 0; i--) { - if (b->data[i] == (unsigned char) c) return i; - } - return BSTR_ERR; -} - -#if !defined (BSTRLIB_AGGRESSIVE_MEMORY_FOR_SPEED_TRADEOFF) -#define LONG_LOG_BITS_QTY (3) -#define LONG_BITS_QTY (1 << LONG_LOG_BITS_QTY) -#define LONG_TYPE unsigned char - -#define CFCLEN ((1 << CHAR_BIT) / LONG_BITS_QTY) -struct charField { LONG_TYPE content[CFCLEN]; }; -#define testInCharField(cf,c) ((cf)->content[(c) >> LONG_LOG_BITS_QTY] & \ - (((long)1) << ((c) & (LONG_BITS_QTY-1)))) -#define setInCharField(cf,idx) { \ - unsigned int c = (unsigned int) (idx); \ - (cf)->content[c >> LONG_LOG_BITS_QTY] |= \ - (LONG_TYPE) (1ul << (c & (LONG_BITS_QTY-1))); \ -} - -#else - -#define CFCLEN (1 << CHAR_BIT) -struct charField { unsigned char content[CFCLEN]; }; -#define testInCharField(cf,c) ((cf)->content[(unsigned char) (c)]) -#define setInCharField(cf,idx) (cf)->content[(unsigned int) (idx)] = ~0 - -#endif - -/* Convert a bstring to charField */ -static int buildCharField (struct charField * cf, const_bstring b) { -int i; - if (b == NULL || b->data == NULL || b->slen <= 0) return BSTR_ERR; - memset ((void *) cf->content, 0, sizeof (struct charField)); - for (i=0; i < b->slen; i++) { - setInCharField (cf, b->data[i]); - } - return BSTR_OK; -} - -static void invertCharField (struct charField * cf) { -int i; - for (i=0; i < CFCLEN; i++) cf->content[i] = ~cf->content[i]; -} - -/* Inner engine for binchr */ -static int binchrCF (const unsigned char * data, int len, int pos, - const struct charField * cf) { -int i; - for (i=pos; i < len; i++) { - unsigned char c = (unsigned char) data[i]; - if (testInCharField (cf, c)) return i; - } - return BSTR_ERR; -} - -/* int binchr (const_bstring b0, int pos, const_bstring b1); - * - * Search for the first position in b0 starting from pos or after, in which - * one of the characters in b1 is found and return it. If such a position - * does not exist in b0, then BSTR_ERR is returned. - */ -int binchr (const_bstring b0, int pos, const_bstring b1) { -struct charField chrs; - if (pos < 0 || b0 == NULL || b0->data == NULL || - b0->slen <= pos) return BSTR_ERR; - if (1 == b1->slen) return bstrchrp (b0, b1->data[0], pos); - if (0 > buildCharField (&chrs, b1)) return BSTR_ERR; - return binchrCF (b0->data, b0->slen, pos, &chrs); -} - -/* Inner engine for binchrr */ -static int binchrrCF (const unsigned char * data, int pos, - const struct charField * cf) { -int i; - for (i=pos; i >= 0; i--) { - unsigned int c = (unsigned int) data[i]; - if (testInCharField (cf, c)) return i; - } - return BSTR_ERR; -} - -/* int binchrr (const_bstring b0, int pos, const_bstring b1); - * - * Search for the last position in b0 no greater than pos, in which one of - * the characters in b1 is found and return it. If such a position does not - * exist in b0, then BSTR_ERR is returned. - */ -int binchrr (const_bstring b0, int pos, const_bstring b1) { -struct charField chrs; - if (pos < 0 || b0 == NULL || b0->data == NULL || b1 == NULL || - b0->slen < pos) return BSTR_ERR; - if (pos == b0->slen) pos--; - if (1 == b1->slen) return bstrrchrp (b0, b1->data[0], pos); - if (0 > buildCharField (&chrs, b1)) return BSTR_ERR; - return binchrrCF (b0->data, pos, &chrs); -} - -/* int bninchr (const_bstring b0, int pos, const_bstring b1); - * - * Search for the first position in b0 starting from pos or after, in which - * none of the characters in b1 is found and return it. If such a position - * does not exist in b0, then BSTR_ERR is returned. - */ -int bninchr (const_bstring b0, int pos, const_bstring b1) { -struct charField chrs; - if (pos < 0 || b0 == NULL || b0->data == NULL || - b0->slen <= pos) return BSTR_ERR; - if (buildCharField (&chrs, b1) < 0) return BSTR_ERR; - invertCharField (&chrs); - return binchrCF (b0->data, b0->slen, pos, &chrs); -} - -/* int bninchrr (const_bstring b0, int pos, const_bstring b1); - * - * Search for the last position in b0 no greater than pos, in which none of - * the characters in b1 is found and return it. If such a position does not - * exist in b0, then BSTR_ERR is returned. - */ -int bninchrr (const_bstring b0, int pos, const_bstring b1) { -struct charField chrs; - if (pos < 0 || b0 == NULL || b0->data == NULL || - b0->slen < pos) return BSTR_ERR; - if (pos == b0->slen) pos--; - if (buildCharField (&chrs, b1) < 0) return BSTR_ERR; - invertCharField (&chrs); - return binchrrCF (b0->data, pos, &chrs); -} - -/* int bsetstr (bstring b0, int pos, bstring b1, unsigned char fill) - * - * Overwrite the string b0 starting at position pos with the string b1. If - * the position pos is past the end of b0, then the character "fill" is - * appended as necessary to make up the gap between the end of b0 and pos. - * If b1 is NULL, it behaves as if it were a 0-length string. - */ -int bsetstr (bstring b0, int pos, const_bstring b1, unsigned char fill) { -int d, newlen; -ptrdiff_t pd; -bstring aux = (bstring) b1; - - if (pos < 0 || b0 == NULL || b0->slen < 0 || NULL == b0->data || - b0->mlen < b0->slen || b0->mlen <= 0) return BSTR_ERR; - if (b1 != NULL && (b1->slen < 0 || b1->data == NULL)) return BSTR_ERR; - - d = pos; - - /* Aliasing case */ - if (NULL != aux) { - if ((pd = (ptrdiff_t) (b1->data - b0->data)) >= 0 && - pd < (ptrdiff_t) b0->mlen) { - if (NULL == (aux = bstrcpy (b1))) return BSTR_ERR; - } - d += aux->slen; - } - - /* Increase memory size if necessary */ - if (balloc (b0, d + 1) != BSTR_OK) { - if (aux != b1) bdestroy (aux); - return BSTR_ERR; - } - - newlen = b0->slen; - - /* Fill in "fill" character as necessary */ - if (pos > newlen) { - bstr__memset (b0->data + b0->slen, (int) fill, - (size_t) (pos - b0->slen)); - newlen = pos; - } - - /* Copy b1 to position pos in b0. */ - if (aux != NULL) { - bBlockCopy ((char *) (b0->data + pos), (char *) aux->data, aux->slen); - if (aux != b1) bdestroy (aux); - } - - /* Indicate the potentially increased size of b0 */ - if (d > newlen) newlen = d; - - b0->slen = newlen; - b0->data[newlen] = (unsigned char) '\0'; - - return BSTR_OK; -} - -/* int binsertblk (bstring b, int pos, const void * blk, int len, - * unsigned char fill) - * - * Inserts the block of characters at blk with length len into b at position - * pos. If the position pos is past the end of b, then the character "fill" - * is appended as necessary to make up the gap between the end of b1 and pos. - * Unlike bsetstr, binsert does not allow b2 to be NULL. - */ -int binsertblk (bstring b, int pos, const void * blk, int len, - unsigned char fill) { -int d, l; -unsigned char* aux = (unsigned char*) blk; - - if (b == NULL || blk == NULL || pos < 0 || len < 0 || b->slen < 0 || - b->mlen <= 0 || b->mlen < b->slen) return BSTR_ERR; - - /* Compute the two possible end pointers */ - d = b->slen + len; - l = pos + len; - if ((d|l) < 0) return BSTR_ERR; /* Integer wrap around. */ - - /* Aliasing case */ - if (((size_t) ((unsigned char*) blk + len)) >= ((size_t) b->data) && - ((size_t) blk) < ((size_t) (b->data + b->mlen))) { - if (NULL == (aux = (unsigned char*) bstr__alloc (len))) - return BSTR_ERR; - bstr__memcpy (aux, blk, len); - } - - if (l > d) { - /* Inserting past the end of the string */ - if (balloc (b, l + 1) != BSTR_OK) { - if (aux != (unsigned char*) blk) bstr__free (aux); - return BSTR_ERR; - } - bstr__memset (b->data + b->slen, (int) fill, - (size_t) (pos - b->slen)); - b->slen = l; - } else { - /* Inserting in the middle of the string */ - if (balloc (b, d + 1) != BSTR_OK) { - if (aux != (unsigned char*) blk) bstr__free (aux); - return BSTR_ERR; - } - bBlockCopy (b->data + l, b->data + pos, d - l); - b->slen = d; - } - bBlockCopy (b->data + pos, aux, len); - b->data[b->slen] = (unsigned char) '\0'; - if (aux != (unsigned char*) blk) bstr__free (aux); - return BSTR_OK; -} - -/* int binsert (bstring b1, int pos, const_bstring b2, unsigned char fill) - * - * Inserts the string b2 into b1 at position pos. If the position pos is - * past the end of b1, then the character "fill" is appended as necessary to - * make up the gap between the end of b1 and pos. Unlike bsetstr, binsert - * does not allow b2 to be NULL. - */ -int binsert (bstring b1, int pos, const_bstring b2, unsigned char fill) { - if (NULL == b2 || (b2->mlen > 0 && b2->slen > b2->mlen)) return BSTR_ERR; - return binsertblk (b1, pos, b2->data, b2->slen, fill); -} - -/* int breplace (bstring b1, int pos, int len, bstring b2, - * unsigned char fill) - * - * Replace a section of a string from pos for a length len with the string - * b2. fill is used is pos > b1->slen. - */ -int breplace (bstring b1, int pos, int len, const_bstring b2, - unsigned char fill) { -int pl, ret; -ptrdiff_t pd; -bstring aux = (bstring) b2; - - if (pos < 0 || len < 0) return BSTR_ERR; - if (pos > INT_MAX - len) return BSTR_ERR; /* Overflow */ - pl = pos + len; - if (b1 == NULL || b2 == NULL || b1->data == NULL || b2->data == NULL || - b1->slen < 0 || b2->slen < 0 || b1->mlen < b1->slen || - b1->mlen <= 0) return BSTR_ERR; - - /* Straddles the end? */ - if (pl >= b1->slen) { - if ((ret = bsetstr (b1, pos, b2, fill)) < 0) return ret; - if (pos + b2->slen < b1->slen) { - b1->slen = pos + b2->slen; - b1->data[b1->slen] = (unsigned char) '\0'; - } - return ret; - } - - /* Aliasing case */ - if ((pd = (ptrdiff_t) (b2->data - b1->data)) >= 0 && - pd < (ptrdiff_t) b1->slen) { - if (NULL == (aux = bstrcpy (b2))) return BSTR_ERR; - } - - if (aux->slen > len) { - if (balloc (b1, b1->slen + aux->slen - len) != BSTR_OK) { - if (aux != b2) bdestroy (aux); - return BSTR_ERR; - } - } - - if (aux->slen != len) bstr__memmove (b1->data + pos + aux->slen, - b1->data + pos + len, - b1->slen - (pos + len)); - bstr__memcpy (b1->data + pos, aux->data, aux->slen); - b1->slen += aux->slen - len; - b1->data[b1->slen] = (unsigned char) '\0'; - if (aux != b2) bdestroy (aux); - return BSTR_OK; -} - -/* - * findreplaceengine is used to implement bfindreplace and - * bfindreplacecaseless. It works by breaking the three cases of - * expansion, reduction and replacement, and solving each of these - * in the most efficient way possible. - */ - -typedef int (*instr_fnptr) (const_bstring s1, int pos, const_bstring s2); - -#define INITIAL_STATIC_FIND_INDEX_COUNT 32 - -static int findreplaceengine (bstring b, const_bstring find, - const_bstring repl, int pos, - instr_fnptr instr) { -int i, ret, delta, acc; -unsigned int mlen, slen; -int * d; -int static_d[INITIAL_STATIC_FIND_INDEX_COUNT+1]; /* This +1 is for LINT. */ -ptrdiff_t pd; -bstring auxf = (bstring) find; -bstring auxr = (bstring) repl; - - if (b == NULL || b->data == NULL || find == NULL || - find->data == NULL || repl == NULL || repl->data == NULL || - pos < 0 || find->slen <= 0 || b->mlen <= 0 || b->slen > b->mlen || - b->slen < 0 || repl->slen < 0) return BSTR_ERR; - if (pos > b->slen - find->slen) return BSTR_OK; - - /* Alias with find string */ - pd = (ptrdiff_t) (find->data - b->data); - if ((ptrdiff_t) (pos - find->slen) < pd && pd < (ptrdiff_t) b->slen) { - if (NULL == (auxf = bstrcpy (find))) return BSTR_ERR; - } - - /* Alias with repl string */ - pd = (ptrdiff_t) (repl->data - b->data); - if ((ptrdiff_t) (pos - repl->slen) < pd && pd < (ptrdiff_t) b->slen) { - if (NULL == (auxr = bstrcpy (repl))) { - if (auxf != find) bdestroy (auxf); - return BSTR_ERR; - } - } - - delta = auxf->slen - auxr->slen; - - /* in-place replacement since find and replace strings are of equal - length */ - if (delta == 0) { - while ((pos = instr (b, pos, auxf)) >= 0) { - bstr__memcpy (b->data + pos, auxr->data, auxr->slen); - pos += auxf->slen; - } - if (auxf != find) bdestroy (auxf); - if (auxr != repl) bdestroy (auxr); - return BSTR_OK; - } - - /* shrinking replacement since auxf->slen > auxr->slen */ - if (delta > 0) { - acc = 0; - - while ((i = instr (b, pos, auxf)) >= 0) { - if (acc && i > pos) - bstr__memmove (b->data + pos - acc, b->data + pos, i - pos); - if (auxr->slen) - bstr__memcpy (b->data + i - acc, auxr->data, auxr->slen); - acc += delta; - pos = i + auxf->slen; - } - - if (acc) { - i = b->slen; - if (i > pos) - bstr__memmove (b->data + pos - acc, b->data + pos, i - pos); - b->slen -= acc; - b->data[b->slen] = (unsigned char) '\0'; - } - - if (auxf != find) bdestroy (auxf); - if (auxr != repl) bdestroy (auxr); - return BSTR_OK; - } - - /* expanding replacement since find->slen < repl->slen. Its a lot - more complicated. This works by first finding all the matches and - storing them to a growable array, then doing at most one resize of - the destination bstring and then performing the direct memory transfers - of the string segment pieces to form the final result. The growable - array of matches uses a deferred doubling reallocing strategy. What - this means is that it starts as a reasonably fixed sized auto array in - the hopes that many if not most cases will never need to grow this - array. But it switches as soon as the bounds of the array will be - exceeded. An extra find result is always appended to this array that - corresponds to the end of the destination string, so slen is checked - against mlen - 1 rather than mlen before resizing. - */ - - mlen = INITIAL_STATIC_FIND_INDEX_COUNT; - d = (int *) static_d; /* Avoid malloc for trivial/initial cases */ - acc = slen = 0; - - while ((pos = instr (b, pos, auxf)) >= 0) { - if (slen >= mlen - 1) { - int *t; - int sl; - /* Overflow */ - if (mlen > (INT_MAX / sizeof(int *)) / 2) { - ret = BSTR_ERR; - goto done; - } - mlen += mlen; - sl = sizeof (int *) * mlen; - if (static_d == d) d = NULL; /* static_d cannot be realloced */ - if (NULL == (t = (int *) bstr__realloc (d, sl))) { - ret = BSTR_ERR; - goto done; - } - if (NULL == d) bstr__memcpy (t, static_d, sizeof (static_d)); - d = t; - } - d[slen] = pos; - slen++; - acc -= delta; - pos += auxf->slen; - if (pos < 0 || acc < 0) { - ret = BSTR_ERR; - goto done; - } - } - - /* slen <= INITIAL_STATIC_INDEX_COUNT-1 or mlen-1 here. */ - d[slen] = b->slen; - - if (BSTR_OK == (ret = balloc (b, b->slen + acc + 1))) { - b->slen += acc; - for (i = slen-1; i >= 0; i--) { - int s, l; - s = d[i] + auxf->slen; - l = d[i+1] - s; /* d[slen] may be accessed here. */ - if (l) { - bstr__memmove (b->data + s + acc, b->data + s, l); - } - if (auxr->slen) { - bstr__memmove (b->data + s + acc - auxr->slen, - auxr->data, auxr->slen); - } - acc += delta; - } - b->data[b->slen] = (unsigned char) '\0'; - } - - done:; - if (static_d != d) bstr__free (d); - if (auxf != find) bdestroy (auxf); - if (auxr != repl) bdestroy (auxr); - return ret; -} - -/* int bfindreplace (bstring b, const_bstring find, const_bstring repl, - * int pos) - * - * Replace all occurrences of a find string with a replace string after a - * given point in a bstring. - */ -int bfindreplace (bstring b, const_bstring find, const_bstring repl, - int pos) { - return findreplaceengine (b, find, repl, pos, binstr); -} - -/* int bfindreplacecaseless (bstring b, const_bstring find, - * const_bstring repl, int pos) - * - * Replace all occurrences of a find string, ignoring case, with a replace - * string after a given point in a bstring. - */ -int bfindreplacecaseless (bstring b, const_bstring find, const_bstring repl, - int pos) { - return findreplaceengine (b, find, repl, pos, binstrcaseless); -} - -/* int binsertch (bstring b, int pos, int len, unsigned char fill) - * - * Inserts the character fill repeatedly into b at position pos for a - * length len. If the position pos is past the end of b, then the - * character "fill" is appended as necessary to make up the gap between the - * end of b and the position pos + len. - */ -int binsertch (bstring b, int pos, int len, unsigned char fill) { -int d, l, i; - - if (pos < 0 || b == NULL || b->slen < 0 || b->mlen < b->slen || - b->mlen <= 0 || len < 0) return BSTR_ERR; - - /* Compute the two possible end pointers */ - d = b->slen + len; - l = pos + len; - if ((d|l) < 0) return BSTR_ERR; - - if (l > d) { - /* Inserting past the end of the string */ - if (balloc (b, l + 1) != BSTR_OK) return BSTR_ERR; - pos = b->slen; - b->slen = l; - } else { - /* Inserting in the middle of the string */ - if (balloc (b, d + 1) != BSTR_OK) return BSTR_ERR; - for (i = d - 1; i >= l; i--) { - b->data[i] = b->data[i - len]; - } - b->slen = d; - } - - for (i=pos; i < l; i++) b->data[i] = fill; - b->data[b->slen] = (unsigned char) '\0'; - return BSTR_OK; -} - -/* int bpattern (bstring b, int len) - * - * Replicate the bstring, b in place, end to end repeatedly until it - * surpasses len characters, then chop the result to exactly len characters. - * This function operates in-place. The function will return with BSTR_ERR - * if b is NULL or of length 0, otherwise BSTR_OK is returned. - */ -int bpattern (bstring b, int len) { -int i, d; - - d = blength (b); - if (d <= 0 || len < 0 || balloc (b, len + 1) != BSTR_OK) return BSTR_ERR; - if (len > 0) { - if (d == 1) return bsetstr (b, len, NULL, b->data[0]); - for (i = d; i < len; i++) b->data[i] = b->data[i - d]; - } - b->data[len] = (unsigned char) '\0'; - b->slen = len; - return BSTR_OK; -} - -#define BS_BUFF_SZ (1024) - -/* int breada (bstring b, bNread readPtr, void * parm) - * - * Use a finite buffer fread-like function readPtr to concatenate to the - * bstring b the entire contents of file-like source data in a roughly - * efficient way. - */ -int breada (bstring b, bNread readPtr, void * parm) { -int i, l, n; - - if (b == NULL || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen || - readPtr == NULL) return BSTR_ERR; - - i = b->slen; - for (n=i+16; ; n += ((n < BS_BUFF_SZ) ? n : BS_BUFF_SZ)) { - if (BSTR_OK != balloc (b, n + 1)) return BSTR_ERR; - l = (int) readPtr ((void *) (b->data + i), 1, n - i, parm); - i += l; - b->slen = i; - if (i < n) break; - } - - b->data[i] = (unsigned char) '\0'; - return BSTR_OK; -} - -/* bstring bread (bNread readPtr, void * parm) - * - * Use a finite buffer fread-like function readPtr to create a bstring - * filled with the entire contents of file-like source data in a roughly - * efficient way. - */ -bstring bread (bNread readPtr, void * parm) { -bstring buff; - - if (0 > breada (buff = bfromcstr (""), readPtr, parm)) { - bdestroy (buff); - return NULL; - } - return buff; -} - -/* int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator) - * - * Use an fgetc-like single character stream reading function (getcPtr) to - * obtain a sequence of characters which are concatenated to the end of the - * bstring b. The stream read is terminated by the passed in terminator - * parameter. - * - * If getcPtr returns with a negative number, or the terminator character - * (which is appended) is read, then the stream reading is halted and the - * function returns with a partial result in b. If there is an empty partial - * result, 1 is returned. If no characters are read, or there is some other - * detectable error, BSTR_ERR is returned. - */ -int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator) { -int c, d, e; - - if (b == NULL || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen || - getcPtr == NULL) return BSTR_ERR; - d = 0; - e = b->mlen - 2; - - while ((c = getcPtr (parm)) >= 0) { - if (d > e) { - b->slen = d; - if (balloc (b, d + 2) != BSTR_OK) return BSTR_ERR; - e = b->mlen - 2; - } - b->data[d] = (unsigned char) c; - d++; - if (c == terminator) break; - } - - b->data[d] = (unsigned char) '\0'; - b->slen = d; - - return d == 0 && c < 0; -} - -/* int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator) - * - * Use an fgetc-like single character stream reading function (getcPtr) to - * obtain a sequence of characters which are concatenated to the end of the - * bstring b. The stream read is terminated by the passed in terminator - * parameter. - * - * If getcPtr returns with a negative number, or the terminator character - * (which is appended) is read, then the stream reading is halted and the - * function returns with a partial result concatentated to b. If there is - * an empty partial result, 1 is returned. If no characters are read, or - * there is some other detectable error, BSTR_ERR is returned. - */ -int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator) { -int c, d, e; - - if (b == NULL || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen || - getcPtr == NULL) return BSTR_ERR; - d = b->slen; - e = b->mlen - 2; - - while ((c = getcPtr (parm)) >= 0) { - if (d > e) { - b->slen = d; - if (balloc (b, d + 2) != BSTR_OK) return BSTR_ERR; - e = b->mlen - 2; - } - b->data[d] = (unsigned char) c; - d++; - if (c == terminator) break; - } - - b->data[d] = (unsigned char) '\0'; - b->slen = d; - - return d == 0 && c < 0; -} - -/* bstring bgets (bNgetc getcPtr, void * parm, char terminator) - * - * Use an fgetc-like single character stream reading function (getcPtr) to - * obtain a sequence of characters which are concatenated into a bstring. - * The stream read is terminated by the passed in terminator function. - * - * If getcPtr returns with a negative number, or the terminator character - * (which is appended) is read, then the stream reading is halted and the - * result obtained thus far is returned. If no characters are read, or - * there is some other detectable error, NULL is returned. - */ -bstring bgets (bNgetc getcPtr, void * parm, char terminator) { -bstring buff; - - if (0 > bgetsa (buff = bfromcstr (""), getcPtr, parm, terminator) || - 0 >= buff->slen) { - bdestroy (buff); - buff = NULL; - } - return buff; -} - -struct bStream { - bstring buff; /* Buffer for over-reads */ - void * parm; /* The stream handle for core stream */ - bNread readFnPtr; /* fread compatible fnptr for core stream */ - int isEOF; /* track file's EOF state */ - int maxBuffSz; -}; - -/* struct bStream * bsopen (bNread readPtr, void * parm) - * - * Wrap a given open stream (described by a fread compatible function - * pointer and stream handle) into an open bStream suitable for the bstring - * library streaming functions. - */ -struct bStream * bsopen (bNread readPtr, void * parm) { -struct bStream * s; - - if (readPtr == NULL) return NULL; - s = (struct bStream *) bstr__alloc (sizeof (struct bStream)); - if (s == NULL) return NULL; - s->parm = parm; - s->buff = bfromcstr (""); - s->readFnPtr = readPtr; - s->maxBuffSz = BS_BUFF_SZ; - s->isEOF = 0; - return s; -} - -/* int bsbufflength (struct bStream * s, int sz) - * - * Set the length of the buffer used by the bStream. If sz is zero, the - * length is not set. This function returns with the previous length. - */ -int bsbufflength (struct bStream * s, int sz) { -int oldSz; - if (s == NULL || sz < 0) return BSTR_ERR; - oldSz = s->maxBuffSz; - if (sz > 0) s->maxBuffSz = sz; - return oldSz; -} - -int bseof (const struct bStream * s) { - if (s == NULL || s->readFnPtr == NULL) return BSTR_ERR; - return s->isEOF && (s->buff->slen == 0); -} - -/* void * bsclose (struct bStream * s) - * - * Close the bStream, and return the handle to the stream that was originally - * used to open the given stream. - */ -void * bsclose (struct bStream * s) { -void * parm; - if (s == NULL) return NULL; - s->readFnPtr = NULL; - if (s->buff) bdestroy (s->buff); - s->buff = NULL; - parm = s->parm; - s->parm = NULL; - s->isEOF = 1; - bstr__free (s); - return parm; -} - -/* int bsreadlna (bstring r, struct bStream * s, char terminator) - * - * Read a bstring terminated by the terminator character or the end of the - * stream from the bStream (s) and return it into the parameter r. This - * function may read additional characters from the core stream that are not - * returned, but will be retained for subsequent read operations. - */ -int bsreadlna (bstring r, struct bStream * s, char terminator) { -int i, l, ret, rlo; -char * b; -struct tagbstring x; - - if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0 || - r->slen < 0 || r->mlen < r->slen) return BSTR_ERR; - l = s->buff->slen; - if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR; - b = (char *) s->buff->data; - x.data = (unsigned char *) b; - - /* First check if the current buffer holds the terminator */ - b[l] = terminator; /* Set sentinel */ - for (i=0; b[i] != terminator; i++) ; - if (i < l) { - x.slen = i + 1; - ret = bconcat (r, &x); - s->buff->slen = l; - if (BSTR_OK == ret) bdelete (s->buff, 0, i + 1); - return BSTR_OK; - } - - rlo = r->slen; - - /* If not then just concatenate the entire buffer to the output */ - x.slen = l; - if (BSTR_OK != bconcat (r, &x)) return BSTR_ERR; - - /* Perform direct in-place reads into the destination to allow for - the minimum of data-copies */ - for (;;) { - if (BSTR_OK != balloc (r, r->slen + s->maxBuffSz + 1)) - return BSTR_ERR; - b = (char *) (r->data + r->slen); - l = (int) s->readFnPtr (b, 1, s->maxBuffSz, s->parm); - if (l <= 0) { - r->data[r->slen] = (unsigned char) '\0'; - s->buff->slen = 0; - s->isEOF = 1; - /* If nothing was read return with an error message */ - return BSTR_ERR & -(r->slen == rlo); - } - b[l] = terminator; /* Set sentinel */ - for (i=0; b[i] != terminator; i++) ; - if (i < l) break; - r->slen += l; - } - - /* Terminator found, push over-read back to buffer */ - i++; - r->slen += i; - s->buff->slen = l - i; - bstr__memcpy (s->buff->data, b + i, l - i); - r->data[r->slen] = (unsigned char) '\0'; - return BSTR_OK; -} - -/* int bsreadlnsa (bstring r, struct bStream * s, bstring term) - * - * Read a bstring terminated by any character in the term string or the end - * of the stream from the bStream (s) and return it into the parameter r. - * This function may read additional characters from the core stream that - * are not returned, but will be retained for subsequent read operations. - */ -int bsreadlnsa (bstring r, struct bStream * s, const_bstring term) { -int i, l, ret, rlo; -unsigned char * b; -struct tagbstring x; -struct charField cf; - - if (s == NULL || s->buff == NULL || r == NULL || term == NULL || - term->data == NULL || r->mlen <= 0 || r->slen < 0 || - r->mlen < r->slen) return BSTR_ERR; - if (term->slen == 1) return bsreadlna (r, s, term->data[0]); - if (term->slen < 1 || buildCharField (&cf, term)) return BSTR_ERR; - - l = s->buff->slen; - if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR; - b = (unsigned char *) s->buff->data; - x.data = b; - - /* First check if the current buffer holds the terminator */ - b[l] = term->data[0]; /* Set sentinel */ - for (i=0; !testInCharField (&cf, b[i]); i++) ; - if (i < l) { - x.slen = i + 1; - ret = bconcat (r, &x); - s->buff->slen = l; - if (BSTR_OK == ret) bdelete (s->buff, 0, i + 1); - return BSTR_OK; - } - - rlo = r->slen; - - /* If not then just concatenate the entire buffer to the output */ - x.slen = l; - if (BSTR_OK != bconcat (r, &x)) return BSTR_ERR; - - /* Perform direct in-place reads into the destination to allow for - the minimum of data-copies */ - for (;;) { - if (BSTR_OK != balloc (r, r->slen + s->maxBuffSz + 1)) - return BSTR_ERR; - b = (unsigned char *) (r->data + r->slen); - l = (int) s->readFnPtr (b, 1, s->maxBuffSz, s->parm); - if (l <= 0) { - r->data[r->slen] = (unsigned char) '\0'; - s->buff->slen = 0; - s->isEOF = 1; - /* If nothing was read return with an error message */ - return BSTR_ERR & -(r->slen == rlo); - } - - b[l] = term->data[0]; /* Set sentinel */ - for (i=0; !testInCharField (&cf, b[i]); i++) ; - if (i < l) break; - r->slen += l; - } - - /* Terminator found, push over-read back to buffer */ - i++; - r->slen += i; - s->buff->slen = l - i; - bstr__memcpy (s->buff->data, b + i, l - i); - r->data[r->slen] = (unsigned char) '\0'; - return BSTR_OK; -} - -/* int bsreada (bstring r, struct bStream * s, int n) - * - * Read a bstring of length n (or, if it is fewer, as many bytes as is - * remaining) from the bStream. This function may read additional - * characters from the core stream that are not returned, but will be - * retained for subsequent read operations. This function will not read - * additional characters from the core stream beyond virtual stream pointer. - */ -int bsreada (bstring r, struct bStream * s, int n) { -int l, ret, orslen; -char * b; -struct tagbstring x; - - if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0 - || r->slen < 0 || r->mlen < r->slen || n <= 0) return BSTR_ERR; - - if (n > INT_MAX - r->slen) return BSTR_ERR; - n += r->slen; - - l = s->buff->slen; - - orslen = r->slen; - - if (0 == l) { - if (s->isEOF) return BSTR_ERR; - if (r->mlen > n) { - l = (int) s->readFnPtr (r->data + r->slen, 1, n - r->slen, - s->parm); - if (0 >= l || l > n - r->slen) { - s->isEOF = 1; - return BSTR_ERR; - } - r->slen += l; - r->data[r->slen] = (unsigned char) '\0'; - return 0; - } - } - - if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR; - b = (char *) s->buff->data; - x.data = (unsigned char *) b; - - do { - if (l + r->slen >= n) { - x.slen = n - r->slen; - ret = bconcat (r, &x); - s->buff->slen = l; - if (BSTR_OK == ret) bdelete (s->buff, 0, x.slen); - return BSTR_ERR & -(r->slen == orslen); - } - - x.slen = l; - if (BSTR_OK != bconcat (r, &x)) break; - - l = n - r->slen; - if (l > s->maxBuffSz) l = s->maxBuffSz; - - l = (int) s->readFnPtr (b, 1, l, s->parm); - - } while (l > 0); - if (l < 0) l = 0; - if (l == 0) s->isEOF = 1; - s->buff->slen = l; - return BSTR_ERR & -(r->slen == orslen); -} - -/* int bsreadln (bstring r, struct bStream * s, char terminator) - * - * Read a bstring terminated by the terminator character or the end of the - * stream from the bStream (s) and return it into the parameter r. This - * function may read additional characters from the core stream that are not - * returned, but will be retained for subsequent read operations. - */ -int bsreadln (bstring r, struct bStream * s, char terminator) { - if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0) - return BSTR_ERR; - if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR; - r->slen = 0; - return bsreadlna (r, s, terminator); -} - -/* int bsreadlns (bstring r, struct bStream * s, bstring term) - * - * Read a bstring terminated by any character in the term string or the end - * of the stream from the bStream (s) and return it into the parameter r. - * This function may read additional characters from the core stream that - * are not returned, but will be retained for subsequent read operations. - */ -int bsreadlns (bstring r, struct bStream * s, const_bstring term) { - if (s == NULL || s->buff == NULL || r == NULL || term == NULL - || term->data == NULL || r->mlen <= 0) return BSTR_ERR; - if (term->slen == 1) return bsreadln (r, s, term->data[0]); - if (term->slen < 1) return BSTR_ERR; - if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR; - r->slen = 0; - return bsreadlnsa (r, s, term); -} - -/* int bsread (bstring r, struct bStream * s, int n) - * - * Read a bstring of length n (or, if it is fewer, as many bytes as is - * remaining) from the bStream. This function may read additional - * characters from the core stream that are not returned, but will be - * retained for subsequent read operations. This function will not read - * additional characters from the core stream beyond virtual stream pointer. - */ -int bsread (bstring r, struct bStream * s, int n) { - if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0 - || n <= 0) return BSTR_ERR; - if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR; - r->slen = 0; - return bsreada (r, s, n); -} - -/* int bsunread (struct bStream * s, const_bstring b) - * - * Insert a bstring into the bStream at the current position. These - * characters will be read prior to those that actually come from the core - * stream. - */ -int bsunread (struct bStream * s, const_bstring b) { - if (s == NULL || s->buff == NULL) return BSTR_ERR; - return binsert (s->buff, 0, b, (unsigned char) '?'); -} - -/* int bspeek (bstring r, const struct bStream * s) - * - * Return the currently buffered characters from the bStream that will be - * read prior to reads from the core stream. - */ -int bspeek (bstring r, const struct bStream * s) { - if (s == NULL || s->buff == NULL) return BSTR_ERR; - return bassign (r, s->buff); -} - -/* bstring bjoinblk (const struct bstrList * bl, void * blk, int len); - * - * Join the entries of a bstrList into one bstring by sequentially - * concatenating them with the content from blk for length len in between. - * If there is an error NULL is returned, otherwise a bstring with the - * correct result is returned. - */ -bstring bjoinblk (const struct bstrList * bl, const void * blk, int len) { -bstring b; -unsigned char * p; -int i, c, v; - - if (bl == NULL || bl->qty < 0) return NULL; - if (len < 0) return NULL; - if (len > 0 && blk == NULL) return NULL; - if (bl->qty < 1) return bfromStatic (""); - - for (i = 0, c = 1; i < bl->qty; i++) { - v = bl->entry[i]->slen; - if (v < 0) return NULL; /* Invalid input */ - if (v > INT_MAX - c) return NULL; /* Overflow */ - c += v; - } - - b = (bstring) bstr__alloc (sizeof (struct tagbstring)); - if (len == 0) { - p = b->data = (unsigned char *) bstr__alloc (c); - if (p == NULL) { - bstr__free (b); - return NULL; - } - for (i = 0; i < bl->qty; i++) { - v = bl->entry[i]->slen; - bstr__memcpy (p, bl->entry[i]->data, v); - p += v; - } - } else { - v = (bl->qty - 1) * len; - if ((bl->qty > 512 || len > 127) && - v / len != bl->qty - 1) return NULL; /* Overflow */ - if (v > INT_MAX - c) return NULL; /* Overflow */ - c += v; - p = b->data = (unsigned char *) bstr__alloc (c); - if (p == NULL) { - bstr__free (b); - return NULL; - } - v = bl->entry[0]->slen; - bstr__memcpy (p, bl->entry[0]->data, v); - p += v; - for (i = 1; i < bl->qty; i++) { - bstr__memcpy (p, blk, len); - p += len; - v = bl->entry[i]->slen; - if (v) { - bstr__memcpy (p, bl->entry[i]->data, v); - p += v; - } - } - } - b->mlen = c; - b->slen = c-1; - b->data[c-1] = (unsigned char) '\0'; - return b; -} - -/* bstring bjoin (const struct bstrList * bl, const_bstring sep); - * - * Join the entries of a bstrList into one bstring by sequentially - * concatenating them with the sep string in between. If there is an error - * NULL is returned, otherwise a bstring with the correct result is returned. - */ -bstring bjoin (const struct bstrList * bl, const_bstring sep) { - if (sep != NULL && (sep->slen < 0 || sep->data == NULL)) return NULL; - return bjoinblk (bl, sep->data, sep->slen); -} - -#define BSSSC_BUFF_LEN (256) - -/* int bssplitscb (struct bStream * s, const_bstring splitStr, - * int (* cb) (void * parm, int ofs, const_bstring entry), - * void * parm) - * - * Iterate the set of disjoint sequential substrings read from a stream - * divided by any of the characters in splitStr. An empty splitStr causes - * the whole stream to be iterated once. - * - * Note: At the point of calling the cb function, the bStream pointer is - * pointed exactly at the position right after having read the split - * character. The cb function can act on the stream by causing the bStream - * pointer to move, and bssplitscb will continue by starting the next split - * at the position of the pointer after the return from cb. - * - * However, if the cb causes the bStream s to be destroyed then the cb must - * return with a negative value, otherwise bssplitscb will continue in an - * undefined manner. - */ -int bssplitscb (struct bStream * s, const_bstring splitStr, - int (* cb) (void * parm, int ofs, const_bstring entry), void * parm) { -struct charField chrs; -bstring buff; -int i, p, ret; - - if (cb == NULL || s == NULL || s->readFnPtr == NULL || - splitStr == NULL || splitStr->slen < 0) return BSTR_ERR; - - if (NULL == (buff = bfromcstr (""))) return BSTR_ERR; - - if (splitStr->slen == 0) { - while (bsreada (buff, s, BSSSC_BUFF_LEN) >= 0) ; - if ((ret = cb (parm, 0, buff)) > 0) - ret = 0; - } else { - buildCharField (&chrs, splitStr); - ret = p = i = 0; - for (;;) { - if (i >= buff->slen) { - bsreada (buff, s, BSSSC_BUFF_LEN); - if (i >= buff->slen) { - if (0 < (ret = cb (parm, p, buff))) ret = 0; - break; - } - } - if (testInCharField (&chrs, buff->data[i])) { - struct tagbstring t; - unsigned char c; - - blk2tbstr (t, buff->data + i + 1, buff->slen - (i + 1)); - if ((ret = bsunread (s, &t)) < 0) break; - buff->slen = i; - c = buff->data[i]; - buff->data[i] = (unsigned char) '\0'; - if ((ret = cb (parm, p, buff)) < 0) break; - buff->data[i] = c; - buff->slen = 0; - p += i + 1; - i = -1; - } - i++; - } - } - - bdestroy (buff); - return ret; -} - -/* int bssplitstrcb (struct bStream * s, const_bstring splitStr, - * int (* cb) (void * parm, int ofs, const_bstring entry), - * void * parm) - * - * Iterate the set of disjoint sequential substrings read from a stream - * divided by the entire substring splitStr. An empty splitStr causes - * each character of the stream to be iterated. - * - * Note: At the point of calling the cb function, the bStream pointer is - * pointed exactly at the position right after having read the split - * character. The cb function can act on the stream by causing the bStream - * pointer to move, and bssplitscb will continue by starting the next split - * at the position of the pointer after the return from cb. - * - * However, if the cb causes the bStream s to be destroyed then the cb must - * return with a negative value, otherwise bssplitscb will continue in an - * undefined manner. - */ -int bssplitstrcb (struct bStream * s, const_bstring splitStr, - int (* cb) (void * parm, int ofs, const_bstring entry), void * parm) { -bstring buff; -int i, p, ret; - - if (cb == NULL || s == NULL || s->readFnPtr == NULL - || splitStr == NULL || splitStr->slen < 0) return BSTR_ERR; - - if (splitStr->slen == 1) return bssplitscb (s, splitStr, cb, parm); - - if (NULL == (buff = bfromcstr (""))) return BSTR_ERR; - - if (splitStr->slen == 0) { - for (i=0; bsreada (buff, s, BSSSC_BUFF_LEN) >= 0; i++) { - if ((ret = cb (parm, 0, buff)) < 0) { - bdestroy (buff); - return ret; - } - buff->slen = 0; - } - return BSTR_OK; - } else { - ret = p = i = 0; - for (i=p=0;;) { - if ((ret = binstr (buff, 0, splitStr)) >= 0) { - struct tagbstring t; - blk2tbstr (t, buff->data, ret); - i = ret + splitStr->slen; - if ((ret = cb (parm, p, &t)) < 0) break; - p += i; - bdelete (buff, 0, i); - } else { - bsreada (buff, s, BSSSC_BUFF_LEN); - if (bseof (s)) { - if ((ret = cb (parm, p, buff)) > 0) ret = 0; - break; - } - } - } - } - - bdestroy (buff); - return ret; -} - -/* int bstrListCreate (void) - * - * Create a bstrList. - */ -struct bstrList * bstrListCreate (void) { -struct bstrList * sl = - (struct bstrList *) bstr__alloc (sizeof (struct bstrList)); - if (sl) { - sl->entry = (bstring *) bstr__alloc (1*sizeof (bstring)); - if (!sl->entry) { - bstr__free (sl); - sl = NULL; - } else { - sl->qty = 0; - sl->mlen = 1; - } - } - return sl; -} - -/* int bstrListDestroy (struct bstrList * sl) - * - * Destroy a bstrList that has been created by bsplit, bsplits or - * bstrListCreate. - */ -int bstrListDestroy (struct bstrList * sl) { -int i; - if (sl == NULL || sl->qty < 0) return BSTR_ERR; - for (i=0; i < sl->qty; i++) { - if (sl->entry[i]) { - bdestroy (sl->entry[i]); - sl->entry[i] = NULL; - } - } - sl->qty = -1; - sl->mlen = -1; - bstr__free (sl->entry); - sl->entry = NULL; - bstr__free (sl); - return BSTR_OK; -} - -/* int bstrListAlloc (struct bstrList * sl, int msz) - * - * Ensure that there is memory for at least msz number of entries for the - * list. - */ -int bstrListAlloc (struct bstrList * sl, int msz) { -bstring * l; -int smsz; -size_t nsz; - if (!sl || msz <= 0 || !sl->entry || sl->qty < 0 || sl->mlen <= 0 || - sl->qty > sl->mlen) return BSTR_ERR; - if (sl->mlen >= msz) return BSTR_OK; - smsz = snapUpSize (msz); - nsz = ((size_t) smsz) * sizeof (bstring); - if (nsz < (size_t) smsz) return BSTR_ERR; - l = (bstring *) bstr__realloc (sl->entry, nsz); - if (!l) { - smsz = msz; - nsz = ((size_t) smsz) * sizeof (bstring); - l = (bstring *) bstr__realloc (sl->entry, nsz); - if (!l) return BSTR_ERR; - } - sl->mlen = smsz; - sl->entry = l; - return BSTR_OK; -} - -/* int bstrListAllocMin (struct bstrList * sl, int msz) - * - * Try to allocate the minimum amount of memory for the list to include at - * least msz entries or sl->qty whichever is greater. - */ -int bstrListAllocMin (struct bstrList * sl, int msz) { -bstring * l; -size_t nsz; - if (!sl || msz <= 0 || !sl->entry || sl->qty < 0 || sl->mlen <= 0 || - sl->qty > sl->mlen) return BSTR_ERR; - if (msz < sl->qty) msz = sl->qty; - if (sl->mlen == msz) return BSTR_OK; - nsz = ((size_t) msz) * sizeof (bstring); - if (nsz < (size_t) msz) return BSTR_ERR; - l = (bstring *) bstr__realloc (sl->entry, nsz); - if (!l) return BSTR_ERR; - sl->mlen = msz; - sl->entry = l; - return BSTR_OK; -} - -/* int bsplitcb (const_bstring str, unsigned char splitChar, int pos, - * int (* cb) (void * parm, int ofs, int len), void * parm) - * - * Iterate the set of disjoint sequential substrings over str divided by the - * character in splitChar. - * - * Note: Non-destructive modification of str from within the cb function - * while performing this split is not undefined. bsplitcb behaves in - * sequential lock step with calls to cb. I.e., after returning from a cb - * that return a non-negative integer, bsplitcb continues from the position - * 1 character after the last detected split character and it will halt - * immediately if the length of str falls below this point. However, if the - * cb function destroys str, then it *must* return with a negative value, - * otherwise bsplitcb will continue in an undefined manner. - */ -int bsplitcb (const_bstring str, unsigned char splitChar, int pos, - int (* cb) (void * parm, int ofs, int len), void * parm) { -int i, p, ret; - - if (cb == NULL || str == NULL || pos < 0 || pos > str->slen) - return BSTR_ERR; - - p = pos; - do { - for (i=p; i < str->slen; i++) { - if (str->data[i] == splitChar) break; - } - if ((ret = cb (parm, p, i - p)) < 0) return ret; - p = i + 1; - } while (p <= str->slen); - return BSTR_OK; -} - -/* int bsplitscb (const_bstring str, const_bstring splitStr, int pos, - * int (* cb) (void * parm, int ofs, int len), void * parm) - * - * Iterate the set of disjoint sequential substrings over str divided by any - * of the characters in splitStr. An empty splitStr causes the whole str to - * be iterated once. - * - * Note: Non-destructive modification of str from within the cb function - * while performing this split is not undefined. bsplitscb behaves in - * sequential lock step with calls to cb. I.e., after returning from a cb - * that return a non-negative integer, bsplitscb continues from the position - * 1 character after the last detected split character and it will halt - * immediately if the length of str falls below this point. However, if the - * cb function destroys str, then it *must* return with a negative value, - * otherwise bsplitscb will continue in an undefined manner. - */ -int bsplitscb (const_bstring str, const_bstring splitStr, int pos, - int (* cb) (void * parm, int ofs, int len), void * parm) { -struct charField chrs; -int i, p, ret; - - if (cb == NULL || str == NULL || pos < 0 || pos > str->slen - || splitStr == NULL || splitStr->slen < 0) return BSTR_ERR; - if (splitStr->slen == 0) { - if ((ret = cb (parm, 0, str->slen)) > 0) ret = 0; - return ret; - } - - if (splitStr->slen == 1) - return bsplitcb (str, splitStr->data[0], pos, cb, parm); - - buildCharField (&chrs, splitStr); - - p = pos; - do { - for (i=p; i < str->slen; i++) { - if (testInCharField (&chrs, str->data[i])) break; - } - if ((ret = cb (parm, p, i - p)) < 0) return ret; - p = i + 1; - } while (p <= str->slen); - return BSTR_OK; -} - -/* int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos, - * int (* cb) (void * parm, int ofs, int len), void * parm) - * - * Iterate the set of disjoint sequential substrings over str divided by the - * substring splitStr. An empty splitStr causes the whole str to be - * iterated once. - * - * Note: Non-destructive modification of str from within the cb function - * while performing this split is not undefined. bsplitstrcb behaves in - * sequential lock step with calls to cb. I.e., after returning from a cb - * that return a non-negative integer, bsplitscb continues from the position - * 1 character after the last detected split character and it will halt - * immediately if the length of str falls below this point. However, if the - * cb function destroys str, then it *must* return with a negative value, - * otherwise bsplitscb will continue in an undefined manner. - */ -int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos, - int (* cb) (void * parm, int ofs, int len), void * parm) { -int i, p, ret; - - if (cb == NULL || str == NULL || pos < 0 || pos > str->slen - || splitStr == NULL || splitStr->slen < 0) return BSTR_ERR; - - if (0 == splitStr->slen) { - for (i=pos; i < str->slen; i++) { - if ((ret = cb (parm, i, 1)) < 0) return ret; - } - return BSTR_OK; - } - - if (splitStr->slen == 1) - return bsplitcb (str, splitStr->data[0], pos, cb, parm); - - for (i=p=pos; i <= str->slen - splitStr->slen; i++) { - if (0 == bstr__memcmp (splitStr->data, str->data + i, - splitStr->slen)) { - if ((ret = cb (parm, p, i - p)) < 0) return ret; - i += splitStr->slen; - p = i; - } - } - if ((ret = cb (parm, p, str->slen - p)) < 0) return ret; - return BSTR_OK; -} - -struct genBstrList { - bstring b; - struct bstrList * bl; -}; - -static int bscb (void * parm, int ofs, int len) { -struct genBstrList * g = (struct genBstrList *) parm; - if (g->bl->qty >= g->bl->mlen) { - int mlen = g->bl->mlen * 2; - bstring * tbl; - - while (g->bl->qty >= mlen) { - if (mlen < g->bl->mlen) return BSTR_ERR; - mlen += mlen; - } - - tbl = (bstring *) bstr__realloc (g->bl->entry, - sizeof (bstring) * mlen); - if (tbl == NULL) return BSTR_ERR; - - g->bl->entry = tbl; - g->bl->mlen = mlen; - } - - g->bl->entry[g->bl->qty] = bmidstr (g->b, ofs, len); - g->bl->qty++; - return BSTR_OK; -} - -/* struct bstrList * bsplit (const_bstring str, unsigned char splitChar) - * - * Create an array of sequential substrings from str divided by the character - * splitChar. - */ -struct bstrList * bsplit (const_bstring str, unsigned char splitChar) { -struct genBstrList g; - - if (str == NULL || str->data == NULL || str->slen < 0) return NULL; - - g.bl = (struct bstrList *) bstr__alloc (sizeof (struct bstrList)); - if (g.bl == NULL) return NULL; - g.bl->mlen = 4; - g.bl->entry = (bstring *) bstr__alloc (g.bl->mlen * sizeof (bstring)); - if (NULL == g.bl->entry) { - bstr__free (g.bl); - return NULL; - } - - g.b = (bstring) str; - g.bl->qty = 0; - if (bsplitcb (str, splitChar, 0, bscb, &g) < 0) { - bstrListDestroy (g.bl); - return NULL; - } - return g.bl; -} - -/* struct bstrList * bsplitstr (const_bstring str, const_bstring splitStr) - * - * Create an array of sequential substrings from str divided by the entire - * substring splitStr. - */ -struct bstrList * bsplitstr (const_bstring str, const_bstring splitStr) { -struct genBstrList g; - - if (str == NULL || str->data == NULL || str->slen < 0) return NULL; - - g.bl = (struct bstrList *) bstr__alloc (sizeof (struct bstrList)); - if (g.bl == NULL) return NULL; - g.bl->mlen = 4; - g.bl->entry = (bstring *) bstr__alloc (g.bl->mlen * sizeof (bstring)); - if (NULL == g.bl->entry) { - bstr__free (g.bl); - return NULL; - } - - g.b = (bstring) str; - g.bl->qty = 0; - if (bsplitstrcb (str, splitStr, 0, bscb, &g) < 0) { - bstrListDestroy (g.bl); - return NULL; - } - return g.bl; -} - -/* struct bstrList * bsplits (const_bstring str, bstring splitStr) - * - * Create an array of sequential substrings from str divided by any of the - * characters in splitStr. An empty splitStr causes a single entry bstrList - * containing a copy of str to be returned. - */ -struct bstrList * bsplits (const_bstring str, const_bstring splitStr) { -struct genBstrList g; - - if ( str == NULL || str->slen < 0 || str->data == NULL || - splitStr == NULL || splitStr->slen < 0 || splitStr->data == NULL) - return NULL; - - g.bl = (struct bstrList *) bstr__alloc (sizeof (struct bstrList)); - if (g.bl == NULL) return NULL; - g.bl->mlen = 4; - g.bl->entry = (bstring *) bstr__alloc (g.bl->mlen * sizeof (bstring)); - if (NULL == g.bl->entry) { - bstr__free (g.bl); - return NULL; - } - g.b = (bstring) str; - g.bl->qty = 0; - - if (bsplitscb (str, splitStr, 0, bscb, &g) < 0) { - bstrListDestroy (g.bl); - return NULL; - } - return g.bl; -} - -#if defined (__TURBOC__) && !defined (__BORLANDC__) -# ifndef BSTRLIB_NOVSNP -# define BSTRLIB_NOVSNP -# endif -#endif - -/* Give WATCOM C/C++, MSVC some latitude for their non-support of vsnprintf */ -#if defined(__WATCOMC__) || defined(_MSC_VER) -#define exvsnprintf(r,b,n,f,a) {r = _vsnprintf (b,n,f,a);} -#else -#ifdef BSTRLIB_NOVSNP -/* This is just a hack. If you are using a system without a vsnprintf, it is - not recommended that bformat be used at all. */ -#define exvsnprintf(r,b,n,f,a) {vsprintf (b,f,a); r = -1;} -#define START_VSNBUFF (256) -#else - -#if defined(__GNUC__) && !defined(__APPLE__) -/* Something is making gcc complain about this prototype not being here, so - I've just gone ahead and put it in. */ -extern int vsnprintf (char *buf, size_t count, const char *format, va_list arg); -#endif - -#define exvsnprintf(r,b,n,f,a) {r = vsnprintf (b,n,f,a);} -#endif -#endif - -#if !defined (BSTRLIB_NOVSNP) - -#ifndef START_VSNBUFF -#define START_VSNBUFF (16) -#endif - -/* On IRIX vsnprintf returns n-1 when the operation would overflow the target - buffer, WATCOM and MSVC both return -1, while C99 requires that the - returned value be exactly what the length would be if the buffer would be - large enough. This leads to the idea that if the return value is larger - than n, then changing n to the return value will reduce the number of - iterations required. */ - -/* int bformata (bstring b, const char * fmt, ...) - * - * After the first parameter, it takes the same parameters as printf (), but - * rather than outputting results to stdio, it appends the results to - * a bstring which contains what would have been output. Note that if there - * is an early generation of a '\0' character, the bstring will be truncated - * to this end point. - */ -int bformata (bstring b, const char * fmt, ...) { -va_list arglist; -bstring buff; -int n, r; - - if (b == NULL || fmt == NULL || b->data == NULL || b->mlen <= 0 - || b->slen < 0 || b->slen > b->mlen) return BSTR_ERR; - - /* Since the length is not determinable beforehand, a search is - performed using the truncating "vsnprintf" call (to avoid buffer - overflows) on increasing potential sizes for the output result. */ - - if ((n = (int) (2*strlen (fmt))) < START_VSNBUFF) n = START_VSNBUFF; - if (NULL == (buff = bfromcstralloc (n + 2, ""))) { - n = 1; - if (NULL == (buff = bfromcstralloc (n + 2, ""))) return BSTR_ERR; - } - - for (;;) { - va_start (arglist, fmt); - exvsnprintf (r, (char *) buff->data, n + 1, fmt, arglist); - va_end (arglist); - - buff->data[n] = (unsigned char) '\0'; - buff->slen = (int) (strlen) ((char *) buff->data); - - if (buff->slen < n) break; - - if (r > n) n = r; else n += n; - - if (BSTR_OK != balloc (buff, n + 2)) { - bdestroy (buff); - return BSTR_ERR; - } - } - - r = bconcat (b, buff); - bdestroy (buff); - return r; -} - -/* int bassignformat (bstring b, const char * fmt, ...) - * - * After the first parameter, it takes the same parameters as printf (), but - * rather than outputting results to stdio, it outputs the results to - * the bstring parameter b. Note that if there is an early generation of a - * '\0' character, the bstring will be truncated to this end point. - */ -int bassignformat (bstring b, const char * fmt, ...) { -va_list arglist; -bstring buff; -int n, r; - - if (b == NULL || fmt == NULL || b->data == NULL || b->mlen <= 0 - || b->slen < 0 || b->slen > b->mlen) return BSTR_ERR; - - /* Since the length is not determinable beforehand, a search is - performed using the truncating "vsnprintf" call (to avoid buffer - overflows) on increasing potential sizes for the output result. */ - - if ((n = (int) (2*strlen (fmt))) < START_VSNBUFF) n = START_VSNBUFF; - if (NULL == (buff = bfromcstralloc (n + 2, ""))) { - n = 1; - if (NULL == (buff = bfromcstralloc (n + 2, ""))) return BSTR_ERR; - } - - for (;;) { - va_start (arglist, fmt); - exvsnprintf (r, (char *) buff->data, n + 1, fmt, arglist); - va_end (arglist); - - buff->data[n] = (unsigned char) '\0'; - buff->slen = (int) (strlen) ((char *) buff->data); - - if (buff->slen < n) break; - - if (r > n) n = r; else n += n; - - if (BSTR_OK != balloc (buff, n + 2)) { - bdestroy (buff); - return BSTR_ERR; - } - } - - r = bassign (b, buff); - bdestroy (buff); - return r; -} - -/* bstring bformat (const char * fmt, ...) - * - * Takes the same parameters as printf (), but rather than outputting results - * to stdio, it forms a bstring which contains what would have been output. - * Note that if there is an early generation of a '\0' character, the - * bstring will be truncated to this end point. - */ -bstring bformat (const char * fmt, ...) { -va_list arglist; -bstring buff; -int n, r; - - if (fmt == NULL) return NULL; - - /* Since the length is not determinable beforehand, a search is - performed using the truncating "vsnprintf" call (to avoid buffer - overflows) on increasing potential sizes for the output result. */ - - if ((n = (int) (2*strlen (fmt))) < START_VSNBUFF) n = START_VSNBUFF; - if (NULL == (buff = bfromcstralloc (n + 2, ""))) { - n = 1; - if (NULL == (buff = bfromcstralloc (n + 2, ""))) return NULL; - } - - for (;;) { - va_start (arglist, fmt); - exvsnprintf (r, (char *) buff->data, n + 1, fmt, arglist); - va_end (arglist); - - buff->data[n] = (unsigned char) '\0'; - buff->slen = (int) (strlen) ((char *) buff->data); - - if (buff->slen < n) break; - - if (r > n) n = r; else n += n; - - if (BSTR_OK != balloc (buff, n + 2)) { - bdestroy (buff); - return NULL; - } - } - - return buff; -} - -/* int bvcformata (bstring b, int count, const char * fmt, va_list arglist) - * - * The bvcformata function formats data under control of the format control - * string fmt and attempts to append the result to b. The fmt parameter is - * the same as that of the printf function. The variable argument list is - * replaced with arglist, which has been initialized by the va_start macro. - * The size of the output is upper bounded by count. If the required output - * exceeds count, the string b is not augmented with any contents and a value - * below BSTR_ERR is returned. If a value below -count is returned then it - * is recommended that the negative of this value be used as an update to the - * count in a subsequent pass. On other errors, such as running out of - * memory, parameter errors or numeric wrap around BSTR_ERR is returned. - * BSTR_OK is returned when the output is successfully generated and - * appended to b. - * - * Note: There is no sanity checking of arglist, and this function is - * destructive of the contents of b from the b->slen point onward. If there - * is an early generation of a '\0' character, the bstring will be truncated - * to this end point. - */ -int bvcformata (bstring b, int count, const char * fmt, va_list arg) { -int n, r, l; - - if (b == NULL || fmt == NULL || count <= 0 || b->data == NULL - || b->mlen <= 0 || b->slen < 0 || b->slen > b->mlen) return BSTR_ERR; - - if (count > (n = b->slen + count) + 2) return BSTR_ERR; - if (BSTR_OK != balloc (b, n + 2)) return BSTR_ERR; - - exvsnprintf (r, (char *) b->data + b->slen, count + 2, fmt, arg); - b->data[b->slen + count + 2] = '\0'; - - /* Did the operation complete successfully within bounds? */ - - if (n >= (l = b->slen + (int) (strlen) ((char *) b->data + b->slen))) { - b->slen = l; - return BSTR_OK; - } - - /* Abort, since the buffer was not large enough. The return value - tries to help set what the retry length should be. */ - - b->data[b->slen] = '\0'; - if (r > count+1) { - l = r; - } else { - if (count > INT_MAX / 2) - l = INT_MAX; - else - l = count + count; - } - n = -l; - if (n > BSTR_ERR-1) n = BSTR_ERR-1; - return n; -} - -#endif diff --git a/nserver/src/bstrlib.h b/nserver/src/bstrlib.h @@ -1,332 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2014 Paul Hsieh - * Copyright © 2020 rsiddharth - */ - -/* - * This is a slightly modified version of bstrlib.h from the bstrlib - * library (https://github.com/websnarf/bstrlib/releases/tag/v1.0.0). - */ - -/* - * This source file is part of the bstring string library. This code was - * written by Paul Hsieh in 2002-2015, and is covered by the BSD open source - * license and the GPL. Refer to the accompanying documentation for details - * on usage and license. - */ - -/* - * bstrlib.h - * - * This file is the interface for the core bstring functions. - */ - -#ifndef BSTRLIB_INCLUDE -#define BSTRLIB_INCLUDE - -#ifdef __cplusplus -extern "C" { -#endif - -#include <stdarg.h> -#include <string.h> -#include <limits.h> -#include <ctype.h> - -#if !defined (BSTRLIB_VSNP_OK) && !defined (BSTRLIB_NOVSNP) -# if defined (__TURBOC__) && !defined (__BORLANDC__) -# define BSTRLIB_NOVSNP -# endif -#endif - -#define BSTR_ERR (-1) -#define BSTR_OK (0) -#define BSTR_BS_BUFF_LENGTH_GET (0) - -typedef struct tagbstring * bstring; -typedef const struct tagbstring * const_bstring; - -/* Version */ -#define BSTR_VER_MAJOR 1 -#define BSTR_VER_MINOR 0 -#define BSTR_VER_UPDATE 0 - -/* Copy functions */ -#define cstr2bstr bfromcstr -extern bstring bfromcstr (const char * str); -extern bstring bfromcstralloc (int mlen, const char * str); -extern bstring bfromcstrrangealloc (int minl, int maxl, const char* str); -extern bstring blk2bstr (const void * blk, int len); -extern char * bstr2cstr (const_bstring s, char z); -extern int bcstrfree (char * s); -extern bstring bstrcpy (const_bstring b1); -extern int bassign (bstring a, const_bstring b); -extern int bassignmidstr (bstring a, const_bstring b, int left, int len); -extern int bassigncstr (bstring a, const char * str); -extern int bassignblk (bstring a, const void * s, int len); - -/* Destroy function */ -extern int bdestroy (bstring b); - -/* Space allocation hinting functions */ -extern int balloc (bstring s, int len); -extern int ballocmin (bstring b, int len); - -/* Substring extraction */ -extern bstring bmidstr (const_bstring b, int left, int len); - -/* Various standard manipulations */ -extern int bconcat (bstring b0, const_bstring b1); -extern int bconchar (bstring b0, char c); -extern int bcatcstr (bstring b, const char * s); -extern int bcatblk (bstring b, const void * s, int len); -extern int binsert (bstring s1, int pos, const_bstring s2, unsigned char fill); -extern int binsertblk (bstring s1, int pos, const void * s2, int len, unsigned char fill); -extern int binsertch (bstring s1, int pos, int len, unsigned char fill); -extern int breplace (bstring b1, int pos, int len, const_bstring b2, unsigned char fill); -extern int bdelete (bstring s1, int pos, int len); -extern int bsetstr (bstring b0, int pos, const_bstring b1, unsigned char fill); -extern int btrunc (bstring b, int n); - -/* Scan/search functions */ -extern int bstricmp (const_bstring b0, const_bstring b1); -extern int bstrnicmp (const_bstring b0, const_bstring b1, int n); -extern int biseqcaseless (const_bstring b0, const_bstring b1); -extern int biseqcaselessblk (const_bstring b, const void * blk, int len); -extern int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len); -extern int biseq (const_bstring b0, const_bstring b1); -extern int biseqblk (const_bstring b, const void * blk, int len); -extern int bisstemeqblk (const_bstring b0, const void * blk, int len); -extern int biseqcstr (const_bstring b, const char * s); -extern int biseqcstrcaseless (const_bstring b, const char * s); -extern int bstrcmp (const_bstring b0, const_bstring b1); -extern int bstrncmp (const_bstring b0, const_bstring b1, int n); -extern int binstr (const_bstring s1, int pos, const_bstring s2); -extern int binstrr (const_bstring s1, int pos, const_bstring s2); -extern int binstrcaseless (const_bstring s1, int pos, const_bstring s2); -extern int binstrrcaseless (const_bstring s1, int pos, const_bstring s2); -extern int bstrchrp (const_bstring b, int c, int pos); -extern int bstrrchrp (const_bstring b, int c, int pos); -#define bstrchr(b,c) bstrchrp ((b), (c), 0) -#define bstrrchr(b,c) bstrrchrp ((b), (c), blength(b)-1) -extern int binchr (const_bstring b0, int pos, const_bstring b1); -extern int binchrr (const_bstring b0, int pos, const_bstring b1); -extern int bninchr (const_bstring b0, int pos, const_bstring b1); -extern int bninchrr (const_bstring b0, int pos, const_bstring b1); -extern int bfindreplace (bstring b, const_bstring find, const_bstring repl, int pos); -extern int bfindreplacecaseless (bstring b, const_bstring find, const_bstring repl, int pos); - -/* List of string container functions */ -struct bstrList { - int qty, mlen; - bstring * entry; -}; -extern struct bstrList * bstrListCreate (void); -extern int bstrListDestroy (struct bstrList * sl); -extern int bstrListAlloc (struct bstrList * sl, int msz); -extern int bstrListAllocMin (struct bstrList * sl, int msz); - -/* String split and join functions */ -extern struct bstrList * bsplit (const_bstring str, unsigned char splitChar); -extern struct bstrList * bsplits (const_bstring str, const_bstring splitStr); -extern struct bstrList * bsplitstr (const_bstring str, const_bstring splitStr); -extern bstring bjoin (const struct bstrList * bl, const_bstring sep); -extern bstring bjoinblk (const struct bstrList * bl, const void * s, int len); -extern int bsplitcb (const_bstring str, unsigned char splitChar, int pos, - int (* cb) (void * parm, int ofs, int len), void * parm); -extern int bsplitscb (const_bstring str, const_bstring splitStr, int pos, - int (* cb) (void * parm, int ofs, int len), void * parm); -extern int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos, - int (* cb) (void * parm, int ofs, int len), void * parm); - -/* Miscellaneous functions */ -extern int bpattern (bstring b, int len); -extern int btoupper (bstring b); -extern int btolower (bstring b); -extern int bltrimws (bstring b); -extern int brtrimws (bstring b); -extern int btrimws (bstring b); - -#if !defined (BSTRLIB_NOVSNP) -extern bstring bformat (const char * fmt, ...); -extern int bformata (bstring b, const char * fmt, ...); -extern int bassignformat (bstring b, const char * fmt, ...); -extern int bvcformata (bstring b, int count, const char * fmt, va_list arglist); - -#define bvformata(ret, b, fmt, lastarg) { \ -bstring bstrtmp_b = (b); \ -const char * bstrtmp_fmt = (fmt); \ -int bstrtmp_r = BSTR_ERR, bstrtmp_sz = 16; \ - for (;;) { \ - va_list bstrtmp_arglist; \ - va_start (bstrtmp_arglist, lastarg); \ - bstrtmp_r = bvcformata (bstrtmp_b, bstrtmp_sz, bstrtmp_fmt, bstrtmp_arglist); \ - va_end (bstrtmp_arglist); \ - if (bstrtmp_r >= 0) { /* Everything went ok */ \ - bstrtmp_r = BSTR_OK; \ - break; \ - } else if (-bstrtmp_r <= bstrtmp_sz) { /* A real error? */ \ - bstrtmp_r = BSTR_ERR; \ - break; \ - } \ - bstrtmp_sz = -bstrtmp_r; /* Doubled or target size */ \ - } \ - ret = bstrtmp_r; \ -} - -#endif - -typedef int (*bNgetc) (void *parm); -typedef size_t (* bNread) (void *buff, size_t elsize, size_t nelem, void *parm); - -/* Input functions */ -extern bstring bgets (bNgetc getcPtr, void * parm, char terminator); -extern bstring bread (bNread readPtr, void * parm); -extern int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator); -extern int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator); -extern int breada (bstring b, bNread readPtr, void * parm); - -/* Stream functions */ -extern struct bStream * bsopen (bNread readPtr, void * parm); -extern void * bsclose (struct bStream * s); -extern int bsbufflength (struct bStream * s, int sz); -extern int bsreadln (bstring b, struct bStream * s, char terminator); -extern int bsreadlns (bstring r, struct bStream * s, const_bstring term); -extern int bsread (bstring b, struct bStream * s, int n); -extern int bsreadlna (bstring b, struct bStream * s, char terminator); -extern int bsreadlnsa (bstring r, struct bStream * s, const_bstring term); -extern int bsreada (bstring b, struct bStream * s, int n); -extern int bsunread (struct bStream * s, const_bstring b); -extern int bspeek (bstring r, const struct bStream * s); -extern int bssplitscb (struct bStream * s, const_bstring splitStr, - int (* cb) (void * parm, int ofs, const_bstring entry), void * parm); -extern int bssplitstrcb (struct bStream * s, const_bstring splitStr, - int (* cb) (void * parm, int ofs, const_bstring entry), void * parm); -extern int bseof (const struct bStream * s); - -struct tagbstring { - int mlen; - int slen; - unsigned char * data; -}; - -/* Accessor macros */ -#define blengthe(b, e) (((b) == (void *)0 || (b)->slen < 0) ? (int)(e) : ((b)->slen)) -#define blength(b) (blengthe ((b), 0)) -#define bdataofse(b, o, e) (((b) == (void *)0 || (b)->data == (void*)0) ? (char *)(e) : ((char *)(b)->data) + (o)) -#define bdataofs(b, o) (bdataofse ((b), (o), (void *)0)) -#define bdatae(b, e) (bdataofse (b, 0, e)) -#define bdata(b) (bdataofs (b, 0)) -#define bchare(b, p, e) ((((unsigned)(p)) < (unsigned)blength(b)) ? ((b)->data[(p)]) : (e)) -#define bchar(b, p) bchare ((b), (p), '\0') - -/* Static constant string initialization macro */ -#define bsStaticMlen(q,m) {(m), (int) sizeof(q)-1, (unsigned char *) ("" q "")} -#if defined(_MSC_VER) -# define bsStatic(q) bsStaticMlen(q,-32) -#endif -#ifndef bsStatic -# define bsStatic(q) bsStaticMlen(q,-__LINE__) -#endif - -/* Static constant block parameter pair */ -#define bsStaticBlkParms(q) ((void *)("" q "")), ((int) sizeof(q)-1) - -#define bcatStatic(b,s) ((bcatblk)((b), bsStaticBlkParms(s))) -#define bfromStatic(s) ((blk2bstr)(bsStaticBlkParms(s))) -#define bassignStatic(b,s) ((bassignblk)((b), bsStaticBlkParms(s))) -#define binsertStatic(b,p,s,f) ((binsertblk)((b), (p), bsStaticBlkParms(s), (f))) -#define bjoinStatic(b,s) ((bjoinblk)((b), bsStaticBlkParms(s))) -#define biseqStatic(b,s) ((biseqblk)((b), bsStaticBlkParms(s))) -#define bisstemeqStatic(b,s) ((bisstemeqblk)((b), bsStaticBlkParms(s))) -#define biseqcaselessStatic(b,s) ((biseqcaselessblk)((b), bsStaticBlkParms(s))) -#define bisstemeqcaselessStatic(b,s) ((bisstemeqcaselessblk)((b), bsStaticBlkParms(s))) - -/* Reference building macros */ -#define cstr2tbstr btfromcstr -#define btfromcstr(t,s) { \ - (t).data = (unsigned char *) (s); \ - (t).slen = ((t).data) ? ((int) (strlen) ((char *)(t).data)) : 0; \ - (t).mlen = -1; \ -} -#define blk2tbstr(t,s,l) { \ - (t).data = (unsigned char *) (s); \ - (t).slen = l; \ - (t).mlen = -1; \ -} -#define btfromblk(t,s,l) blk2tbstr(t,s,l) -#define bmid2tbstr(t,b,p,l) { \ - const_bstring bstrtmp_s = (b); \ - if (bstrtmp_s && bstrtmp_s->data && bstrtmp_s->slen >= 0) { \ - int bstrtmp_left = (p); \ - int bstrtmp_len = (l); \ - if (bstrtmp_left < 0) { \ - bstrtmp_len += bstrtmp_left; \ - bstrtmp_left = 0; \ - } \ - if (bstrtmp_len > bstrtmp_s->slen - bstrtmp_left) \ - bstrtmp_len = bstrtmp_s->slen - bstrtmp_left; \ - if (bstrtmp_len <= 0) { \ - (t).data = (unsigned char *)""; \ - (t).slen = 0; \ - } else { \ - (t).data = bstrtmp_s->data + bstrtmp_left; \ - (t).slen = bstrtmp_len; \ - } \ - } else { \ - (t).data = (unsigned char *)""; \ - (t).slen = 0; \ - } \ - (t).mlen = -__LINE__; \ -} -#define btfromblkltrimws(t,s,l) { \ - int bstrtmp_idx = 0, bstrtmp_len = (l); \ - unsigned char * bstrtmp_s = (s); \ - if (bstrtmp_s && bstrtmp_len >= 0) { \ - for (; bstrtmp_idx < bstrtmp_len; bstrtmp_idx++) { \ - if (!isspace (bstrtmp_s[bstrtmp_idx])) break; \ - } \ - } \ - (t).data = bstrtmp_s + bstrtmp_idx; \ - (t).slen = bstrtmp_len - bstrtmp_idx; \ - (t).mlen = -__LINE__; \ -} -#define btfromblkrtrimws(t,s,l) { \ - int bstrtmp_len = (l) - 1; \ - unsigned char * bstrtmp_s = (s); \ - if (bstrtmp_s && bstrtmp_len >= 0) { \ - for (; bstrtmp_len >= 0; bstrtmp_len--) { \ - if (!isspace (bstrtmp_s[bstrtmp_len])) break; \ - } \ - } \ - (t).data = bstrtmp_s; \ - (t).slen = bstrtmp_len + 1; \ - (t).mlen = -__LINE__; \ -} -#define btfromblktrimws(t,s,l) { \ - int bstrtmp_idx = 0, bstrtmp_len = (l) - 1; \ - unsigned char * bstrtmp_s = (s); \ - if (bstrtmp_s && bstrtmp_len >= 0) { \ - for (; bstrtmp_idx <= bstrtmp_len; bstrtmp_idx++) { \ - if (!isspace (bstrtmp_s[bstrtmp_idx])) break; \ - } \ - for (; bstrtmp_len >= bstrtmp_idx; bstrtmp_len--) { \ - if (!isspace (bstrtmp_s[bstrtmp_len])) break; \ - } \ - } \ - (t).data = bstrtmp_s + bstrtmp_idx; \ - (t).slen = bstrtmp_len + 1 - bstrtmp_idx; \ - (t).mlen = -__LINE__; \ -} - -/* Write protection macros */ -#define bwriteprotect(t) { if ((t).mlen >= 0) (t).mlen = -1; } -#define bwriteallow(t) { if ((t).mlen == -1) (t).mlen = (t).slen + ((t).slen == 0); } -#define biswriteprotected(t) ((t).mlen <= 0) - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/nserver/src/darray.c b/nserver/src/darray.c @@ -1,198 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2010, Zed A. Shaw. - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#include <darray.h> -#include <darray_algos.h> -#include <assert.h> - -DArray *DArray_create(size_t element_size, size_t initial_max) -{ - DArray *array = malloc(sizeof(DArray)); - check_mem(array); - array->max = initial_max; - check(array->max > 0, "You must set initial_max > 0."); - - array->contents = calloc(initial_max, sizeof(void *)); - check_mem(array->contents); - - array->end = 0; - array->element_size = element_size; - array->expand_rate = DEFAULT_EXPAND_RATE; - - return array; - - error: - if (array) - free(array); - return NULL; -} - -void DArray_clear(DArray *array) -{ - check(array != NULL, "array cannot be NULL"); - - int i = 0; - if (array->element_size > 0) { - for (i = 0; i < array->max; i++) { - if (array->contents[i] != NULL) { - free(array->contents[i]); - } - } - } - - error: - return; -} - -static inline int DArray_resize(DArray *array, size_t newsize) -{ - check(array != NULL, "array cannot be NULL"); - check((int) newsize >= array->end, "newsize must be >= end."); - - array->max = newsize; - check(array->max > 0, "The newsize must be > 0."); - - void *contents = realloc(array->contents, - array->max * sizeof(void *)); - // Check contents and assume realloc doesn't harm the original on error. - - check_mem(contents); - - array->contents = contents; - - return 0; - error: - return -1; -} - -int DArray_expand(DArray *array) -{ - size_t old_max = array->max; - check(DArray_resize(array, array->max + array->expand_rate) == 0, - "Failed to expand array to new size: %d", - array->max + (int) array->expand_rate); - - memset(array->contents + old_max, 0, (array->expand_rate) * sizeof(void *)); - - return 0; - - error: - return -1; -} - -int DArray_contract(DArray *array) -{ - check(array != NULL, "array cannot be NULL"); - - int new_size = array->end < (int) array->expand_rate ? - (int) array->expand_rate : array->end; - - return DArray_resize(array, new_size + 1); - error: - return -1; -} - -void DArray_destroy(DArray *array) -{ - if (array) { - if (array->contents) - free(array->contents); - free(array); - } -} - -void DArray_clear_destroy(DArray *array) -{ - DArray_clear(array); - DArray_destroy(array); -} - -int DArray_push(DArray *array, void *el) -{ - check(array != NULL, "array cannot be NULL"); - - array->contents[array->end] = el; - array->end++; - - if (DArray_end(array) >= DArray_max(array)) { - return DArray_expand(array); - } else { - return 0; - } - - error: - return -1; -} - -void *DArray_pop(DArray *array) -{ - check(array != NULL, "array cannot be NULL"); - check(array->end - 1 >= 0, "Attempt to pop from empty array."); - - void *el = DArray_remove(array, array->end - 1); - array->end--; - - if (DArray_end(array) > (int)array->expand_rate - && DArray_end(array) % array->expand_rate) { - DArray_contract(array); - } - - return el; - error: - return NULL; -} - -int DArray_sort_add(DArray *array, void *el, DArray_compare cmp) -{ - int rc; - rc = DArray_push(array, el); - check(rc == 0, "Error pushing element."); - - // sort the array. - rc = DArray_heapsort(array, cmp); - check(rc == 0, "Error sorting array."); - - return 0; - error: - return -1; -} - -DArray *DArray_shallow_copy(DArray *array) -{ - DArray *copy = DArray_create(array->element_size, array->max); - check(copy != NULL, "Error creating DArray copy."); - - int i = 0; - for (i = 0; i < array->max; i++) { - copy->contents[i] = array->contents[i]; - } - - return copy; - error: - return NULL; -} - -int DArray_find(DArray *array, void *el, DArray_compare cmp) -{ - int low = 0; - int high = DArray_end(array) - 1; - void *c = NULL; - - while (low <= high) { - int middle = low + (high - low) / 2; - c = DArray_get(array, middle); - - if (cmp(&el, &c) < 0) { - high = middle - 1; - } else if (cmp(&el, &c) > 0) { - low = middle + 1; - } else { - return middle; - } - } - - return -1; -} diff --git a/nserver/src/darray.h b/nserver/src/darray.h @@ -1,126 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2010, Zed A. Shaw. - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#ifndef _DArray_h -#define _DArray_h -#include <stdlib.h> -#include <assert.h> -#include <dbg.h> - -typedef struct DArray { - int end; - int max; - size_t element_size; - size_t expand_rate; - void **contents; -} DArray; - -typedef int (*DArray_compare) (const void *a, const void *b); - -DArray *DArray_create(size_t element_size, size_t initial_max); - -void DArray_destroy(DArray *array); - -void DArray_clear(DArray *array); - -int DArray_expand(DArray *array); - -int DArray_contract(DArray *array); - -int DArray_push(DArray *array, void *el); - -void *DArray_pop(DArray *array); - -int DArray_sort_add(DArray *array, void *el, DArray_compare cmp); - -int DArray_find(DArray *array, void *el, DArray_compare cmp); - -void DArray_clear_destroy(DArray *array); - -/** - * Creates a new DArray using `DArray_create` and copies the - * `contents` from array to the newly created DArray. - * - * Returns newly created DArray. - */ -DArray *DArray_shallow_copy(DArray *array); - -#define DArray_last(A) ((A)->contents[(A)->end - 1]) -#define DArray_first(A) ((A)->contents[0]) -#define DArray_end(A) ((A)->end) -#define DArray_count(A) DArray_end(A) -#define DArray_max(A) ((A)->max) - -#define DEFAULT_EXPAND_RATE 300 - -static inline int DArray_set(DArray *array, int i, void *el) -{ - check(array != NULL, "array cannot be NULL"); - check(i >= 0, "i cannot be lesser than 0"); - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wstrict-overflow" - check(i < array->max, "darray attempt to set past max"); -#pragma GCC diagnostic pop - - if (i > array->end) - array->end = i; - - array->contents[i] = el; - return i; - error: - return -1; -} - -static inline void *DArray_get(DArray *array, int i) -{ - check(array != NULL, "array cannot be NULL"); - check(i >= 0, "i cannot be lesser than 0"); - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wstrict-overflow" - check(i < array->max, "darray attempt to get past max"); -#pragma GCC diagnostic pop - - return array->contents[i]; - error: - return NULL; -} - -static inline void *DArray_remove(DArray *array, int i) -{ - check(array != NULL, "array cannot be NULL"); - check(i >= 0, "i cannot be lesser than 0"); - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wstrict-overflow" - check(i < array->max, "darray attempt to get past max"); -#pragma GCC diagnostic pop - - void *el = array->contents[i]; - - array->contents[i] = NULL; - - return el; - error: - return NULL; -} - -static inline void *DArray_new(DArray *array) -{ - check(array != NULL, "array cannot be NULL"); - check(array->element_size > 0, - "Can't use DArray_new on 0 size darrays."); - - return calloc(1, array->element_size); - - error: - return NULL; -} - -#define DArray_free(E) free((E)) - -#endif diff --git a/nserver/src/darray_algos.c b/nserver/src/darray_algos.c @@ -1,234 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2010, Zed A. Shaw. - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#include <darray_algos.h> - -int DArray_qsort(DArray *array, DArray_compare cmp) -{ - qsort(array->contents, DArray_count(array), sizeof(void *), cmp); - return 0; -} - -int DArray_heapsort(DArray *array, DArray_compare cmp) -{ - return heapsort(array->contents, DArray_count(array), - sizeof(void *), cmp); -} - -int DArray_mergesort(DArray *array, DArray_compare cmp) -{ - return mergesort(array->contents, DArray_count(array), - sizeof(void *), cmp); -} - -// Fucked Quick Sort. -int DArray_fucked_qsort_partition(DArray *array, DArray_compare cmp, - int low, int high) -{ - int i = 0, j = 0, cmp_rc; - void *pivot = NULL, *tmp = NULL; - - pivot = array->contents[high]; - i = low - 1; - - for (j = low; j < high; j++) { - cmp_rc = cmp(&array->contents[j], &pivot); - if (cmp_rc < 0) { - i = i + 1; - - // swap - tmp = array->contents[j]; - array->contents[j] = array->contents[i]; - array->contents[i] = tmp; - } - } - - cmp_rc = cmp(&array->contents[high], &array->contents[i + 1]); - if (cmp_rc < 0) { - tmp = array->contents[high]; - array->contents[high] = array->contents[i + 1]; - array->contents[i + 1] = tmp; - } - - return i + 1; -} - -int DArray_fucked_qsort_recurse(DArray *array, DArray_compare cmp, - int low, int high) -{ - int rc = 0, p = 0; - if (low < high) { - p = DArray_fucked_qsort_partition(array, cmp, low, high); - check(p >= 0, "Failed to partition [%d-%d]", low, high); - - rc = DArray_fucked_qsort_recurse(array, cmp, low, p - 1); - check(rc == 0, "Failed to quick sort sub array [%d-%d]", low, p-1); - - rc = DArray_fucked_qsort_recurse(array, cmp, p + 1, high); - check(rc == 0, "Failed to quick sort sub array [%d-%d]", p+1, high); - } - - return 0; - error: - return -1; -} - -int DArray_fucked_qsort(DArray *array, DArray_compare cmp) -{ - int rc; - rc = DArray_fucked_qsort_recurse(array, cmp, 0, DArray_end(array) - 1); - check(rc == 0, "Error sorting array."); - - return 0; - error: - return -1; -} - -// Fucked Heap Sort. -#define DArray_fucked_heapsort_iparent(i) ((floor(i - 1) / 2)) -#define DArray_fucked_heapsort_ileft_child(i) ((2*i + 1)) -#define DArray_fucked_heapsort_iright_child(i) ((2*i + 2)) - -static inline void DArray_fucked_heapsort_swap(DArray *array, int a, int b) -{ - void *tmp = array->contents[a]; - array->contents[a] = array->contents[b]; - array->contents[b] = tmp; -} - -int DArray_fucked_heapsort_sift_down(DArray *array, DArray_compare cmp, - int start, int end) -{ - - int root = start; - int child = 0; - int swap = 0; - - while (DArray_fucked_heapsort_ileft_child(root) <= end) { - child = DArray_fucked_heapsort_ileft_child(root); - swap = root; - - if (cmp(&array->contents[root], &array->contents[child]) < 0) { - swap = child; - } - if (((child + 1) <= end) - && (cmp(&array->contents[swap], &array->contents[child + 1]) < 0)) { - swap = child + 1; - } - if (swap == root) { - break; - } - - DArray_fucked_heapsort_swap(array, root, swap); - root = swap; - } - - return 0; -} - -int DArray_fucked_heapsort_heapify(DArray *array, DArray_compare cmp) -{ - int count = DArray_count(array); - int start = (int) DArray_fucked_heapsort_iparent(count - 1); - int rc = 0; - - - while (start >= 0) { - rc = DArray_fucked_heapsort_sift_down(array, cmp, start, count - 1); - check(rc == 0, "Error sifting down at %d %d", start, count - 1); - - start = start - 1; - } - - return 0; - error: - return -1; -} - -int DArray_fucked_heapsort(DArray *array, DArray_compare cmp) -{ - int rc = 0, end = 0; - - // First heapify array. - rc = DArray_fucked_heapsort_heapify(array, cmp); - check(rc == 0, "Error heapifying"); - - end = DArray_count(array) - 1; - while (end > 0) { - DArray_fucked_heapsort_swap(array, end, 0); - - end = end - 1; - rc = DArray_fucked_heapsort_sift_down(array, cmp, 0, end); - check(rc == 0, "Error sifting down at %d %d", 0, end); - } - - return 0; - error: - return -1; -} - -// Fucked Merge Sort. -void DArray_fucked_topdown_merge(DArray *a, DArray *b, - int begin, int middle, - int end, DArray_compare cmp) -{ - int i = 0, j = 0, k = 0; - - i = begin; - j = middle; - - for (k = begin; k < end; k++) { - if (i < middle && - (j >= end || cmp(&a->contents[i], &a->contents[j]) < 0)) { - DArray_set(b, k, DArray_get(a, i)); - i = i + 1; - } else { - DArray_set(b, k, DArray_get(a, j)); - j = j + 1; - } - } - - return; -} - -void DArray_fucked_topdown_split_merge(DArray *b, DArray *a, - int begin, int end, - DArray_compare cmp) -{ - if ((end - begin) < 2) { - return; - } - int middle = (end + begin) / 2; - - DArray_fucked_topdown_split_merge(a, b, begin, middle, cmp); - DArray_fucked_topdown_split_merge(a, b, middle, end, cmp); - - DArray_fucked_topdown_merge(b, a, begin, middle, end, cmp); - - return; -} - -int DArray_fucked_mergesort(DArray *array, DArray_compare cmp) -{ - DArray *copy = DArray_shallow_copy(array); - check(copy != NULL, "Error shallow copying array"); - - DArray *a = NULL, *b = NULL; - int begin = 0, end = 0; - - a = array; - b = copy; - begin = 0; - end = DArray_end(a); - DArray_fucked_topdown_split_merge(b, a, begin, end, cmp); - - // Clean up copy - DArray_destroy(copy); - - return 0; - error: - return -1; -} diff --git a/nserver/src/darray_algos.h b/nserver/src/darray_algos.h @@ -1,26 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2010, Zed A. Shaw. - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#ifndef darray_algos_h -#define darray_algos_h - -#include <math.h> -#include <stdlib.h> -#include <darray.h> - -int DArray_qsort(DArray *array, DArray_compare cmp); - -int DArray_heapsort(DArray *array, DArray_compare cmp); - -int DArray_mergesort(DArray *array, DArray_compare cmp); - -int DArray_fucked_qsort(DArray *array, DArray_compare cmp); - -int DArray_fucked_heapsort(DArray *array, DArray_compare cmp); - -int DArray_fucked_mergesort(DArray *array, DArray_compare cmp); - -#endif diff --git a/nserver/src/db.c b/nserver/src/db.c @@ -1,138 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#include <db.h> - -static const char *DB_FILE = "nserver.db"; - -datum *mk_datum(char *data) -{ - datum *d = NULL; - - check(data != NULL, "data invalid"); - - d = calloc(1, sizeof(datum)); - check(d != NULL, "datum mem alloc failed"); - - d->dptr = data; - d->dsize = strlen(data); - - return d; - error: - if (d) { - free(d); - } - return NULL; -} - -GDBM_FILE db_open(int flags) -{ - return gdbm_open(DB_FILE, 0,flags, S_IRUSR|S_IWUSR, NULL); -} - -int db_init() -{ - // Create DB if it's not already created. - GDBM_FILE gf = db_open(GDBM_WRCREAT); - check(gf != NULL, "unable to init db"); - - // Close the DB. - int rc = gdbm_close(gf); - check(rc == 0, "error closing db after init"); - - return 0; - error: - return -1; -} - -int db_store(char *key, char *value) -{ - datum *k_datum = NULL, *v_datum = NULL; - GDBM_FILE gf = NULL; - - check(key != NULL && strlen(key) > 0, "key invalid"); - check(value != NULL && strlen(value) > 0, "data invalid"); - - // make key value datum - k_datum = mk_datum(key); - check(k_datum != NULL, "key datum init failed"); - - v_datum = mk_datum(value); - check(v_datum != NULL, "value datum init failed"); - - // init db. - int rc = db_init(); - check(rc == 0, "db init failed"); - - // open the gdbm data in write mode - gf = db_open(GDBM_WRITER|GDBM_SYNC); - check(gf != NULL, "unable to open db in write mode"); - - // write key -> data to db. - rc = gdbm_store(gf, *k_datum, *v_datum, GDBM_REPLACE); - check(rc == 0, "gdbm store failed"); - - // close db - rc = gdbm_close(gf); - check(rc == 0, "gdbm close failed"); - - // cleanup. - free(k_datum); - free(v_datum); - - return 0; - error: - if (k_datum) { - free(k_datum); - } - if (v_datum) { - free(v_datum); - } - if (gf) { - gdbm_close(gf); - } - return -1; -} - -char *db_load(char *key) -{ - datum *k_datum = NULL; - GDBM_FILE gf = NULL; - - check(key != NULL && strlen(key) > 0, "key invalid"); - - // make key datum - k_datum = mk_datum(key); - check(k_datum != NULL, "key datum init failed"); - - // init db. - int rc = db_init(); - check(rc == 0, "db init failed"); - - // open the gdbm data in read mode - gf = db_open(GDBM_READER|GDBM_SYNC); - check(gf != NULL, "unable to open db in read mode"); - - // try to fetch value for key. - datum v_datum = gdbm_fetch(gf, *k_datum); - check(v_datum.dptr != NULL, "key not found"); - - // close db - rc = gdbm_close(gf); - check(rc == 0, "gdbm close failed"); - - // clean up. - free(k_datum); - - return v_datum.dptr; - error: - if (k_datum) { - free(k_datum); - } - if (gf) { - gdbm_close(gf); - } - return NULL; -} diff --git a/nserver/src/db.h b/nserver/src/db.h @@ -1,20 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#ifndef _db_h -#define _db_h - -#include <gdbm.h> -#include <dbg.h> -#include <stdlib.h> -#include <string.h> -#include <sys/stat.h> - -int db_init(); -int db_store(char *key, char *value); -char *db_load(char *key); - -#endif - diff --git a/nserver/src/dbg.h b/nserver/src/dbg.h @@ -1,48 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2010, Zed A. Shaw. - */ - -#ifndef __dbg_h__ -#define __dbg_h__ - -#include <stdio.h> -#include <errno.h> -#include <string.h> - -#ifdef NDEBUG -#define debug(M, ...) -#else -#define debug(M, ...) fprintf(stderr, "DEBUG %s:%s:%d: " M "\n", \ - __FILE__, __FUNCTION__, __LINE__, \ - ##__VA_ARGS__) -#endif - -#define clean_errno() (errno == 0 ? "None" : strerror(errno)) - -#define log_err(M, ...) fprintf(stderr, \ - "[ERROR] (%s:%s:%d: errno: %s) " M "\n", __FILE__, \ - __FUNCTION__, __LINE__, \ - clean_errno(), ##__VA_ARGS__) - -#define log_warn(M, ...) fprintf(stderr, \ - "[WARN] (%s:%s:%d: errno: %s) " M "\n", \ - __FILE__, __FUNCTION__, __LINE__, \ - clean_errno(), ##__VA_ARGS__) - -#define log_info(M, ...) fprintf(stderr, "[INFO] (%s:%s:%d) " M "\n", \ - __FILE__, __FUNCTION__, __LINE__, \ - ##__VA_ARGS__) - -#define check(A, M, ...) if(!(A)) {\ - log_err(M, ##__VA_ARGS__); errno=0; goto error; } - -#define sentinel(M, ...) { log_err(M, ##__VA_ARGS__);\ - errno=0; goto error; } - -#define check_mem(A) check((A), "Out of memory.") - -#define check_debug(A, M, ...) if(!(A)) { debug(M, ##__VA_ARGS__);\ - errno=0; goto error; } - -#endif diff --git a/nserver/src/hashmap.c b/nserver/src/hashmap.c @@ -1,341 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2010, Zed A. Shaw. - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#undef NDEBUG -#include <stdint.h> -#include <darray_algos.h> -#include <hashmap.h> -#include <dbg.h> -#include <bstrlib.h> - -static int default_compare(void *a, void *b) -{ - return bstrcmp((bstring) a, (bstring) b); -} - -/** - * Simple Bob Jenkin's hash algorithm taken from the wikipedia - * description. - */ -static uint32_t default_hash(void *a) -{ - size_t len = blength((bstring) a); - char *key = bdata((bstring) a); - uint32_t hash = 0; - uint32_t i = 0; - - for (hash = i = 0; i < len; ++i) { - hash += key[i]; - hash += (hash << 10); - hash ^= (hash >> 6); - } - - hash += (hash << 3); - hash ^= (hash >> 11); - hash += (hash << 15); - - return hash; -} - -/** - * Fucked up version of FNV hash - */ -uint32_t fnv_hash(void *a) -{ - size_t len = blength((bstring) a); - char *key = bdata((bstring) a); - uint32_t hash = 0; - uint32_t i = 0; - uint32_t fnv_prime = 16777619; - uint32_t fnv_offset_basis = 2166136261; - - hash = fnv_offset_basis; - for (i = 0; i < len; ++i) { - hash *= fnv_prime; - hash ^= key[i]; - } - - return hash; -} - -Hashmap *Hashmap_create(Hashmap_compare compare, Hashmap_hash hash) -{ - Hashmap *map = calloc(1, sizeof(Hashmap)); - check_mem(map); - - map->compare = compare == NULL ? default_compare : compare; - map->hash = hash == NULL ? default_hash : hash; - map->salt = rand() >> 16; - map->buckets = DArray_create( - sizeof(DArray *), DEFAULT_NUMBER_OF_BUCKETS); - map->buckets->end = map->buckets->max; // fake out expanding it. - check_mem(map->buckets); - - return map; - - error: - if (map) { - Hashmap_destroy(map); - } - - return NULL; -} - -void Hashmap_destroy(Hashmap *map) -{ - int i = 0; - int j = 0; - - if (map) { - if (map->buckets) { - for (i = 0; i < DArray_count(map->buckets); i++) { - DArray *bucket = DArray_get(map->buckets, i); - if (bucket) { - for (j = 0; j < DArray_count(bucket); j++) { - free(DArray_get(bucket, j)); - } - DArray_destroy(bucket); - } - } - DArray_destroy(map->buckets); - } - - free(map); - } -} - -static inline HashmapNode *Hashmap_node_create(int hash, void *key, - void *data) -{ - HashmapNode *node = calloc(1, sizeof(HashmapNode)); - check_mem(node); - - node->key = key; - node->data = data; - node->hash = hash; - - return node; - - error: - return NULL; -} - -static inline DArray *Hashmap_find_bucket(Hashmap *map, void *key, - int create, - uint32_t *hash_out) -{ - uint32_t hash = map->hash(key) + map->salt; - int bucket_n = hash % DEFAULT_NUMBER_OF_BUCKETS; - check(bucket_n >= 0, "Invalid bucket found %d", bucket_n); - // store it for the return so the caller can use it - *hash_out = hash; - - DArray *bucket = DArray_get(map->buckets, bucket_n); - - if (!bucket && create) { - // new bucket, set it up - bucket = DArray_create( - sizeof(void *), DEFAULT_NUMBER_OF_BUCKETS); - check_mem(bucket); - DArray_set(map->buckets, bucket_n, bucket); - } - - return bucket; - - error: - return NULL; -} - -int Hashmap_delete_bucket(Hashmap *map, uint32_t hash) -{ - int bucket_n = hash % DEFAULT_NUMBER_OF_BUCKETS; - check(bucket_n >= 0, "Invalid bucket found %d", bucket_n); - - // Get bucket. - DArray *bucket = DArray_get(map->buckets, bucket_n); - if(bucket) { - // Remove bucket. - DArray_clear_destroy(bucket); - DArray_remove(map->buckets, bucket_n); - } - - return 0; - error: - return -1; -} - -int Hashmap_set(Hashmap *map, void *key, void *data) -{ - uint32_t hash = 0; - DArray *bucket = Hashmap_find_bucket(map, key, 1, &hash); - check(bucket, "Error can't create bucket"); - - HashmapNode *node = Hashmap_node_create(hash, key, data); - check_mem(node); - - DArray_push(bucket, node); - - // Sort the bucket. - int rc = DArray_heapsort(bucket, (DArray_compare) map->compare); - check(rc == 0, "Error sorting bucket"); - - return 0; - - error: - return -1; -} - -static inline int Hashmap_get_node(Hashmap *map, uint32_t hash, - DArray *bucket, void *key) -{ - int i = 0; - - for (i = 0; i < DArray_end(bucket); i++) { - debug("TRY: %d", i); - HashmapNode *node = DArray_get(bucket, i); - if (node->hash == hash && map->compare(node->key, key) == 0) { - return i; - } - } - - return -1; -} - -void *Hashmap_get(Hashmap *map, void *key) -{ - uint32_t hash = 0; - DArray *bucket = Hashmap_find_bucket(map, key, 0, &hash); - if (!bucket) return NULL; - - int i = Hashmap_get_node(map, hash, bucket, key); - if (i == -1) return NULL; - - HashmapNode *node = DArray_get(bucket, i); - check(node != NULL, - "Failed to get node from bucket when it should exist."); - - return node->data; - - error: - return NULL; -} - -/** - * Sets key <-> data iff key is not already present in Hashmap. - */ -int Hashmap_set_fucked(Hashmap *map, void *key, void *data) -{ - uint32_t hash = 0; - DArray *bucket = Hashmap_find_bucket(map, key, 1, &hash); - check(bucket, "Error can't create bucket"); - - int i = Hashmap_get_node(map, hash, bucket, key); - if (i >= 0) { - // Element with `key` already exists. Do nothing. - return 0; - } - - // Element with `key` does not exist. Add it to Hashmap. - HashmapNode *node = Hashmap_node_create(hash, key, data); - check_mem(node); - - DArray_push(bucket, node); - - // Sort the bucket. - int rc = DArray_heapsort(bucket, (DArray_compare) map->compare); - check(rc == 0, "Error sorting bucket"); - - return 1; - error: - return -1; -} - -int Hashmap_traverse(Hashmap *map, Hashmap_traverse_cb traverse_cb) -{ - int i = 0; - int j = 0; - int rc = 0; - - for (i = 0; i < DArray_count(map->buckets); i++) { - DArray *bucket = DArray_get(map->buckets, i); - if (bucket) { - for (j = 0; j < DArray_count(bucket); j++) { - HashmapNode *node = DArray_get(bucket, j); - rc = traverse_cb(node); - if (rc != 0) - return rc; - } - } - } - - return 0; -} - -/** - * Returns all keys of the hashmap as a DArray. - * - * Use DArray_destroy on the 'keys' returned by this function after - * use. - */ -DArray *Hashmap_keys(Hashmap *map) -{ - check(map != NULL, "map is NULL"); - - DArray *keys = DArray_create(sizeof(void *), - DEFAULT_NUMBER_OF_KEYS); - check(keys != NULL, "Unable to initialize keys"); - - int i = 0; - int j = 0; - - for (i = 0; i < DArray_count(map->buckets); i++) { - DArray *bucket = DArray_get(map->buckets, i); - if (bucket) { - for (j = 0; j < DArray_count(bucket); j++) { - HashmapNode *node = DArray_get(bucket, j); - - if (node) { - DArray_push(keys, node->key); - } - } - } - } - - return keys; - error: - return NULL; -} - -void *Hashmap_delete(Hashmap *map, void *key) -{ - uint32_t hash = 0; - DArray *bucket = Hashmap_find_bucket(map, key, 0, &hash); - if (!bucket) - return NULL; - - int i = Hashmap_get_node(map, hash, bucket, key); - if (i == -1) - return NULL; - - HashmapNode *node = DArray_get(bucket, i); - void *data = node->data; - free(node); - - HashmapNode *ending = DArray_pop(bucket); - - if (ending != node) { - // alright looks like it's not the last one, swap it. - DArray_set(bucket, i, ending); - } else { - // alright looks like it's the last one, destroy bucket. - check(Hashmap_delete_bucket(map, hash) == 0, - "Error destroy bucket"); - } - - return data; - error: - return NULL; -} diff --git a/nserver/src/hashmap.h b/nserver/src/hashmap.h @@ -1,49 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2010, Zed A. Shaw. - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#ifndef _lcthw_Hashmap_h -#define _lcthw_Hashmap_h - -#include <stdint.h> -#include <darray.h> - -#define DEFAULT_NUMBER_OF_BUCKETS 100 -#define DEFAULT_NUMBER_OF_KEYS 50 - -typedef int (*Hashmap_compare) (void *a, void *b); -typedef uint32_t(*Hashmap_hash) (void *key); - -typedef struct Hashmap { - DArray *buckets; - Hashmap_compare compare; - Hashmap_hash hash; - int salt; -} Hashmap; - - -typedef struct HashmapNode { - void *key; - void *data; - uint32_t hash; -} HashmapNode; - -typedef int (*Hashmap_traverse_cb) (HashmapNode *node); - -Hashmap *Hashmap_create(Hashmap_compare, Hashmap_hash); -void Hashmap_destroy(Hashmap *map); - -int Hashmap_set(Hashmap *map, void *key, void *data); -int Hashmap_set_fucked(Hashmap *map, void *key, void *data); -void *Hashmap_get(Hashmap *map, void *key); - -int Hashmap_traverse(Hashmap *map, Hashmap_traverse_cb travers_cb); - -void *Hashmap_delete(Hashmap *map, void *key); - -DArray *Hashmap_keys(Hashmap *map); - -uint32_t fnv_hash(void *a); -#endif diff --git a/nserver/src/ncmd.c b/nserver/src/ncmd.c @@ -1,351 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#include <ncmd.h> - -int sanitize(char *cmd) -{ - check(cmd != NULL, "cmd is NULL"); - - int len = strlen(cmd); - check(len > 0, "cmd empty"); - - // replace newline character with NUL. - for (int i = 0; i < len; i++) { - if (cmd[i] == '\n') { - cmd[i] = '\0'; - - break; - } - } - return 0; - error: - return -1; -} - -int check_cmd(char *cmd, char *err) -{ - check_mem(err); - check(cmd != NULL, "cmd is NULL"); - - int rc = sanitize(cmd); - check(rc != -1, "sanitize failed"); - - size_t len = strlen(cmd); - if (len >= CMD_MIN_SIZE && len <= CMD_MAX_SIZE) { - return 0; - } - - if (len == 0) { - strncpy(err, "closing connection\n", RSP_SIZE); - return -1; - } else { - strncpy(err, "command size invalid\n", RSP_SIZE); - return -1; - } - - return 0; - error: - strncpy(err, "internal error\n", RSP_SIZE); - return -1; -} - - -struct bstrList *cmd_parts(char *cmd) -{ - bstring bcmd = NULL; - struct bstrList *parts_tmp = NULL; - - bcmd = bfromcstr(cmd); - check(bcmd != NULL, "bstring creation failed"); - - parts_tmp = bsplit(bcmd, ' '); - check(parts_tmp != NULL, "cmp split failed"); - check(parts_tmp->qty > 0, "qty check failed"); - - struct bstrList *parts = bstrListCreate(); - check(parts != NULL, "parts create failed"); - - int rc = bstrListAlloc(parts, parts_tmp->qty); - check(rc == BSTR_OK, "parts alloc failed"); - check(parts->qty == 0, "qty check failed"); - - bstring part = NULL; - int index = 0; - for (int i = 0; i < parts_tmp->qty; i++) { - check(parts->qty <= parts->mlen, "parts capacity check failed"); - - part = parts_tmp->entry[i]; - - if (blength(part) == 0) { - continue; - } - - parts->entry[index++] = bstrcpy(part); - parts->qty++; - } - - // Clean up. - bdestroy(bcmd); - bstrListDestroy(parts_tmp); - - return parts; - error: - // Clean up. - if (bcmd) { - bdestroy(bcmd); - } - if (parts_tmp) { - bstrListDestroy(parts_tmp); - } - - return NULL; -} - -int find_function(struct bstrList *cmd_parts) -{ - // functions. - struct tagbstring fcreate = bsStatic("/create"); - struct tagbstring fsample = bsStatic("/sample"); - struct tagbstring fmean = bsStatic("/mean"); - struct tagbstring fdump = bsStatic("/dump"); - struct tagbstring fdelete = bsStatic("/delete"); - struct tagbstring flist = bsStatic("/list"); - struct tagbstring fstore = bsStatic("/store"); - struct tagbstring fload = bsStatic("/load"); - - check(cmd_parts != NULL, "cmd_parts is NULL"); - check(cmd_parts->qty > 0, "qty check failed"); - - bstring cmd_name = cmd_parts->entry[0]; - check(blength(cmd_name) > 0, "cmd_name check failed"); - - // trim cmd name - int rc = btrimws(cmd_name); - check(rc == BSTR_OK, "cmd name trim failed"); - - // find function for cmd_name - if (bstricmp(cmd_name, &fcreate) == 0) { - return NS_CREATE; - } else if (bstricmp(cmd_name, &fsample) == 0) { - return NS_SAMPLE; - } else if (bstricmp(cmd_name, &fmean) == 0) { - return NS_MEAN; - } else if (bstricmp(cmd_name, &fdump) == 0) { - return NS_DUMP; - } else if (bstricmp(cmd_name, &fdelete) == 0) { - return NS_DELETE; - } else if (bstricmp(cmd_name, &flist) == 0) { - return NS_LIST; - } else if (bstricmp(cmd_name, &fstore) == 0) { - return NS_STORE; - } else if (bstricmp(cmd_name, &fload) == 0) { - return NS_LOAD; - } else { - return NS_NOP; - } - - error: - return NS_NOP; -} - -int check_args(struct bstrList *cmd_parts, int argc) -{ - check(cmd_parts != NULL, "cmd_parts is NULL"); - check(cmd_parts->qty == argc, "qty check failed"); - - bstring part = NULL; - for (int i = 0; i < argc; i++) { - part = cmd_parts->entry[i]; - - check(blength(part) > 0, "part %d empty", i); - } - - return 0; - error: - return -1; -} - -int call_function(int func, struct bstrList *cmd_parts, char *out) -{ - check(out != NULL, "out invalid"); - - if (func < 0 || cmd_parts == NULL || cmd_parts->qty < 1) { - strncpy(out, "error: args invalid\n", RSP_SIZE); - - return -1; - } - - double mean = 0.0; - switch (func) { - case NS_CREATE: - if(check_args(cmd_parts, 2) != 0) { - strncpy(out, "error: command invalid\n", RSP_SIZE); - - return -1; - } - if (sscreate(bdata(cmd_parts->entry[1])) < 0) { - strncpy(out, "error: create failed\n", RSP_SIZE); - - return -1; - } - strncpy(out, "OK\n", RSP_SIZE); - - break; - case NS_SAMPLE: - if(check_args(cmd_parts, 3) != 0) { - strncpy(out, "error: command invalid\n", RSP_SIZE); - - return -1; - } - - double sample = strtod(bdata(cmd_parts->entry[2]), NULL); - mean = sssample(bdata(cmd_parts->entry[1]), sample); - if (mean < 0) { - strncpy(out, "error: sample failed\n", RSP_SIZE); - - return -1; - } - if (sprintf(out, "Mean: %.2f\n", mean) < 0) { - strncpy(out, "error: sample failed\n", RSP_SIZE); - - return -1; - } - break; - case NS_MEAN: - if(check_args(cmd_parts, 2) != 0) { - strncpy(out, "error: command invalid\n", RSP_SIZE); - - return -1; - } - - mean = ssmean(bdata(cmd_parts->entry[1])); - if (mean < 0) { - strncpy(out, "error: mean failed\n", RSP_SIZE); - - return -1; - } - if (sprintf(out, "Mean: %.2f\n", mean) < 0) { - strncpy(out, "error: mean failed\n", RSP_SIZE); - - return -1; - } - break; - case NS_DUMP: - if(check_args(cmd_parts, 2) != 0) { - strncpy(out, "error: command invalid\n", RSP_SIZE); - - return -1; - } - - char *dump = ssdump(bdata(cmd_parts->entry[1])); - if (dump == NULL) { - strncpy(out, "error: dump failed\n", RSP_SIZE); - - return -1; - } - strncpy(out, dump, RSP_SIZE); - - // Clean up dump - free(dump); - - break; - case NS_DELETE: - if(check_args(cmd_parts, 2) != 0) { - strncpy(out, "error: command invalid\n", RSP_SIZE); - - return -1; - } - - if (ssdelete(bdata(cmd_parts->entry[1])) != 0) { - strncpy(out, "error: delete failed\n", RSP_SIZE); - - return -1; - } - strncpy(out, "OK\n", RSP_SIZE); - - break; - case NS_LIST: - if(check_args(cmd_parts, 1) != 0) { - strncpy(out, "error: command invalid\n", RSP_SIZE); - - return -1; - } - - char *list = sslist(); - if (list == NULL) { - strncpy(out, "error: list failed\n", RSP_SIZE); - - return -1; - } - strncpy(out, list, RSP_SIZE); - - // Clean up list. - free(list); - - break; - case NS_STORE: - if(check_args(cmd_parts, 2) != 0) { - strncpy(out, "error: command invalid\n", RSP_SIZE); - - return -1; - } - if (ssstore(bdata(cmd_parts->entry[1])) < 0) { - strncpy(out, "error: store failed\n", RSP_SIZE); - - return -1; - } - strncpy(out, "OK\n", RSP_SIZE); - break; - case NS_LOAD: - if(check_args(cmd_parts, 3) != 0) { - strncpy(out, "error: command invalid\n", RSP_SIZE); - - return -1; - } - if (ssload(bdata(cmd_parts->entry[1]), - bdata(cmd_parts->entry[2])) < 0) { - strncpy(out, "error: load failed\n", RSP_SIZE); - - return -1; - } - strncpy(out, "OK\n", RSP_SIZE); - break; - default: - strncpy(out, "error: function not found\n", RSP_SIZE); - - return -1; - } - - return 0; - error: - return -1; -} - -int process(char *cmd, char *out) -{ - check(out, "out invalid"); - - int rc = check_cmd(cmd, out); - check(rc == 0, "cmd check failed"); - - // split cmd into parts. - struct bstrList *parts = cmd_parts(cmd); - check(parts != NULL, "cmd_parts failed"); - check(parts->qty > 0, "bstrList qty check failed"); - - // call find_function. - int FUNC = find_function(parts); - check(FUNC != -1, "find function failed"); - - // call call_function - rc = call_function(FUNC, parts, out); - check(rc != -1, "call function failed"); - - return 0; - error: - return -1; -} - diff --git a/nserver/src/ncmd.h b/nserver/src/ncmd.h @@ -1,41 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#ifndef _ncmd_h -#define _ncmd_h - -#include <string.h> - -#include <bstrlib.h> -#include <dbg.h> -#include <protocol.h> - -#define CMD_MIN_SIZE 5 -#define CMD_MAX_SIZE 120 -#define RSP_SIZE 200 - -enum FUNCTIONS { - NS_CREATE, - NS_SAMPLE, - NS_MEAN, - NS_DUMP, - NS_DELETE, - NS_LIST, - NS_STORE, - NS_LOAD, - NS_NOP = -1 -}; - -int sanitize(char *cmd); -int check_cmd(char *cmd, char *err); - -struct bstrList *cmd_parts(char *cmd); - -int find_function(struct bstrList *cmd_parts); -int call_function(int func, struct bstrList *cmd_parts, char *out); - -int process(char *cmd, char *out); - -#endif diff --git a/nserver/src/nserve.c b/nserver/src/nserve.c @@ -1,78 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#include <nserve.h> - -int slurpsock(char *buf, size_t buf_sz, int sock) -{ - ssize_t bytes; - - bytes = recv(sock, buf, buf_sz, 0); - check(bytes >= 0, "Failed to read from socket: %d", sock); - - return bytes; - - error: - return -1; -} - -int barfsock(char *buf, size_t buf_sz, int sock) -{ - ssize_t bytes = 0; - - bytes = send(sock, buf, buf_sz, 0); - check(bytes >= 0, "barfsock: send failed"); - - return bytes; - error: - return -1; -} - -void nserve(int sock) -{ - char *out = (char *) calloc(RSP_SIZE + 1, sizeof(char)); - check_mem(out); - - char *cmd = (char *) calloc(CMD_MAX_SIZE + 1, sizeof(char)); - check_mem(cmd); - - int rc = 0, done = 0; - do { - // clear out, cmd. - memset(out, '\0', RSP_SIZE + 1); - memset(cmd, '\0', CMD_MAX_SIZE + 1); - - // Read command from socket. - ssize_t bytes = slurpsock(cmd, CMD_MAX_SIZE, sock); - check(bytes >= 0, "nserve: slurpsock failed"); - - rc = process(cmd, out); - if (rc < 0) { - done = 1; - } - - // Write response to socket. - rc = barfsock(out, strlen(out), sock); - check(rc != -1, "nserve: echo failed"); - } while(done != 1); - - // Close socket. - rc = close(sock); - check(rc == 0, "nserve: close failed"); - - // Cleanup. - free(cmd); - - exit(0); - error: - rc = close(sock); - check(rc == 0, "nserve: close failed"); - - // Cleanup if needed. - if (cmd) - free(cmd); - - exit(1); -} diff --git a/nserver/src/nserve.h b/nserver/src/nserve.h @@ -1,20 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#ifndef _nserve_h -#define _nserve_h - -#include <stdlib.h> -#include <string.h> -#include <unistd.h> -#include <sys/socket.h> - -#include <bstrlib.h> -#include <ncmd.h> -#include <dbg.h> - -void nserve(int sock); - -#endif diff --git a/nserver/src/nsocket.c b/nserver/src/nsocket.c @@ -1,61 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#include <nsocket.h> - -int get_socket() -{ - int sockfd = 0; - int rc = 0; - int y = 1; - - struct addrinfo hints; - struct addrinfo *servinfo = NULL; - struct addrinfo *addr = NULL; - - memset(&hints, 0, sizeof(hints)); - hints.ai_family = AF_UNSPEC; - hints.ai_socktype = SOCK_STREAM; - hints.ai_flags = AI_PASSIVE; - - rc = getaddrinfo(NULL, PORT, &hints, &servinfo); - check(rc == 0, "get_socket: getaddrinfo failed"); - - // Loop through the addresses and find one that works. - for (addr = servinfo; addr != NULL; sockfd = 0, - addr = addr->ai_next) { - sockfd = socket(addr->ai_family, addr->ai_socktype, - addr->ai_protocol); - if (sockfd < 1) { - continue; - } - - // dodge the "address already in use" error. - rc = setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, - &y, sizeof(int)); - if (rc != 0) { - continue; - } - - // assign name to socket. - rc = bind(sockfd, addr->ai_addr, addr->ai_addrlen); - if (rc != 0) { - continue; - } - - break; - } - check(sockfd > 0, "unable to get socket"); - - // Cleanup. - freeaddrinfo(servinfo); - - return sockfd; - error: - if (servinfo) - freeaddrinfo(servinfo); - - return -1; -} diff --git a/nserver/src/nsocket.h b/nserver/src/nsocket.h @@ -1,19 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#ifndef _nsocket_h -#define _nsocket_h - -#include <sys/types.h> -#include <sys/socket.h> -#include <netdb.h> - -#include <dbg.h> - -#define PORT "7899" - -int get_socket(); - -#endif diff --git a/nserver/src/protocol.c b/nserver/src/protocol.c @@ -1,310 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#include <protocol.h> - -static TSTree *tst; - -int sscreate(char *key) -{ - check(key != NULL || strlen(key) < 1, "key invalid"); - - // 1. Check if key is already in the tree. - Record *rec = (Record *) TSTree_search(tst, key, strlen(key)); - - // If it's already there; there's nothing to do. - if (rec != NULL && rec->deleted == 0) { - return 1; - } - // If it's already there and deleted, undelete it. - if (rec != NULL && rec->deleted == 1) { - rec->deleted = 0; - - // Allocate fresh Stats. - rec->st = Stats_create(); - check(rec->st != NULL, "stats creation failed"); - - return 2; - } - - // 2. Create bstring from 'key'. - bstring k = bfromcstr(key); - check(k != NULL, "key creation failed"); - - // 3. Allocate fresh Stats. - Stats *st = Stats_create(); - check(st != NULL, "stats creation failed"); - - // 4. Create Record. - rec = (Record *) calloc(1, sizeof(Record)); - check_mem(rec); - - // 5. Initialize Record. - rec->key = k; - rec->st = st; - rec->deleted = 0; - - // 6. Add Record to tree. - tst = TSTree_insert(tst, key, strlen(key), rec); - check(tst != NULL, "tstree insert failed"); - - return 0; - error: - return -1; -} - -int ssdelete(char *key) -{ - check(key != NULL || strlen(key) < 1, "key invalid"); - check(tst != NULL, "tstree not initialized"); - - Record *rec = (Record *) TSTree_search(tst, key, strlen(key)); - if (rec == NULL) { - // key does not exists. - return 0; - } - - // Mark as deleted. - rec->deleted = 1; - - // Free Stats. - free(rec->st); - - return 0; - error: - return -1; -} - -int sssample_parent(char *key, double s) -{ - check(key != NULL || strlen(key) < 1, "key invalid"); - check(tst != NULL, "tstree not initialized"); - - // 1. Try to get Record with key prefix. - Record *rec = (Record *) TSTree_search_prefix(tst, key, strlen(key)); - - if (rec == NULL) { - // No record with key prefix. - return 0; - } - check(rec->st != NULL, "record's st invalid"); - - if (rec->deleted == 1) { - // Record was deleted; nop. - return 0; - } - - // 2. Sample! - Stats_sample(rec->st, s); - - return 1; - error: - return -1; -} - -double sssample(char *key, double s) -{ - check(key != NULL || strlen(key) < 1, "key invalid"); - check(tst != NULL, "tstree not initialized"); - - // 1. Try to get Record for key. - Record *rec = (Record *) TSTree_search(tst, key, strlen(key)); - - check(rec != NULL, "record not found"); - check(rec->st != NULL, "record's st invalid"); - check(rec->deleted != 1, "record was deleted"); - - // 2. Sample! - Stats_sample(rec->st, s); - - // 3. Sample parent! - int rc = sssample_parent(key, s); - check(rc >= 0, "sampling parent failed"); - - // 4. Get mean. - double m = Stats_mean(rec->st); - - return m; - error: - return -1; -} - -double ssmean(char *key) -{ - check(key != NULL || strlen(key) < 1, "key invalid"); - check(tst != NULL, "tstree not initialized"); - - // 1. Try to get Record for key. - Record *rec = (Record *) TSTree_search(tst, key, strlen(key)); - - check(rec != NULL, "record not found"); - check(rec->deleted != 1, "record was deleted"); - check(rec->st != NULL, "record's st invalid"); - - // 2. Get mean. - double m = Stats_mean(rec->st); - - return m; - error: - return -1; -} - -char *ssdump(char *key) -{ - check(key != NULL && strlen(key) > 0, "key invalid"); - check(tst != NULL, "tstree not initialized"); - - // 1. create bstring from 'key'. - Record *rec = (Record *) TSTree_search(tst, key, strlen(key)); - - check(rec != NULL, "record not found"); - check(rec->st != NULL, "stats not found for key"); - check(rec->deleted != 1, "record was deleted"); - - // 2. get dump. - char *dstr = Stats_dump(rec->st); - check(dstr != NULL, "dump failed for key"); - - return dstr; - error: - return NULL; -} - -// meant to be used by sslist. -void traverse_tree(void *value, void *data) -{ - Record *rec = (Record *) value; - bstring bstr = (bstring) data; - - check(rec != NULL, "Record is NULL"); - check(rec->deleted != 1, "Record was deleted"); - check(bstr != NULL, "bstr is NULL"); - check(rec->key != NULL, "Record's key is NULL"); - check(blength(rec->key) > 0, "Record's key is an empty string"); - - int rc = bconcat(bstr, rec->key); - check(rc == BSTR_OK, "bstr key concat failed"); - - rc = bconchar(bstr, '\n'); - check(rc == BSTR_OK, "bstr newline concat failed"); - - error: - return; -} - - -char *sslist() -{ - char *list = NULL, *tmp = NULL; - - if (tst == NULL) { - list = (char *) calloc(7 + 1, sizeof(char)); - check_mem(list); - - list = strncpy(list, "EMPTY\n\r", 7); - - return list; - } - - // 1. Create "accumulator" string. - bstring ks_str = bfromcstr(""); - check(ks_str != NULL, "error creating keys_str"); - - // 2. Accumulate keys into "accumulator" string. - TSTree_traverse(tst, traverse_tree, ks_str); - - // 3. Make result. - tmp = bstr2cstr(ks_str, ' '); - - list = (char *) calloc(strlen(tmp) + 1, sizeof(char)); - check_mem(list); - - list = strncpy(list, tmp, strlen(tmp)); - - // 4. Clean up. - bcstrfree(tmp); - - // 3. Return result. - return list; - error: - if (tmp) { - bcstrfree(tmp); - } - return NULL; -} - -int ssstore(char *key) -{ - check(key != NULL && strlen(key) > 0, "key invalid"); - check(tst != NULL, "tstree not initialized"); - - // 1. create bstring from 'key'. - Record *rec = (Record *) TSTree_search(tst, key, strlen(key)); - - check(rec != NULL, "record not found"); - check(rec->st != NULL, "stats not found for key"); - check(rec->deleted != 1, "record was deleted"); - - // 2. stringify the stats. - char *st_str = Stats_stringify(rec->st); - check(st_str != NULL, "stats stringify failed"); - - // 3. store stats in db. - int rc = db_store(key, st_str); - check(rc == 0, "db store failed"); - - return 0; - error: - return -1; -} - -int ssload(char *from, char *to) -{ - check(from != NULL && strlen(from) > 0, "from invalid"); - check(to != NULL && strlen(to) > 0, "to invalid"); - check(tst != NULL, "tstree not initialized"); - - // 1. Check if 'to' key already exists. - Record *rec = (Record *) TSTree_search(tst, to, strlen(to)); - - // 2. if 'to' key exists return immediately with -2. - if (rec != NULL && rec->deleted == 0) { - return -2; - } - - // 3. read 'from' key from database. - char *st_str = db_load(from); - check(st_str != NULL, "db load failed"); - - // 4. construct stats from string. - Stats *st = Stats_unstringify(st_str); - check(st != NULL, "stats unstringify failed"); - - // 5. create Record if needed. - int rec_created = 0; - if (rec == NULL) { - rec = (Record *) calloc(1, sizeof(Record)); - check_mem(rec); - rec_created = 1; - } - - // 6. get things ready for insertiion - bstring tk = bfromcstr(to); - check(tk != NULL, "key creation failed"); - - rec->key = tk; - rec->st = st; - rec->deleted = 0; - - // 7. insert Record into 'to' key in the TSTree if needed. - if (rec_created == 1) { - tst = TSTree_insert(tst, to, strlen(to), rec); - check(tst != NULL, "tstree insert failed"); - } - - return 0; - error: - return -1; -} diff --git a/nserver/src/protocol.h b/nserver/src/protocol.h @@ -1,34 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#ifndef _protocol_h -#define _protocol_h - - -#include <bstrlib.h> -#include <darray.h> -#include <db.h> -#include <hashmap.h> -#include <stats.h> -#include <tstree.h> -#include <dbg.h> - -typedef struct Record { - bstring key; - Stats *st; - int deleted; -} Record; - -int sscreate(char *key); -int ssdelete(char *key); -double sssample(char *key, double s); -double ssmean(char *key); -char *ssdump(char *key); -char *sslist(); -int ssstore(char *key); -int ssload(char *from, char *to); - - -#endif diff --git a/nserver/src/stats.c b/nserver/src/stats.c @@ -1,128 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2010, Zed A. Shaw. - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#include <math.h> -#include <stats.h> - -Stats *Stats_recreate(double sum, double sumsq, unsigned long n, - double min, double max) -{ - Stats *st = malloc(sizeof(Stats)); - check_mem(st); - - st->sum = sum; - st->sumsq = sumsq; - st->n = n; - st->min = min; - st->max = max; - - return st; - - error: - return NULL; -} - -Stats *Stats_create() -{ - return Stats_recreate(0.0, 0.0, 0L, 0.0, 0.0); -} - -void Stats_sample(Stats *st, double s) -{ - st->sum += s; - st->sumsq += s * s; - - if (st->n == 0) { - st->min = s; - st->max = s; - } else { - if (st->min > s) - st->min = s; - if (st->max < s) - st->max = s; - } - - st->n += 1; -} - -char *Stats_dump(Stats *st) -{ - size_t char_sz = sizeof(char); - size_t dstr_len = 280 * char_sz; - - // allocate space for dump string. - char *dstr = calloc(dstr_len, char_sz); - check_mem(dstr); - - // dump into dump str. - int rc = snprintf(dstr, dstr_len, - "sum: %f, sumsq: %f, n: %ld, " - "min: %f, max: %f, mean: %f, stddev: %f\n", - st->sum, st->sumsq, st->n, st->min, st->max, - Stats_mean(st), Stats_stddev(st)); - check(rc > 0, "stats dump failed"); - - return dstr; - error: - return NULL; -} - -char *Stats_stringify(Stats *st) -{ - size_t stats_str_len = 80; - - // allocate space for stringified stats. - char *stats_str = calloc(stats_str_len, sizeof(char)); - check_mem(stats_str); - - // stringify the stats - int rc = snprintf(stats_str, stats_str_len, - "%.2f:%.2f:%ld:%.2f:%.2f", - st->sum, st->sumsq, st->n, st->min, st->max); - check(rc > 0, "stringify stats failed"); - - return stats_str; - error: - if (stats_str) { - free(stats_str); - } - return NULL; -} - - -Stats *Stats_unstringify(char *st_str) -{ - Stats *st = NULL; - - check(st_str != NULL, "st_str invalid"); - - bstring st_bstr = bfromcstr(st_str); - check(st_bstr != NULL, "st_str bstring convert failed"); - - struct bstrList *st_list = bsplit(st_bstr, ':'); - check(st_list != NULL, "st_bstr split failed"); - check(st_list->qty == 5, "wrong number of st parts"); - - st = Stats_create(); - check(st != NULL, "stats creation failed"); - - st->sum = atof(bdata(st_list->entry[0])); - st->sumsq = atof(bdata(st_list->entry[1])); - st->n = atoi(bdata(st_list->entry[2])); - st->min = atof(bdata(st_list->entry[3])); - st->max = atof(bdata(st_list->entry[4])); - - // clean up. - int rc = bstrListDestroy(st_list); - check(rc == BSTR_OK, "st_list destroy failed"); - - return st; - error: - if (st) { - free(st); - } - return NULL; -} diff --git a/nserver/src/stats.h b/nserver/src/stats.h @@ -1,47 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2010, Zed A. Shaw. - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#ifndef stats_h -#define stats_h - -#include <math.h> -#include <stdlib.h> -#include <bstrlib.h> -#include <dbg.h> - -typedef struct Stats { - double sum; - double sumsq; - unsigned long n; - double min; - double max; -} Stats; - -Stats *Stats_recreate(double sum, double sumsq, unsigned long n, - double min, double max); - -Stats *Stats_create(); - -void Stats_sample(Stats *st, double s); - -char *Stats_dump(Stats *st); - -char *Stats_stringify(Stats *st); - -Stats *Stats_unstringify(char *st_str); - -static inline double Stats_mean(Stats *st) -{ - return st->sum / st->n; -} - -static inline double Stats_stddev(Stats *st) -{ - return sqrt((st->sumsq - (st->sum * st->sum / st->n)) / - (st->n - 1)); -} - -#endif diff --git a/nserver/src/tstree.c b/nserver/src/tstree.c @@ -1,256 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2010, Zed A. Shaw. - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#include <stdlib.h> -#include <stdio.h> -#include <string.h> -#include <assert.h> -#include <dbg.h> -#include <tstree.h> - -static inline TSTree *TSTree_insert_base(TSTree *root, TSTree *node, - const char *key, size_t len, - void *value) -{ - if (node == NULL) { - node = (TSTree *) calloc(1, sizeof(TSTree)); - - if (root == NULL) { - root = node; - } - - node->splitchar = *key; - } - - if (*key < node->splitchar) { - node->low = TSTree_insert_base(root, - node->low, key, len, value); - } else if (*key == node->splitchar) { - if (len > 1) { - node->equal = TSTree_insert_base(root, node->equal, - key + 1, len -1 , value); - } else { - assert(node->value == NULL && "Duplicate insert into tst."); - node->value = value; - } - } else { - node->high = TSTree_insert_base(root, node->high, - key, len, value); - } - - return node; -} - -TSTree *TSTree_insert(TSTree *node, const char *key, size_t len, - void *value) -{ - return TSTree_insert_base(node, node, key, len, value); -} - -void *TSTree_search(TSTree *root, const char *key, size_t len) -{ - TSTree *node = root; - size_t i = 0; - - while (i < len && node) { - if (key[i] < node->splitchar) { - node = node->low; - } else if (key[i] == node->splitchar) { - i++; - if (i < len) - node = node->equal; - } else { - node = node->high; - } - } - - if (node) { - return node->value; - } else { - return NULL; - } -} - -void *TSTree_search_prefix(TSTree *root, const char *key, size_t len) -{ - if (len == 0) - return NULL; - - TSTree *node = root; - TSTree *last = NULL; - size_t i = 0; - - while (i < len && node) { - if (key[i] < node->splitchar) { - node = node->low; - } else if (key[i] == node->splitchar) { - i++; - if (i < len) { - if (node->value) { - last = node->value; - } - node = node->equal; - } - } else { - node = node->high; - } - } - - return last; -} - -void TSTree_collect_keys(TSTree *node, char *key, size_t key_sz, DArray *array) -{ - if (!node) { - return; - } - - strcat(key, &node->splitchar); - - key_sz += 2; - key = (char *) realloc(key, key_sz); - - if (node->value) { - char *key_cpy = (char *) calloc(key_sz, sizeof(char)); - strcpy(key_cpy, key); - DArray_push(array, key_cpy); - } - - if (node->low) { - TSTree_collect_keys(node->low, key, key_sz, array); - } - - if (node->equal) { - TSTree_collect_keys(node->equal, key, key_sz, array); - } - - if (node->high) { - TSTree_collect_keys(node->high, key, key_sz, array); - } -} - -size_t TSTree_collect_keycat(char *key, size_t key_sz, char *c) { - // Expand key. - key_sz += 2; - key = (char *) realloc(key, key_sz); - check(key != NULL, "Unable to expand key"); - - // Concat. - key = strcat(key, c); - check(key != NULL, "key cat failed"); - - return key_sz; - error: - if (key) { - free(key); - } - return 0; -} - -DArray *TSTree_collect(TSTree *root, const char *key, size_t len) -{ - char *ckey = NULL; - - DArray *array = DArray_create(sizeof(void), 1); - check(array != NULL, "Unable to initialize DArray"); - - if (len == 0) - return array; - - TSTree *node = root; - TSTree *last = NULL; - size_t i = 0; - - size_t ckey_sz = 4; - ckey = (char *) calloc(ckey_sz, sizeof(char)); - check(ckey != NULL, "Unable to initialize ckey"); - ckey[0] = '\0'; - - while (i < len && node) { - if (key[i] < node->splitchar) { - node = node->low; - } else if (key[i] == node->splitchar) { - i++; - if (i < len) { - ckey_sz = TSTree_collect_keycat(ckey, ckey_sz, - &node->splitchar); - check(ckey_sz > 0, "keycat failed"); - - if (node->value) { - last = node; - } - node = node->equal; - } - } else { - node = node->high; - } - } - node = node ? node : last; - - while (node && !node->value) { - ckey_sz = TSTree_collect_keycat(ckey, ckey_sz, - &node->splitchar); - check(ckey_sz > 0, "keycat failed"); - - node = node->equal; - } - - if (node) { - TSTree_collect_keys(node, ckey, ckey_sz, array); - } - - // Clean up. - free(ckey); - - return array; - - error: - // Clean up. - if (array) { - DArray_destroy(array); - } - if (ckey) { - free(ckey); - } - return NULL; -} - -void TSTree_traverse(TSTree *node, TSTree_traverse_cb cb, void *data) -{ - if (!node) - return; - - if (node->low) - TSTree_traverse(node->low, cb, data); - - if (node->equal) { - TSTree_traverse(node->equal, cb, data); - } - - if (node->high) - TSTree_traverse(node->high, cb, data); - - if (node->value) - cb(node->value, data); -} - -void TSTree_destroy(TSTree *node) -{ - if (node == NULL) - return; - - if (node->low) - TSTree_destroy(node->low); - - if (node->equal) { - TSTree_destroy(node->equal); - } - - if (node->high) - TSTree_destroy(node->high); - - free(node); -} diff --git a/nserver/src/tstree.h b/nserver/src/tstree.h @@ -1,36 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2010, Zed A. Shaw. - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#ifndef _TSTree_h -#define _TSTree_h - -#include <stdlib.h> -#include <darray.h> - -typedef struct TSTree { - char splitchar; - struct TSTree *low; - struct TSTree *equal; - struct TSTree *high; - void *value; -} TSTree; - -void *TSTree_search(TSTree *root, const char *key, size_t len); - -void *TSTree_search_prefix(TSTree *root, const char *key, size_t len); - -DArray *TSTree_collect(TSTree *root, const char *key, size_t len); - -typedef void (* TSTree_traverse_cb) (void *value, void *data); - -TSTree *TSTree_insert(TSTree *node, const char *key, size_t len, - void *value); - -void TSTree_traverse(TSTree *node, TSTree_traverse_cb cb, void *data); - -void TSTree_destroy(TSTree *root); - -#endif diff --git a/nserver/tests/darray_algos_tests.c b/nserver/tests/darray_algos_tests.c @@ -1,102 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2010, Zed A. Shaw. - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#include "minunit.h" -#include <darray_algos.h> - -int testcmp(char **a, char **b) -{ - return strcmp(*a, *b); -} - -DArray *create_words() -{ - DArray *result = DArray_create(0, 5); - char *words[] = { "asdfasfd", - "werwar", "13234", "asdfasfd", "oioj" }; - int i = 0; - - for (i = 0; i < 5; i++) { - DArray_push(result, words[i]); - } - - return result; -} - -int is_sorted(DArray *array) -{ - int i = 0; - - for (i = 0; i < DArray_count(array) -1; i++) { - if (strcmp(DArray_get(array, i), DArray_get(array, i + 1)) > 0) { - return 0; - } - } - - return 1; -} - -char *run_sort_test(int (*func) (DArray *, DArray_compare), - const char *name) -{ - DArray *words = create_words(); - mu_assert(!is_sorted(words), "Words should start not sorted."); - - debug("--- Testing %s sorting algorithm", name); - int rc = func(words, (DArray_compare) testcmp); - mu_assert(rc == 0, "sort failed"); - mu_assert(is_sorted(words), "didn't sort it"); - - DArray_destroy(words); - - return NULL; -} - -char *test_qsort() -{ - return run_sort_test(DArray_qsort, "qsort"); -} - -char *test_fucked_qsort() -{ - return run_sort_test(DArray_fucked_qsort, "fucked qsort"); -} - -char *test_heapsort() -{ - return run_sort_test(DArray_heapsort, "heapsort"); -} - -char *test_fucked_heapsort() -{ - return run_sort_test(DArray_fucked_heapsort, "fucked heapsort"); -} - -char *test_mergesort() -{ - return run_sort_test(DArray_mergesort, "mergesort"); -} - -char *test_fucked_mergesort() -{ - return run_sort_test(DArray_fucked_mergesort, "fucked mergesort"); -} - -char *all_tests() -{ - mu_suite_start(); - - mu_run_test(test_qsort); - mu_run_test(test_fucked_qsort); - mu_run_test(test_heapsort); - mu_run_test(test_fucked_heapsort); - mu_run_test(test_mergesort); - mu_run_test(test_fucked_mergesort); - - return NULL; -} - -RUN_TESTS(all_tests); diff --git a/nserver/tests/darray_tests.c b/nserver/tests/darray_tests.c @@ -1,361 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2010, Zed A. Shaw. - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#include "minunit.h" -#include <darray.h> - -static DArray *array = NULL; -static int *val1 = NULL; -static int *val2 = NULL; - -int testcmp(int **a, int **b) -{ - int x = **a, y = **b; - - if (x == y) { - return 0; - } else if (x < y) { - return -1; - } else { - return 1; - } -} - -char *test_create() -{ - // Test fail. - array = DArray_create(0, 0); - mu_assert(array == NULL, "array must be NULL."); - - // Test success. - array = DArray_create(sizeof(int), 100); - mu_assert(array != NULL, "DArray_create failed."); - mu_assert(array->contents != NULL, "contents are wrong in array."); - mu_assert(array->end == 0, "end isn't at the right spot"); - mu_assert(array->element_size == sizeof(int), - "element size is wrong."); - mu_assert(array->max == 100, "wrong max length on initial size"); - - return NULL; -} - -char *test_destroy() -{ - DArray_destroy(array); - - return NULL; -} - -char *test_new() -{ - // Test fail. - val1 = DArray_new(NULL); - mu_assert(val1 == NULL, "val1 must be NULL"); - - // Test success - val1 = DArray_new(array); - mu_assert(val1 != NULL, "failed to make a new element"); - - val2 = DArray_new(array); - mu_assert(val2 != NULL, "failed to make a new element"); - - return NULL; -} - -char *test_set() -{ - int rc = 0; - - // Test fail. - - // case where array is NULL - rc = DArray_set(NULL, 0, val1); - mu_assert(rc == -1, "rc must be -1"); - - // case where i < 0 - rc = DArray_set(array, -1, val1); - mu_assert(rc == -1, "rc must be -1"); - - // case where i > array->max - rc = DArray_set(array, array->max + 1, val1); - mu_assert(rc == -1, "rc must be -1"); - - // Test success. - - // must set val1 at index 0 - rc = DArray_set(array, 0, val1); - mu_assert(rc == 0, "rc must be 0"); - - // must set val2 at index 1 - rc = DArray_set(array, 1, val2); - mu_assert(rc == 1, "rc must be 1"); - - return NULL; -} - -char *test_get() -{ - void *rc = NULL; - - // Test fail. - - // case where array is NULL - rc = DArray_get(NULL, 0); - mu_assert(rc == NULL, "rc must be NULL"); - - // case where i < 0 - rc = DArray_get(array, -2); - mu_assert(rc == NULL, "rc must be NULL"); - - // case where i > array->max - rc = DArray_get(array, array->max + 1); - mu_assert(rc == NULL, "rc must be NULL"); - - // Test succcess. - mu_assert(DArray_get(array, 0) == val1, "Wrong first value"); - mu_assert(DArray_get(array, 1) == val2, "Wrong second value"); - - return NULL; -} - -char *test_remove() -{ - int *val_check = NULL; - - // Test fail. - - // case where array is NULL. - val_check = DArray_remove(NULL, 0); - mu_assert(val_check == NULL, "val_check must be NULL"); - mu_assert(array->contents[0] != NULL, - "array->contents[0] must not be NULL"); - - // case where i < 0 - val_check = DArray_remove(array, -1); - mu_assert(val_check == NULL, "val_check must be NULL"); - - // case where i > array->max - val_check = DArray_remove(array, array->max + 1); - mu_assert(val_check == NULL, "val_check must be NULL"); - - // Test success. - val_check = DArray_remove(array, 0); - mu_assert(val_check !=NULL, "Should not get NULL"); - mu_assert(*val_check == *val1, "Should get the first value."); - mu_assert(DArray_get(array, 0) == NULL, "Should be gone."); - DArray_free(val_check); - - val_check = DArray_remove(array, 1); - mu_assert(val_check != NULL, "Should not get NULL."); - mu_assert(*val_check == *val2, "Should get second value."); - mu_assert(DArray_get(array, 1) == NULL, "Should be gone"); - DArray_free(val_check); - - return NULL; -} - -char *test_expand_contract() -{ - int old_max = array->max; - DArray_expand(array); - mu_assert((unsigned int) array->max == old_max + array->expand_rate, - "Wrong size after expand."); - - // Check if newly allocated space is all set to 0. - int i = 0; - for (i = old_max; i < array->max; i++) { - mu_assert(array->contents[i] == 0, "contents must be 0"); - } - - int rc = 0; - rc = DArray_contract(array); - mu_assert(rc == 0, "rc must be 0"); - mu_assert((unsigned int) array->max == array->expand_rate + 1, - "Should stay at the expand_rate at least."); - - rc = DArray_contract(array); - mu_assert(rc == 0, "rc must be 0"); - mu_assert((unsigned int) array->max == array->expand_rate + 1, - "Should stay at the expand_rate at least"); - - return NULL; -} - -char *test_push_pop() -{ - int i = 0, rc = 0; - for (i = 0; i < 1000; i++) { - int *val = DArray_new(array); - *val = i * 333; - rc = DArray_push(array, val); - mu_assert(rc == 0, "Darray_push failed"); - } - - mu_assert(array->max == 1201, "Wrong max size."); - - for (i = 999; i >= 0; i--) { - int *val = DArray_pop(array); - mu_assert(val != NULL, "Shouldn't get a NULL"); - mu_assert(*val == i * 333, "Wrong value."); - - if ((DArray_end(array) > (int) array->expand_rate) && - (DArray_end(array) % array->expand_rate)) { - mu_assert(array->max == DArray_end(array) + 1, - "DArray pop contract error"); - } - - DArray_free(val); - } - - return NULL; -} - -int is_sorted(DArray *array) -{ - int i = 0; - - for (i = 0; i < DArray_count(array) -1; i++) { - if (*((int *) DArray_get(array, i)) > *((int *) DArray_get(array, i + 1))) { - return 0; - } - } - - return 1; -} - -char *test_shallow_copy() -{ - // First populate array. - array = DArray_create(sizeof(int), 100); - int i = 0, rc = 0; - int *val = NULL; - for (i = 0; i < 1000; i++) { - val = DArray_new(array); - *val = i * 333; - rc = DArray_push(array, val); - mu_assert(rc == 0, "Darray_push failed"); - } - mu_assert(array->max == 1300, "Wrong max size."); - - // Set at 1100 - val = DArray_new(array); - *val = 42; - rc = DArray_set(array, 1100, val); - mu_assert(rc == 1100, "Error setting value at 1100"); - - // Set at 1110 - val = DArray_new(array); - *val = 4242; - rc = DArray_set(array, 1110, val); - mu_assert(rc == 1110, "Error setting value at 1110"); - - // Test shallow copy - DArray *copy = DArray_shallow_copy(array); - mu_assert(copy != NULL, "Shallow copy failed"); - - int expected = 0; - for (i = 0; i < 1000; i++) { - expected = i * 333; - val = DArray_get(copy, i); - mu_assert(*val == expected, "Unexpected element in copy."); - } - - expected = 42; - val = DArray_get(copy, 1100); - mu_assert(*val == expected, "Unexpected element at in copy."); - - expected = 4242; - val = DArray_get(copy, 1110); - mu_assert(*val == expected, "Unexpected element at in copy."); - - // Destroy copy. - DArray_destroy(copy); - - // Destroy array. - DArray_clear_destroy(array); - return NULL; -} - -char *test_sort_add() -{ - array = DArray_create(sizeof(int), 100); - mu_assert(array != NULL, "Error initializing array"); - - int i = 0, rc = 0; - int *val = NULL; - for (i = 0; i < 2000; i++) { - val = DArray_new(array); - mu_assert(val != NULL, "Error creating new element"); - *val = rand(); - - rc = DArray_sort_add(array, val, (DArray_compare) testcmp); - mu_assert(rc == 0, "Error adding element."); - mu_assert(is_sorted(array) == 1, "array not sorted."); - } - - DArray_clear_destroy(array); - return NULL; -} - -char *test_find() -{ - array = DArray_create(sizeof(int), 100); - mu_assert(array != NULL, "Error initializing array"); - - // test setup. - int i = 0, rc = 0; - int *val = NULL; - for (i = 0; i < 2000; i++) { - val = DArray_new(array); - mu_assert(val != NULL, "Error creating new element"); - *val = i; - - rc = DArray_sort_add(array, val, (DArray_compare) testcmp); - mu_assert(rc == 0, "Error adding element"); - mu_assert(is_sorted(array) == 1, "array not sorted"); - } - - // tests. - val = DArray_new(array); - mu_assert(val != NULL, "Error creating new element"); - - for (i = 0; i < 2000; i++) { - *val = i; - - rc = DArray_find(array, val, (DArray_compare) testcmp); - mu_assert(rc == i, "val not found in array"); - } - - *val = 3000; - rc = DArray_find(array, val, (DArray_compare) testcmp); - mu_assert(rc == -1, "rc must be -1"); - - // test teardown. - DArray_clear_destroy(array); - free(val); - return NULL; -} - -char *all_tests() -{ - mu_suite_start(); - - mu_run_test(test_create); - mu_run_test(test_new); - mu_run_test(test_set); - mu_run_test(test_get); - mu_run_test(test_remove); - mu_run_test(test_expand_contract); - mu_run_test(test_push_pop); - mu_run_test(test_destroy); - mu_run_test(test_shallow_copy); - mu_run_test(test_sort_add); - mu_run_test(test_find); - - return NULL; -} - -RUN_TESTS(all_tests); diff --git a/nserver/tests/db_tests.c b/nserver/tests/db_tests.c @@ -1,55 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#include "minunit.h" -#include <db.h> - -char *test_db_init() -{ - int rc = db_init(); - mu_assert(rc == 0, "db init failed"); - - return NULL; -} - -char *test_db_store() -{ - char *k = "hello"; - char *v = "kirk"; - - int rc = db_store(k, v); - mu_assert(rc == 0, "db store failed"); - - return NULL; -} - -char *test_db_load() -{ - char *k = "hello"; - char *expected_v = "kirk"; - - char *v = db_load(k); - mu_assert(v != NULL, "key not found"); - mu_assert(strncmp(v, expected_v, strlen(expected_v)) == 0, - "incorrect value for key"); - - // cleanup. - free(v); - - return NULL; -} - -char *all_tests() -{ - mu_suite_start(); - - mu_run_test(test_db_init); - mu_run_test(test_db_store); - mu_run_test(test_db_load); - - return NULL; -} - -RUN_TESTS(all_tests); diff --git a/nserver/tests/hashmap_tests.c b/nserver/tests/hashmap_tests.c @@ -1,311 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2010, Zed A. Shaw. - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#include "minunit.h" -#include <hashmap.h> -#include <assert.h> -#include <bstrlib.h> - -Hashmap *map = NULL; -Hashmap *map_alt = NULL; -static int traverse_called = 0; -static int traverse_duplicates = 0; -struct tagbstring test0 = bsStatic("test data 0"); -struct tagbstring test1 = bsStatic("test data 1"); -struct tagbstring test2 = bsStatic("test data 2"); -struct tagbstring test3 = bsStatic("xest data 3"); -struct tagbstring expect0 = bsStatic("THE VALUE 0"); -struct tagbstring expect1 = bsStatic("THE VALUE 1"); -struct tagbstring expect2 = bsStatic("THE VALUE 2"); -struct tagbstring expect3 = bsStatic("THE VALUE 3"); - -static int traverse_good_cb(HashmapNode *node) -{ - debug("KEY: %s", bdata((bstring) node->key)); - traverse_called++; - return 0; -} - -static int traverse_fail_cb(HashmapNode *node) -{ - debug("KEY %s", bdata((bstring) node->key)); - traverse_called++; - - if (traverse_called == 2) { - return 1; - } else { - return 0; - } -} - -static int traverse_duplicates_cb(HashmapNode *node) -{ - if ((bstring) node->data == &expect1) { - ++traverse_duplicates; - } - - return 0; -} - -int non_empty_buckets(Hashmap *map) -{ - int i = 0, non_empty = 0; - - for (i = 0; i < DArray_count(map->buckets); i++) { - DArray *bucket = DArray_get(map->buckets, i); - if (bucket) { - non_empty += 1; - } - } - - return non_empty; -} - -char *test_create() -{ - map = Hashmap_create(NULL, NULL); - mu_assert(map != NULL, "Failed to create map."); - - map_alt = Hashmap_create(NULL, (Hashmap_hash) fnv_hash); - mu_assert(map != NULL, "Failde to create map_alt."); - - return NULL; -} - -char *test_destroy() -{ - Hashmap_destroy(map); - Hashmap_destroy(map_alt); - return NULL; -} - -char *test_get_test() -{ - int rc = Hashmap_set(map, &test1, &expect1); - mu_assert(rc == 0, "Failed to set &test1"); - bstring result = Hashmap_get(map, &test1); - mu_assert(result == &expect1, "Wron value for test1."); - - rc = Hashmap_set(map, &test2, &expect2); - mu_assert(rc == 0, "Failed to test test2"); - result = Hashmap_get(map, &test2); - mu_assert(result == &expect2, "Wrong value for test2."); - - rc = Hashmap_set(map, &test3, &expect3); - mu_assert(rc == 0, "Failed to set test3"); - result = Hashmap_get(map, &test3); - mu_assert(result == &expect3, "Wrong value for test3"); - - return NULL; -} - -char *test_traverse() -{ - int rc = Hashmap_traverse(map, traverse_good_cb); - mu_assert(rc == 0, "Failed to traverse"); - mu_assert(traverse_called == 3, "Wrong count traverse"); - - traverse_called = 0; - rc = Hashmap_traverse(map, traverse_fail_cb); - mu_assert(rc == 1, "Failed to traverse."); - mu_assert(traverse_called == 2, "Wrong count traverse for fail."); - - return NULL; -} - -char *test_keys() -{ - DArray *keys = Hashmap_keys(map); - mu_assert(keys != NULL, "Unable to get hashmap's keys"); - mu_assert(DArray_count(keys) == 3, "Expected three keys"); - - for (int i = 0; i < DArray_count(keys); i++) { - char *k = bdata((bstring) DArray_get(keys, i)); - - debug("KEY: %s", k); - } - - // clean up. - DArray_destroy(keys); - - return NULL; -} - -char *test_delete() -{ - bstring deleted = (bstring) Hashmap_delete(map, &test1); - mu_assert(deleted != NULL, "Got NULL on delete"); - mu_assert(deleted == &expect1, "Should get test1"); - bstring result = Hashmap_get(map, &test1); - mu_assert(result == NULL, "Should delete"); - - deleted = (bstring) Hashmap_delete(map, &test2); - mu_assert(deleted != NULL, "Got NULL on delete"); - mu_assert(deleted == &expect2, "Should get test2"); - result = Hashmap_get(map, &test2); - mu_assert(result == NULL, "Should delete"); - - deleted = (bstring) Hashmap_delete(map, &test3); - mu_assert(deleted != NULL, "Got NULL on delete."); - mu_assert(deleted == &expect3, "Should get test3"); - result = Hashmap_get(map, &test3); - mu_assert(result == NULL, "Should delete."); - - return NULL; -} - -char *test_bucket_destruction() -{ - int rc = 0, non_empty = 0; - bstring deleted = NULL; - - // Insert some elements. - rc = Hashmap_set(map, &test1, &expect1); - mu_assert(rc == 0, "Failed to set &test1 0"); - rc = Hashmap_set(map, &test2, &expect2); - mu_assert(rc == 0, "Failed to test test2"); - - // Non-empty buckets test. - non_empty = non_empty_buckets(map); - mu_assert(non_empty == 2, "Expected two non-empty buckets"); - - // Remove test1 - deleted = Hashmap_delete(map, &test1); - mu_assert(deleted != NULL, "Error deleting test1"); - - // Non-empty buckets test. - non_empty = non_empty_buckets(map); - mu_assert(non_empty == 1, "Expected one non-empty buckets"); - - // Remove test2 - deleted = Hashmap_delete(map, &test2); - mu_assert(deleted != NULL, "Error deleting test2"); - - // Non-empty buckets test. - non_empty = non_empty_buckets(map); - mu_assert(non_empty == 0, "Expected one non-empty buckets"); - - return NULL; -} - -char *test_set_duplicates() -{ - int rc = 0; - - // Insert test1 two times. - rc = Hashmap_set(map, &test1, &expect1); - mu_assert(rc == 0, "Failed to set &test1 0"); - rc = Hashmap_set(map, &test1, &expect1); - mu_assert(rc == 0, "Failed to set &test1 1"); - - // Insert test2 one time. - rc = Hashmap_set(map, &test2, &expect2); - mu_assert(rc == 0, "Failed to test test2"); - - // Insert test3 one time. - rc = Hashmap_set(map, &test3, &expect3); - mu_assert(rc == 0, "Failed to set test3"); - - // Test there are two test1 nodes. - traverse_duplicates = 0; - rc = Hashmap_traverse(map, traverse_duplicates_cb); - mu_assert(traverse_duplicates == 2, - "traverse_duplicates must be 2"); - - // Cleanup - bstring deleted = NULL; - deleted = Hashmap_delete(map, &test1); - mu_assert(deleted != NULL, "Error deleting test1 0"); - deleted = Hashmap_delete(map, &test1); - mu_assert(deleted != NULL, "Error deleting test1 1"); - deleted = Hashmap_delete(map, &test2); - mu_assert(deleted != NULL, "Error deleting test2"); - deleted = Hashmap_delete(map, &test3); - mu_assert(deleted != NULL, "Error deleting test3"); - - return NULL; -} - -char *test_set_fucked() -{ - int rc = 0; - - // Insert test1 three times. - rc = Hashmap_set_fucked(map, &test1, &expect1); - mu_assert(rc == 1, "Failed to set fuck &test1 0"); - rc = Hashmap_set_fucked(map, &test1, &expect1); - mu_assert(rc == 0, "Failed to set fuck &test1 1"); - rc = Hashmap_set_fucked(map, &test1, &expect1); - mu_assert(rc == 0, "Failed to set fuck &test1 2"); - - // Insert test2 one time. - rc = Hashmap_set_fucked(map, &test2, &expect2); - mu_assert(rc == 1, "Failed to test test2"); - - // Insert test3 one time. - rc = Hashmap_set_fucked(map, &test3, &expect3); - mu_assert(rc == 1, "Failed to set test3"); - - // Test there are two test1 nodes. - traverse_duplicates = 0; - rc = Hashmap_traverse(map, traverse_duplicates_cb); - mu_assert(traverse_duplicates == 1, - "traverse_duplicates must be 1"); - - // Cleanup - bstring deleted = NULL; - deleted = Hashmap_delete(map, &test1); - mu_assert(deleted != NULL, "Error deleting test1"); - deleted = Hashmap_delete(map, &test1); - mu_assert(deleted == NULL, "Error test1 must be already deleted"); - deleted = Hashmap_delete(map, &test2); - mu_assert(deleted != NULL, "Error deleting test2"); - deleted = Hashmap_delete(map, &test3); - mu_assert(deleted != NULL, "Error deleting test3"); - - return NULL; -} - -char *test_fnv_hash() -{ - uint32_t hash[3]; - - hash[0] = fnv_hash(&test0); - mu_assert(hash[0] > 0, "hash not set correctly for key test0"); - - hash[1] = fnv_hash(&test1); - mu_assert(hash[1] > 0, "hash not set correctly for key test1"); - - hash[2] = fnv_hash(&test2); - mu_assert(hash[2] > 0, "hash not set correctly for key test2"); - - // Check all three hashes are different. - mu_assert(hash[0] != hash[1], "hash for test0 = hash for test1"); - mu_assert(hash[0] != hash[2], "hash for test0 = hash for test2"); - mu_assert(hash[1] != hash[2], "hash for test1 = hash for test2"); - - return NULL; -} - -char *all_tests() -{ - mu_suite_start(); - - mu_run_test(test_create); - mu_run_test(test_get_test); - mu_run_test(test_traverse); - mu_run_test(test_keys); - mu_run_test(test_delete); - mu_run_test(test_bucket_destruction); - mu_run_test(test_set_duplicates); - mu_run_test(test_set_fucked); - mu_run_test(test_fnv_hash); - mu_run_test(test_destroy); - - return NULL; -} - -RUN_TESTS(all_tests); diff --git a/nserver/tests/minunit.h b/nserver/tests/minunit.h @@ -1,38 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2010, Zed A. Shaw. - */ - -#undef NDEBUG -#ifndef _minunit_h -#define _minunit_h - -#include <stdio.h> -#include <dbg.h> -#include <stdlib.h> - -#define mu_suite_start() char *message = NULL - -#define mu_assert(test, message) if (!(test)) {\ - log_err(message); return message; } -#define mu_run_test(test) debug("\n-----%s", " " #test); \ - message = test(); tests_run++; if (message) return message; - -#define RUN_TESTS(name) int main(int argc, char *argv[]) {\ - argc = 1; \ - debug("----- RUNNING: %s", argv[0]); \ - printf("----\nRUNNING: %s\n", argv[0]);\ - char *result = name();\ - if (result != 0) {\ - printf("FAILED: %s\n", result); \ - }\ - else {\ - printf("ALL TESTS PASSED\n");\ - }\ - printf("Tests run: %d\n", tests_run);\ - exit(result != 0);\ - } - -int tests_run; - -#endif diff --git a/nserver/tests/ncmd_tests.c b/nserver/tests/ncmd_tests.c @@ -1,492 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#include "minunit.h" -#include <ncmd.h> - -char *test_sanitize() -{ - char *cmd = calloc(128, sizeof(char)); - mu_assert(cmd != NULL, "calloc failed"); - - char *c_cmd = "/create api/beef\n"; - size_t c_cmd_sz = strlen(c_cmd); - - strncpy(cmd, c_cmd, c_cmd_sz + 1); - mu_assert(strlen(cmd) == c_cmd_sz, "strncpy failed"); - - sanitize(cmd); - mu_assert(strlen(cmd) == c_cmd_sz - 1, "sanitize failed"); - mu_assert(strcmp(cmd, "/create api/beef") == 0, "sanitize failed"); - - - // Clear cmd. - memset(cmd, '\0', 128); - - - c_cmd = "/create api/ham\n\n\n"; - c_cmd_sz = strlen(c_cmd); - - strncpy(cmd, c_cmd, c_cmd_sz + 1); - mu_assert(strlen(cmd) == c_cmd_sz, "strncpy failed"); - - sanitize(cmd); - mu_assert(strlen(cmd) == c_cmd_sz - 3, "sanitize failed"); - mu_assert(strcmp(cmd, "/create api/ham") == 0, "sanitize failed"); - - - // Clear cmd. - memset(cmd, '\0', 128); - - - c_cmd = "/create api/bacon\n/create api/turkey\n"; - c_cmd_sz = strlen(c_cmd); - - strncpy(cmd, c_cmd, c_cmd_sz + 1); - mu_assert(strlen(cmd) == c_cmd_sz, "strncpy failed"); - - sanitize(cmd); - mu_assert(strlen(cmd) == c_cmd_sz - 20, "sanitize failed"); - mu_assert(strcmp(cmd, "/create api/bacon") == 0, "sanitize failed"); - - - // Cleanup. - free(cmd); - - return NULL; -} - -char *test_check_cmd() -{ - char *err = (char *) calloc(RSP_SIZE, sizeof(char)); - - char *cmd = (char *) calloc(128, sizeof(char)); - mu_assert(cmd != NULL, "calloc failed"); - - char *bacon = "/create api/bacon"; - strncpy(cmd, bacon, strlen(bacon)); - mu_assert(strlen(cmd) == strlen(bacon), "strncpy failed"); - - int rc = check_cmd(cmd, err); - mu_assert(rc == 0, "check_cmd failed"); - - memset(err, '\0', RSP_SIZE); - memset(cmd, '\0', 128); - - char *c = "/c"; - strncpy(cmd, c, strlen(c)); - mu_assert(strlen(cmd) == strlen(c), "strncpy failed"); - - rc = check_cmd(cmd, err); - mu_assert(rc < 0, "check_cmd failed"); - mu_assert(strcmp(err, "command size invalid\n") == 0, - "wrong err msg"); - - memset(err, '\0', RSP_SIZE); - memset(cmd, '\0', 128); - - - char *empty = "\n"; - strncpy(cmd, empty, strlen(empty)); - mu_assert(strlen(cmd) == strlen(empty), "strncpy failed"); - - rc = check_cmd(cmd, err); - mu_assert(rc < 0, "check_cmd failed"); - mu_assert(strcmp(err, "closing connection\n") == 0, - "wrong err msg"); - - - rc = check_cmd(NULL, err); - mu_assert(rc < 0, "check_cmd failed"); - mu_assert(strcmp(err, "internal error\n") == 0, - "wrong err msg"); - - - // Cleanup. - free(err); - free(cmd); - - return NULL; -} - -char *test_cmd_parts() -{ - struct bstrList *parts = NULL; - - bstring create = bfromcstr("/create"); - - char *bacon = "/create bacon"; - parts = cmd_parts(bacon); - mu_assert(parts != NULL, "cmd parts failed"); - mu_assert(parts->qty == 2, "qty check failed"); - mu_assert(bstricmp(parts->entry[0], create) == 0, - "equality check failed"); - - // Cleanup - bstrListDestroy(parts); - - char *ham = "/create ham"; - parts = cmd_parts(ham); - mu_assert(parts != NULL, "cmd parts failed"); - mu_assert(parts->qty == 2, "qty check failed"); - mu_assert(bstricmp(parts->entry[0], create) == 0, - "equality check failed"); - - - // Cleanup - bdestroy(create); - bstrListDestroy(parts); - - return NULL; -} - -char *test_find_function() -{ - struct bstrList *parts = NULL; - int funk = 0; - - char *bacon = "/create bacon"; - parts = cmd_parts(bacon); - mu_assert(parts != NULL, "cmd_parts failed"); - funk = find_function(parts); - mu_assert(funk == NS_CREATE, "find function create failed"); - - char *ham = "/create ham"; - parts = cmd_parts(ham); - mu_assert(parts != NULL, "cmd_parts failed"); - funk = find_function(parts); - mu_assert(funk == NS_CREATE, "find function create failed"); - - ham = "/CREate ham"; - parts = cmd_parts(ham); - mu_assert(parts != NULL, "cmd_parts failed"); - funk = find_function(parts); - mu_assert(funk == NS_CREATE, "find function create failed"); - - char *sample = "/sample bacon 42"; - parts = cmd_parts(sample); - mu_assert(parts != NULL, "cmd_parts failed"); - funk = find_function(parts); - mu_assert(funk == NS_SAMPLE, "find function sample failed"); - - sample = "/SAMPLE bacon 42"; - parts = cmd_parts(sample); - mu_assert(parts != NULL, "cmd_parts failed"); - funk = find_function(parts); - mu_assert(funk == NS_SAMPLE, "find function sample failed"); - - char *mean = "/mean bacon"; - parts = cmd_parts(mean); - mu_assert(parts != NULL, "cmd_parts failed"); - funk = find_function(parts); - mu_assert(funk == NS_MEAN, "find function mean failed"); - - char *dump = "/dump bacon"; - parts = cmd_parts(dump); - mu_assert(parts != NULL, "cmd_parts failed"); - funk = find_function(parts); - mu_assert(funk == NS_DUMP, "find function dump failed"); - - char *delete = "/delete bacon"; - parts = cmd_parts(delete); - mu_assert(parts != NULL, "cmd_parts failed"); - funk = find_function(parts); - mu_assert(funk == NS_DELETE, "find function delete failed"); - - char *list = "/list"; - parts = cmd_parts(list); - mu_assert(parts != NULL, "cmp_parts failed"); - funk = find_function(parts); - mu_assert(funk == NS_LIST, "find function list failed"); - - list = "/LIST"; - parts = cmd_parts(list); - mu_assert(parts != NULL, "cmp_parts failed"); - funk = find_function(parts); - mu_assert(funk == NS_LIST, "find function list failed"); - - char *store = "/store jowl"; - parts = cmd_parts(store); - mu_assert(parts != NULL, "cmp_parts failed"); - funk = find_function(parts); - mu_assert(funk == NS_STORE, "find function list failed"); - - store = "/STore jowl"; - parts = cmd_parts(store); - mu_assert(parts != NULL, "cmp_parts failed"); - funk = find_function(parts); - mu_assert(funk == NS_STORE, "find function list failed"); - - char *load = "/load jowl ears"; - parts = cmd_parts(load); - mu_assert(parts != NULL, "cmp_parts failed"); - funk = find_function(parts); - mu_assert(funk == NS_LOAD, "find function list failed"); - - load = "/LoAD jowl ears"; - parts = cmd_parts(load); - mu_assert(parts != NULL, "cmp_parts failed"); - funk = find_function(parts); - mu_assert(funk == NS_LOAD, "find function list failed"); - - char *nop = "/meant bacon"; - parts = cmd_parts(nop); - mu_assert(parts != NULL, "cmd_parts failed"); - funk = find_function(parts); - mu_assert(funk == NS_NOP, "find function mean failed"); - - return NULL; -} - -char *test_call_function() -{ - struct bstrList *parts = NULL; - - char *msg = (char *) calloc(RSP_SIZE + 1, sizeof(char)); - mu_assert(msg != NULL, "msg invalid"); - - char *bacon = "/create bacon"; - parts = cmd_parts(bacon); - mu_assert(parts != NULL, "cmd_parts failed"); - int rc = call_function(NS_CREATE, parts, msg); - mu_assert(rc == 0, "call function failed"); - mu_assert(strcmp(msg, "OK\n") == 0, "call function failed"); - - char *ham = "/create ham"; - parts = cmd_parts(ham); - mu_assert(parts != NULL, "cmd_parts failed"); - rc = call_function(NS_CREATE, parts, msg); - mu_assert(rc == 0, "call function failed"); - mu_assert(strcmp(msg, "OK\n") == 0, "call function failed"); - - char *beef = "/create beef"; - parts = cmd_parts(beef); - mu_assert(parts != NULL, "cmd_parts failed"); - rc = call_function(NS_CREATE, parts, msg); - mu_assert(rc == 0, "call function failed"); - mu_assert(strcmp(msg, "OK\n") == 0, "call function failed"); - - char *bacon_sample = "/sample bacon 4.2"; - parts = cmd_parts(bacon_sample); - mu_assert(parts != NULL, "cmd_parts failed"); - rc = call_function(NS_SAMPLE, parts, msg); - mu_assert(rc == 0, "call function failed"); - mu_assert(strcmp(msg, "Mean: 4.20\n") == 0, "call function failed"); - - bacon_sample = "/Sample bacon 6.9"; - parts = cmd_parts(bacon_sample); - mu_assert(parts != NULL, "cmd_parts failed"); - rc = call_function(NS_SAMPLE, parts, msg); - mu_assert(rc == 0, "call function failed"); - mu_assert(strcmp(msg, "Mean: 5.55\n") == 0, "call function failed"); - - char *bacon_mean = "/mean bacon"; - parts = cmd_parts(bacon_mean); - mu_assert(parts != NULL, "cmd_parts failed"); - rc = call_function(NS_MEAN, parts, msg); - mu_assert(rc == 0, "call function failed"); - mu_assert(strcmp(msg, "Mean: 5.55\n") == 0, "call function failed"); - - char *bacon_dump = "/dump bacon"; - parts = cmd_parts(bacon_dump); - mu_assert(parts != NULL, "cmd_parts failed"); - rc = call_function(NS_DUMP, parts, msg); - mu_assert(rc == 0, "call function failed"); - mu_assert(strcmp(msg, "sum: 11.100000, sumsq: 65.250000, n: 2, min: 4.200000, max: 6.900000, mean: 5.550000, stddev: 1.909188\n") == 0, "call function failed"); - - char *bacon_delete = "/delete bacon"; - parts = cmd_parts(bacon_delete); - mu_assert(parts != NULL, "cmd_parts failed"); - rc = call_function(NS_DELETE, parts, msg); - mu_assert(rc == 0, "call function failed"); - mu_assert(strcmp(msg, "OK\n") == 0, "call function failed"); - - char *list = "/list"; - parts = cmd_parts(list); - mu_assert(parts != NULL, "cmd_parts failed"); - rc = call_function(NS_LIST, parts, msg); - mu_assert(rc == 0, "call function failed"); - mu_assert(strcmp(msg, "ham\nbeef\n") == 0 - || strcmp(msg, "beef\nham\n") == 0, - "call function failed"); - - - char *ham_store = "/store ham"; - parts = cmd_parts(ham_store); - mu_assert(parts != NULL, "cmd_parts failed"); - rc = call_function(NS_STORE, parts, msg); - mu_assert(rc == 0, "call function failed"); - mu_assert(strcmp(msg, "OK\n") == 0, "call function failed"); - - - char *beef_store = "/store beef"; - parts = cmd_parts(beef_store); - mu_assert(parts != NULL, "cmd_parts failed"); - rc = call_function(NS_STORE, parts, msg); - mu_assert(rc == 0, "call function failed"); - mu_assert(strcmp(msg, "OK\n") == 0, "call function failed"); - - char *roastedham_load = "/load ham roastedham"; - parts = cmd_parts(roastedham_load); - mu_assert(parts != NULL, "cmd_parts failed"); - rc = call_function(NS_LOAD, parts, msg); - mu_assert(rc == 0, "call function failed"); - mu_assert(strcmp(msg, "OK\n") == 0, "call function failed"); - - char *grilledbeef_load = "/load beef grilledbeef"; - parts = cmd_parts(grilledbeef_load); - mu_assert(parts != NULL, "cmd_parts failed"); - rc = call_function(NS_LOAD, parts, msg); - printf("LOAD FIAAAL %d %s\n", rc, msg); - mu_assert(rc == 0, "call function failed"); - mu_assert(strcmp(msg, "OK\n") == 0, "call function failed"); - - // delete ham, roastedham, beef, and roastedbeef. - char *ham_delete = "/delete ham"; - parts = cmd_parts(ham_delete); - mu_assert(parts != NULL, "cmd_parts failed"); - rc = call_function(NS_DELETE, parts, msg); - mu_assert(rc == 0, "call function failed"); - mu_assert(strcmp(msg, "OK\n") == 0, "call function failed"); - - char *roastedham_delete = "/delete roastedham"; - parts = cmd_parts(roastedham_delete); - mu_assert(parts != NULL, "cmd_parts failed"); - rc = call_function(NS_DELETE, parts, msg); - mu_assert(rc == 0, "call function failed"); - mu_assert(strcmp(msg, "OK\n") == 0, "call function failed"); - - char *beef_delete = "/delete beef"; - parts = cmd_parts(beef_delete); - mu_assert(parts != NULL, "cmd_parts failed"); - rc = call_function(NS_DELETE, parts, msg); - mu_assert(rc == 0, "call function failed"); - mu_assert(strcmp(msg, "OK\n") == 0, "call function failed"); - - char *grilledbeef_delete = "/delete grilledbeef"; - parts = cmd_parts(grilledbeef_delete); - mu_assert(parts != NULL, "cmd_parts failed"); - rc = call_function(NS_DELETE, parts, msg); - mu_assert(rc == 0, "call function failed"); - mu_assert(strcmp(msg, "OK\n") == 0, "call function failed"); - - return NULL; -} - -char *test_process() -{ - char *out = (char *) calloc(RSP_SIZE + 1, sizeof(char)); - mu_assert(out != NULL, "out invalid"); - - char *bacon = "/create bacon"; - int rc = process(bacon, out); - mu_assert(rc == 0, "process failed"); - mu_assert(strcmp(out, "OK\n") == 0, "process failed"); - - char *ham = "/create ham"; - rc = process(ham, out); - mu_assert(rc == 0, "process failed"); - mu_assert(strcmp(out, "OK\n") == 0, "process failed"); - - char *beef = "/create beef"; - rc = process(beef, out); - mu_assert(rc == 0, "process failed"); - mu_assert(strcmp(out, "OK\n") == 0, "process failed"); - - char *ham_sample = "/sample ham 4.3"; - rc = process(ham_sample, out); - mu_assert(rc == 0, "process failed"); - mu_assert(strcmp(out, "Mean: 4.30\n") == 0, "process failed"); - - ham_sample = "/sample ham 6.0"; - rc = process(ham_sample, out); - mu_assert(rc == 0, "process failed"); - mu_assert(strcmp(out, "Mean: 5.15\n") == 0, "process failed"); - - char *bacon_sample = "/sample bacon 4.2"; - rc = process(bacon_sample, out); - mu_assert(rc == 0, "process failed"); - mu_assert(strcmp(out, "Mean: 4.20\n") == 0, "process failed"); - - bacon_sample = "/Sample bacon 6.9"; - rc = process(bacon_sample, out); - mu_assert(rc == 0, "process failed"); - mu_assert(strcmp(out, "Mean: 5.55\n") == 0, "process failed"); - - char *bacon_mean = "/mean bacon"; - rc = process(bacon_mean, out); - mu_assert(rc == 0, "process failed"); - mu_assert(strcmp(out, "Mean: 5.55\n") == 0, "process failed"); - - char *bacon_dump = "/dump bacon"; - rc = process(bacon_dump, out); - mu_assert(rc == 0, "process failed"); - mu_assert(strcmp(out, "sum: 11.100000, sumsq: 65.250000, n: 2, min: 4.200000, max: 6.900000, mean: 5.550000, stddev: 1.909188\n") == 0, "process failed"); - - char *bacon_delete = "/delete bacon"; - rc = process(bacon_delete, out); - mu_assert(rc == 0, "process failed"); - mu_assert(strcmp(out, "OK\n") == 0, "process failed"); - - char *list = "/list"; - rc = process(list, out); - mu_assert(rc == 0, "process failed"); - mu_assert(strcmp(out, "ham\nbeef\n") == 0 - || strcmp(out, "beef\nham\n") == 0, - "process failed"); - - char *ham_store = "/store ham"; - rc = process(ham_store, out); - mu_assert(rc == 0, "process failed"); - mu_assert(strcmp(out, "OK\n") == 0, "process failed"); - - char *beef_store = "/store beef"; - rc = process(beef_store, out); - mu_assert(rc == 0, "process failed"); - mu_assert(strcmp(out, "OK\n") == 0, "process failed"); - - char *bacon_store = "/store bacon"; - rc = process(bacon_store, out); - mu_assert(rc == -1, "process failed"); - mu_assert(strcmp(out, "error: store failed\n") == 0, "process failed"); - - char *roastedham_load = "/load ham roastedham"; - rc = process(roastedham_load, out); - mu_assert(rc == 0, "process failed"); - mu_assert(strcmp(out, "OK\n") == 0, "process failed"); - - char *roastedham_delete = "/delete roastedham"; - rc = process(roastedham_delete, out); - mu_assert(rc == 0, "process failed"); - mu_assert(strcmp(out, "OK\n") == 0, "process failed"); - - roastedham_load = "/load ham roastedham"; - rc = process(roastedham_load, out); - mu_assert(rc == 0, "process failed"); - mu_assert(strcmp(out, "OK\n") == 0, "process failed"); - - char *roastedham_dump = "/dump roastedham"; - rc = process(roastedham_dump, out); - mu_assert(rc == 0, "process failed"); - mu_assert(strcmp(out, "sum: 10.300000, sumsq: 54.490000, n: 2, min: 4.300000, max: 6.000000, mean: 5.150000, stddev: 1.202082\n") == 0, "process failed"); - - return NULL; -} - -char *all_tests() -{ - mu_suite_start(); - - mu_run_test(test_sanitize); - mu_run_test(test_check_cmd); - mu_run_test(test_cmd_parts); - mu_run_test(test_find_function); - mu_run_test(test_call_function); - mu_run_test(test_process); - - return NULL; -} - -RUN_TESTS(all_tests); diff --git a/nserver/tests/protocol_tests.c b/nserver/tests/protocol_tests.c @@ -1,202 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#include "minunit.h" -#include <protocol.h> - -char *test_sscreate() -{ - int rc = 0; - - rc = sscreate("/crimson"); - mu_assert(rc == 0, "sscreate failed 0"); - - rc = sscreate("/vermilion"); - mu_assert(rc == 0, "sscreate failed 1"); - - rc = sscreate("/crimson"); - mu_assert(rc == 1, "sscreate failed 2"); - - rc = sscreate("/crimson/sky"); - mu_assert(rc == 0, "sscreate failed 3"); - - // delete. check. - rc = ssdelete("/crimson/sky"); - mu_assert(rc == 0, "ssdelete failed 0"); - - rc = sscreate("/crimson/sky"); - mu_assert(rc == 2, "sscreate failed 4"); - - return NULL; -} - -char *test_sssample() -{ - double mean = 0; - - mean = sssample("/crimson", 3); - mu_assert(mean == 3.0, "sssample failed 0"); - - mean = sssample("/crimson", 9); - mu_assert(mean == 6.0, "sssample failed 1"); - - mean = sssample("/crimson", 12); - mu_assert(mean == 8.0, "sssample failed 2"); - - mean = sssample("/vermilion", 20); - mu_assert(mean == 20.0, "sssample failed 3"); - - mean = sssample("/vermilion", 27); - mu_assert(mean == 23.5, "sssample failed 4"); - - mean = sssample("/vermilion", 4); - mu_assert(mean == 17.0, "sssample failed 5"); - - mean = sssample("/ruby", 48); - mu_assert(mean == -1, "sssample failed 6"); - - mean = sssample("/crimson/sky", 42); - mu_assert(mean == 42.0, "sssample failed 7"); - - mean = sssample("/crimson", 10); - mu_assert(mean == 15.20, "sssample failed 8"); - - // delete check. - int rc = ssdelete("/crimson/sky"); - mu_assert(rc == 0, "ssdeleted failed 0"); - - mean = sssample("/crimson/sky", 71); - mu_assert(mean == -1, "sssample failed 9"); - - rc = sscreate("/crimson/sky"); - mu_assert(rc == 2, "sscreate failed 1"); - - mean = sssample("/crimson/sky", 71); - mu_assert(mean == 71.0, "sssample failed 9"); - - - - return NULL; -} - -char *test_ssmean() -{ - double m = 0; - - m = ssmean("/crimson"); - mu_assert(m == 24.50, "ssmean failed 0"); - - m = ssmean("/vermilion"); - mu_assert(m == 17, "ssmean failed 1"); - - m = ssmean("/ruby"); - mu_assert(m == -1, "ssmean failed 2"); - - m = ssmean("/crimson/sky"); - mu_assert(m == 71.0, "ssmean failed 3"); - - // delete check. - int rc = ssdelete("/crimson/sky"); - mu_assert(rc == 0, "ssdeleted failed 0"); - - m = ssmean("/crimson/sky"); - mu_assert(m == -1, "ssmean failed 4"); - - return NULL; -} - -char *test_ssdump() -{ - char *dstr = NULL; - - dstr = ssdump("/crimson"); - mu_assert(dstr != NULL, "ssdump failed 0"); - debug("DUMP: %s", dstr); - - // clean up. - free(dstr); - - dstr = ssdump("/vermilion"); - mu_assert(dstr != NULL, "ssdump failed 1"); - debug("DUMP: %s", dstr); - - // clean up. - free(dstr); - - dstr = ssdump("/ruby"); - mu_assert(dstr == NULL, "ssdump failed 2"); - debug("DUMP: %s", dstr); - - dstr = ssdump("/crimson/sky"); - mu_assert(dstr == NULL, "ssdump failed 2"); - - return NULL; -} - -char *test_sslist() -{ - char *ks = sslist(); - mu_assert(ks != NULL, "sslist failed"); - mu_assert(strlen(ks) == 20, "length check failed"); - - return NULL; -} - -char *test_ssstore() -{ - - int rc = ssstore("/crimson"); - mu_assert(rc == 0, "store /crimson failed"); - - rc = ssstore("/nonexistent"); - mu_assert(rc == -1, "store /nonexistent failed"); - - return NULL; -} - -char *test_ssload() -{ - int rc = ssload("/crimson", "/crimson"); - mu_assert(rc == -2, "ssload failed 0"); - - rc = ssload("/crimson", "/amaranth"); - mu_assert(rc == 0, "ssload failed 1"); - - return NULL; -} - -char *test_ssdelete() -{ - int rc = 0; - - rc = ssdelete("/crimson"); - mu_assert(rc == 0, "delete failed 0"); - - rc = ssdelete("/vermilion"); - mu_assert(rc == 0, "delete failed 1"); - - rc = ssdelete("/ruby"); - mu_assert(rc == 0, "delete failed 2"); - - return NULL; -} - -char *all_tests() -{ - mu_suite_start(); - - mu_run_test(test_sscreate); - mu_run_test(test_sssample); - mu_run_test(test_ssmean); - mu_run_test(test_ssdump); - mu_run_test(test_sslist); - mu_run_test(test_ssstore); - mu_run_test(test_ssload); - mu_run_test(test_ssdelete); - - return NULL; -} - -RUN_TESTS(all_tests); diff --git a/nserver/tests/runtests.sh b/nserver/tests/runtests.sh @@ -1,19 +0,0 @@ -echo "Running unit tests:" - -for i in tests/*_tests -do - if test -f $i - then - if $VALGRIND ./$i 2>> tests/tests.log - then - echo $i PASS - else - echo "ERROR in test $i: here's tests/tests.log" - echo "------" - tail tests/tests.log - exit 1 - fi - fi -done - -echo "" diff --git a/nserver/tests/stats_tests.c b/nserver/tests/stats_tests.c @@ -1,132 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2010, Zed A. Shaw. - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#include "minunit.h" -#include <stats.h> -#include <string.h> -#include <math.h> - -static char *st_str = NULL; - -const int NUM_SAMPLES = 10; -double samples[] = { - 6.1061334, 9.6783204, 1.2747090, 8.2395131, 0.3333483, - 6.9755066, 1.0626275, 7.6587523, 4.9382973, 9.5788115 -}; - -Stats expect = { - .sumsq = 425.1641, - .sum = 55.84602, - .min = 0.333, - .max = 9.678, - .n = 10 -}; - -double expect_mean = 5.584602; -double expect_stddev = 3.547868; - -#define EQ(X,Y,N) (round((X) * pow(10, N)) == round((Y) * pow(10, N))) - -char *test_operations() -{ - int i = 0; - Stats *st = Stats_create(); - mu_assert(st != NULL, "Fail to create stats."); - - for (i = 0; i < NUM_SAMPLES; i++) { - Stats_sample(st, samples[i]); - } - - Stats_dump(st); - - mu_assert(EQ(st->sumsq, expect.sumsq, 3), "sumsq not valid"); - mu_assert(EQ(st->sum, expect.sum, 3), "sum not valid"); - mu_assert(EQ(st->min, expect.min, 3), "min not valid"); - mu_assert(EQ(st->max, expect.max, 3), "max not valid"); - mu_assert(EQ(st->n, expect.n, 3), "n not valid"); - mu_assert(EQ(expect_mean, Stats_mean(st), 3), "mean not valid"); - mu_assert(EQ(expect_stddev, Stats_stddev(st), 3), - "stddev not valid"); - - return NULL; -} - -char *test_recreate() -{ - Stats *st = Stats_recreate( - expect.sum, expect.sumsq, expect.n, expect.min, expect.max); - - mu_assert(st->sum == expect.sum, "sum not equal"); - mu_assert(st->sumsq == expect.sumsq, "sumsq not equal"); - mu_assert(st->n == expect.n, "n not equal"); - mu_assert(st->min == expect.min, "min not equal"); - mu_assert(st->max == expect.max, "max not equal"); - mu_assert(EQ(expect_mean, Stats_mean(st), 3), "mean not valid"); - mu_assert(EQ(expect_stddev, Stats_stddev(st), 3), - "stddev not valid"); - - return NULL; -} - -char *test_stats_stringify() -{ - Stats *st = Stats_create(); - mu_assert(st != NULL, "stats create failed"); - - // fill with dummy data. - st->sum = 8238.33892; - st->sumsq = 4260238.8292; - st->n = 28; - st->min = 28.3921; - st->max = 238.27; - - st_str = Stats_stringify(st); - mu_assert(st_str != NULL, "stats stringify failed"); - - char *expected_st_str = "8238.34:4260238.83:28:28.39:238.27"; - mu_assert(strncmp(st_str, expected_st_str, strlen(expected_st_str)) == 0, - "stringified str invalid"); - - // cleanup - free(st); - - return NULL; -} - -char *test_stats_unstringify() -{ - mu_assert(st_str != NULL, "st_str not initialized"); - - Stats *st = Stats_unstringify(st_str); - mu_assert(st != NULL, "stats unstringify failed"); - - mu_assert(st->sum == 8238.34, "stats sum incorrect"); - mu_assert(st->sumsq == 4260238.83, "stats sumsq incorrect"); - mu_assert(st->n == 28, "stats n incorrect"); - mu_assert(st->min == 28.39, "stats min incorrect"); - mu_assert(st->max == 238.27, "stats max incorrect"); - - // clean up - free(st); - free(st_str); - - return NULL; -} - -char *all_tests() -{ - mu_suite_start(); - - mu_run_test(test_operations); - mu_run_test(test_recreate); - - mu_run_test(test_stats_stringify); - mu_run_test(test_stats_unstringify); - - return NULL; -} - -RUN_TESTS(all_tests); diff --git a/nserver/tests/tstree_tests.c b/nserver/tests/tstree_tests.c @@ -1,132 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause */ -/* - * Copyright © 2010, Zed A. Shaw. - * Copyright © 2020 rsiddharth <s@ricketyspace.net> - */ - -#include "minunit.h" -#include <tstree.h> -#include <string.h> -#include <assert.h> -#include <bstrlib.h> - -TSTree *node = NULL; -char *valueA = "VALUEA"; -char *valueB = "VALUEB"; -char *value2 = "VALUE2"; -char *value4 = "VALUE4"; -char *reverse = "VALUER"; -int traverse_count = 0; - -struct tagbstring test1 = bsStatic("TEST"); -struct tagbstring test2 = bsStatic("TEST2"); -struct tagbstring test3 = bsStatic("TSET"); -struct tagbstring test4 = bsStatic("T"); - -char *test_insert() -{ - node = TSTree_insert(node, bdata(&test1), blength(&test1), valueA); - mu_assert(node != NULL, "Failed to insert into tst."); - - node = TSTree_insert(node, bdata(&test2), blength(&test2), value2); - mu_assert(node != NULL, - "Failed to insert into tst with second name."); - - node = TSTree_insert(node, bdata(&test3), blength(&test3), reverse); - mu_assert(node != NULL, - "Failed to insert into tst with reverse name"); - - node = TSTree_insert(node, bdata(&test4), blength(&test4), value4); - mu_assert(node != NULL, - "Failed to insert into tst with second name."); - - return NULL; -} - -char *test_search_exact() -{ - // tst returns the last one inserted - void *res = TSTree_search(node, bdata(&test1), blength(&test1)); - mu_assert(res == valueA, - "Got the wrong value back, should get A not B."); - - // tst does not find if not exact - res = TSTree_search(node, "TESTNO", strlen("TESTNO")); - mu_assert(res == NULL, "Should not find anything."); - - return NULL; -} - -char *test_search_prefix() -{ - void *res = TSTree_search_prefix( - node, bdata(&test2), blength(&test2)); - debug("result: %p, expected: %p", res, valueA); - mu_assert(res == valueA, "Got wrong valueA by prefix."); - - - res = TSTree_search_prefix(node, bdata(&test3), blength(&test3)); - debug("result: %p, expected: %p", res, valueA); - mu_assert(res == value4, "Got wrong value4 for prefix of 1."); - - res = TSTree_search_prefix(node, "TE", strlen("TE")); - mu_assert(res == value4, "Should find for short prefix"); - - res = TSTree_search_prefix(node, "TE--", strlen("TE--")); - mu_assert(res == value4, "Should find for partial prefix."); - - return NULL; -} - -char *test_collect() -{ - DArray *arr = TSTree_collect(node, "TE", strlen("TE")); - mu_assert(DArray_count(arr) == 2, "Must collect TEST & TEST2"); - DArray_destroy(arr); - - arr = TSTree_collect(node, "T", strlen("T")); - mu_assert(DArray_count(arr) == 4, "Must collect all keys"); - DArray_destroy(arr); - - return NULL; -} - -void TSTree_traverse_test_cb(void *value, void *data) -{ - assert(value != NULL && "Should not get NULL value."); - assert(data == valueA && "Expecting valueA as the data."); - traverse_count++; -} - -char *test_traverse() -{ - traverse_count = 0; - TSTree_traverse(node, TSTree_traverse_test_cb, valueA); - debug("traverse count is: %d", traverse_count); - mu_assert(traverse_count == 4, "Didn't find 4 keys."); - - return NULL; -} - -char *test_destroy() -{ - TSTree_destroy(node); - - return NULL; -} - -char *all_tests() -{ - mu_suite_start(); - - mu_run_test(test_insert); - mu_run_test(test_search_exact); - mu_run_test(test_search_prefix); - mu_run_test(test_collect); - mu_run_test(test_traverse); - mu_run_test(test_destroy); - - return NULL; -} - -RUN_TESTS(all_tests); diff --git a/src/bstrlib.c b/src/bstrlib.c @@ -0,0 +1,3149 @@ +/* SPDX-License-Identifier: BSD-3-Clause */ +/* + * Copyright © 2014 Paul Hsieh + * Copyright © 2020 rsiddharth + */ + +/* + * This is a slightly modified version of bstrlib.c from the bstrlib + * library (https://github.com/websnarf/bstrlib/releases/tag/v1.0.0). + */ + +/* + * This source file is part of the bstring string library. This code was + * written by Paul Hsieh in 2002-2015, and is covered by the BSD open source + * license and the GPL. Refer to the accompanying documentation for details + * on usage and license. + */ + +/* + * bstrlib.c + * + * This file is the core module for implementing the bstring functions. + */ + +#if defined (_MSC_VER) +# define _CRT_SECURE_NO_WARNINGS +#endif + +#include <stdio.h> +#include <stddef.h> +#include <stdarg.h> +#include <stdlib.h> +#include <string.h> +#include <ctype.h> +#include <limits.h> +#include <bstrlib.h> + +/* Optionally include a mechanism for debugging memory */ + +#if defined(MEMORY_DEBUG) || defined(BSTRLIB_MEMORY_DEBUG) +#include "memdbg.h" +#endif + +#ifndef bstr__alloc +#if defined (BSTRLIB_TEST_CANARY) +void* bstr__alloc (size_t sz) { + char* p = (char *) malloc (sz); + memset (p, 'X', sz); + return p; +} +#else +#define bstr__alloc(x) malloc (x) +#endif +#endif + +#ifndef bstr__free +#define bstr__free(p) free (p) +#endif + +#ifndef bstr__realloc +#define bstr__realloc(p,x) realloc ((p), (x)) +#endif + +#ifndef bstr__memcpy +#define bstr__memcpy(d,s,l) memcpy ((d), (s), (l)) +#endif + +#ifndef bstr__memmove +#define bstr__memmove(d,s,l) memmove ((d), (s), (l)) +#endif + +#ifndef bstr__memset +#define bstr__memset(d,c,l) memset ((d), (c), (l)) +#endif + +#ifndef bstr__memcmp +#define bstr__memcmp(d,c,l) memcmp ((d), (c), (l)) +#endif + +#ifndef bstr__memchr +#define bstr__memchr(s,c,l) memchr ((s), (c), (l)) +#endif + +/* Just a length safe wrapper for memmove. */ + +#define bBlockCopy(D,S,L) { if ((L) > 0) bstr__memmove ((D),(S),(L)); } + +/* Compute the snapped size for a given requested size. By snapping to powers + of 2 like this, repeated reallocations are avoided. */ +static int snapUpSize (int i) { + if (i < 8) { + i = 8; + } else { + unsigned int j; + j = (unsigned int) i; + + j |= (j >> 1); + j |= (j >> 2); + j |= (j >> 4); + j |= (j >> 8); /* Ok, since int >= 16 bits */ +#if (UINT_MAX != 0xffff) + j |= (j >> 16); /* For 32 bit int systems */ +#if (UINT_MAX > 0xffffffffUL) + j |= (j >> 32); /* For 64 bit int systems */ +#endif +#endif + /* Least power of two greater than i */ + j++; + if ((int) j >= i) i = (int) j; + } + return i; +} + +/* int balloc (bstring b, int len) + * + * Increase the size of the memory backing the bstring b to at least len. + */ +int balloc (bstring b, int olen) { + int len; + if (b == NULL || b->data == NULL || b->slen < 0 || b->mlen <= 0 || + b->mlen < b->slen || olen <= 0) { + return BSTR_ERR; + } + + if (olen >= b->mlen) { + unsigned char * x; + + if ((len = snapUpSize (olen)) <= b->mlen) return BSTR_OK; + + /* Assume probability of a non-moving realloc is 0.125 */ + if (7 * b->mlen < 8 * b->slen) { + + /* If slen is close to mlen in size then use realloc to reduce + the memory defragmentation */ + + reallocStrategy:; + + x = (unsigned char *) bstr__realloc (b->data, (size_t) len); + if (x == NULL) { + + /* Since we failed, try allocating the tighest possible + allocation */ + + len = olen; + x = (unsigned char *) bstr__realloc (b->data, (size_t) olen); + if (NULL == x) { + return BSTR_ERR; + } + } + } else { + + /* If slen is not close to mlen then avoid the penalty of copying + the extra bytes that are allocated, but not considered part of + the string */ + + if (NULL == (x = (unsigned char *) bstr__alloc ((size_t) len))) { + + /* Perhaps there is no available memory for the two + allocations to be in memory at once */ + + goto reallocStrategy; + + } else { + if (b->slen) bstr__memcpy ((char *) x, (char *) b->data, + (size_t) b->slen); + bstr__free (b->data); + } + } + b->data = x; + b->mlen = len; + b->data[b->slen] = (unsigned char) '\0'; + +#if defined (BSTRLIB_TEST_CANARY) + if (len > b->slen + 1) { + memchr (b->data + b->slen + 1, 'X', len - (b->slen + 1)); + } +#endif + } + + return BSTR_OK; +} + +/* int ballocmin (bstring b, int len) + * + * Set the size of the memory backing the bstring b to len or b->slen+1, + * whichever is larger. Note that repeated use of this function can degrade + * performance. + */ +int ballocmin (bstring b, int len) { + unsigned char * s; + + if (b == NULL || b->data == NULL) return BSTR_ERR; + if (b->slen >= INT_MAX || b->slen < 0) return BSTR_ERR; + if (b->mlen <= 0 || b->mlen < b->slen || len <= 0) { + return BSTR_ERR; + } + + if (len < b->slen + 1) len = b->slen + 1; + + if (len != b->mlen) { + s = (unsigned char *) bstr__realloc (b->data, (size_t) len); + if (NULL == s) return BSTR_ERR; + s[b->slen] = (unsigned char) '\0'; + b->data = s; + b->mlen = len; + } + + return BSTR_OK; +} + +/* bstring bfromcstr (const char * str) + * + * Create a bstring which contains the contents of the '\0' terminated char * + * buffer str. + */ +bstring bfromcstr (const char * str) { +bstring b; +int i; +size_t j; + + if (str == NULL) return NULL; + j = (strlen) (str); + i = snapUpSize ((int) (j + (2 - (j != 0)))); + if (i <= (int) j) return NULL; + + b = (bstring) bstr__alloc (sizeof (struct tagbstring)); + if (NULL == b) return NULL; + b->slen = (int) j; + if (NULL == (b->data = (unsigned char *) bstr__alloc (b->mlen = i))) { + bstr__free (b); + return NULL; + } + + bstr__memcpy (b->data, str, j+1); + return b; +} + +/* bstring bfromcstrrangealloc (int minl, int maxl, const char* str) + * + * Create a bstring which contains the contents of the '\0' terminated + * char* buffer str. The memory buffer backing the string is at least + * minl characters in length, but an attempt is made to allocate up to + * maxl characters. + */ +bstring bfromcstrrangealloc (int minl, int maxl, const char* str) { +bstring b; +int i; +size_t j; + + /* Bad parameters? */ + if (str == NULL) return NULL; + if (maxl < minl || minl < 0) return NULL; + + /* Adjust lengths */ + j = (strlen) (str); + if ((size_t) minl < (j+1)) minl = (int) (j+1); + if (maxl < minl) maxl = minl; + i = maxl; + + b = (bstring) bstr__alloc (sizeof (struct tagbstring)); + if (b == NULL) return NULL; + b->slen = (int) j; + + while (NULL == (b->data = (unsigned char *) bstr__alloc (b->mlen = i))) { + int k = (i >> 1) + (minl >> 1); + if (i == k || i < minl) { + bstr__free (b); + return NULL; + } + i = k; + } + + bstr__memcpy (b->data, str, j+1); + return b; +} + +/* bstring bfromcstralloc (int mlen, const char * str) + * + * Create a bstring which contains the contents of the '\0' terminated + * char* buffer str. The memory buffer backing the string is at least + * mlen characters in length. + */ +bstring bfromcstralloc (int mlen, const char * str) { + return bfromcstrrangealloc (mlen, mlen, str); +} + +/* bstring blk2bstr (const void * blk, int len) + * + * Create a bstring which contains the content of the block blk of length + * len. + */ +bstring blk2bstr (const void * blk, int len) { +bstring b; +int i; + + if (blk == NULL || len < 0) return NULL; + b = (bstring) bstr__alloc (sizeof (struct tagbstring)); + if (b == NULL) return NULL; + b->slen = len; + + i = len + (2 - (len != 0)); + i = snapUpSize (i); + + b->mlen = i; + + b->data = (unsigned char *) bstr__alloc ((size_t) b->mlen); + if (b->data == NULL) { + bstr__free (b); + return NULL; + } + + if (len > 0) bstr__memcpy (b->data, blk, (size_t) len); + b->data[len] = (unsigned char) '\0'; + + return b; +} + +/* char * bstr2cstr (const_bstring s, char z) + * + * Create a '\0' terminated char * buffer which is equal to the contents of + * the bstring s, except that any contained '\0' characters are converted + * to the character in z. This returned value should be freed with a + * bcstrfree () call, by the calling application. + */ +char * bstr2cstr (const_bstring b, char z) { +int i, l; +char * r; + + if (b == NULL || b->slen < 0 || b->data == NULL) return NULL; + l = b->slen; + r = (char *) bstr__alloc ((size_t) (l + 1)); + if (r == NULL) return r; + + for (i=0; i < l; i ++) { + r[i] = (char) ((b->data[i] == '\0') ? z : (char) (b->data[i])); + } + + r[l] = (unsigned char) '\0'; + + return r; +} + +/* int bcstrfree (char * s) + * + * Frees a C-string generated by bstr2cstr (). This is normally unnecessary + * since it just wraps a call to bstr__free (), however, if bstr__alloc () + * and bstr__free () have been redefined as a macros within the bstrlib + * module (via defining them in memdbg.h after defining + * BSTRLIB_MEMORY_DEBUG) with some difference in behaviour from the std + * library functions, then this allows a correct way of freeing the memory + * that allows higher level code to be independent from these macro + * redefinitions. + */ +int bcstrfree (char * s) { + if (s) { + bstr__free (s); + return BSTR_OK; + } + return BSTR_ERR; +} + +/* int bconcat (bstring b0, const_bstring b1) + * + * Concatenate the bstring b1 to the bstring b0. + */ +int bconcat (bstring b0, const_bstring b1) { +int len, d; +bstring aux = (bstring) b1; + + if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL) + return BSTR_ERR; + + d = b0->slen; + len = b1->slen; + if ((d | (b0->mlen - d) | len | (d + len)) < 0) return BSTR_ERR; + + if (b0->mlen <= d + len + 1) { + ptrdiff_t pd = b1->data - b0->data; + if (0 <= pd && pd < b0->mlen) { + if (NULL == (aux = bstrcpy (b1))) return BSTR_ERR; + } + if (balloc (b0, d + len + 1) != BSTR_OK) { + if (aux != b1) bdestroy (aux); + return BSTR_ERR; + } + } + + bBlockCopy (&b0->data[d], &aux->data[0], (size_t) len); + b0->data[d + len] = (unsigned char) '\0'; + b0->slen = d + len; + if (aux != b1) bdestroy (aux); + return BSTR_OK; +} + +/* int bconchar (bstring b, char c) + * + * Concatenate the single character c to the bstring b. + */ +int bconchar (bstring b, char c) { +int d; + + if (b == NULL) return BSTR_ERR; + d = b->slen; + if ((d | (b->mlen - d)) < 0 || balloc (b, d + 2) != BSTR_OK) + return BSTR_ERR; + b->data[d] = (unsigned char) c; + b->data[d + 1] = (unsigned char) '\0'; + b->slen++; + return BSTR_OK; +} + +/* int bcatcstr (bstring b, const char * s) + * + * Concatenate a char * string to a bstring. + */ +int bcatcstr (bstring b, const char * s) { +char * d; +int i, l; + + if (b == NULL || b->data == NULL || b->slen < 0 || b->mlen < b->slen + || b->mlen <= 0 || s == NULL) return BSTR_ERR; + + /* Optimistically concatenate directly */ + l = b->mlen - b->slen; + d = (char *) &b->data[b->slen]; + for (i=0; i < l; i++) { + if ((*d++ = *s++) == '\0') { + b->slen += i; + return BSTR_OK; + } + } + b->slen += i; + + /* Need to explicitely resize and concatenate tail */ + return bcatblk (b, (const void *) s, (int) strlen (s)); +} + +/* int bcatblk (bstring b, const void * s, int len) + * + * Concatenate a fixed length buffer to a bstring. + */ +int bcatblk (bstring b, const void * s, int len) { +int nl; + + if (b == NULL || b->data == NULL || b->slen < 0 || b->mlen < b->slen + || b->mlen <= 0 || s == NULL || len < 0) return BSTR_ERR; + + if (0 > (nl = b->slen + len)) return BSTR_ERR; /* Overflow? */ + if (b->mlen <= nl && 0 > balloc (b, nl + 1)) return BSTR_ERR; + + bBlockCopy (&b->data[b->slen], s, (size_t) len); + b->slen = nl; + b->data[nl] = (unsigned char) '\0'; + return BSTR_OK; +} + +/* bstring bstrcpy (const_bstring b) + * + * Create a copy of the bstring b. + */ +bstring bstrcpy (const_bstring b) { +bstring b0; +int i,j; + + /* Attempted to copy an invalid string? */ + if (b == NULL || b->slen < 0 || b->data == NULL) return NULL; + + b0 = (bstring) bstr__alloc (sizeof (struct tagbstring)); + if (b0 == NULL) { + /* Unable to allocate memory for string header */ + return NULL; + } + + i = b->slen; + j = snapUpSize (i + 1); + + b0->data = (unsigned char *) bstr__alloc (j); + if (b0->data == NULL) { + j = i + 1; + b0->data = (unsigned char *) bstr__alloc (j); + if (b0->data == NULL) { + /* Unable to allocate memory for string data */ + bstr__free (b0); + return NULL; + } + } + + b0->mlen = j; + b0->slen = i; + + if (i) bstr__memcpy ((char *) b0->data, (char *) b->data, i); + b0->data[b0->slen] = (unsigned char) '\0'; + + return b0; +} + +/* int bassign (bstring a, const_bstring b) + * + * Overwrite the string a with the contents of string b. + */ +int bassign (bstring a, const_bstring b) { + if (b == NULL || b->data == NULL || b->slen < 0) + return BSTR_ERR; + if (b->slen != 0) { + if (balloc (a, b->slen) != BSTR_OK) return BSTR_ERR; + bstr__memmove (a->data, b->data, b->slen); + } else { + if (a == NULL || a->data == NULL || a->mlen < a->slen || + a->slen < 0 || a->mlen == 0) + return BSTR_ERR; + } + a->data[b->slen] = (unsigned char) '\0'; + a->slen = b->slen; + return BSTR_OK; +} + +/* int bassignmidstr (bstring a, const_bstring b, int left, int len) + * + * Overwrite the string a with the middle of contents of string b + * starting from position left and running for a length len. left and + * len are clamped to the ends of b as with the function bmidstr. + */ +int bassignmidstr (bstring a, const_bstring b, int left, int len) { + if (b == NULL || b->data == NULL || b->slen < 0) + return BSTR_ERR; + + if (left < 0) { + len += left; + left = 0; + } + + if (len > b->slen - left) len = b->slen - left; + + if (a == NULL || a->data == NULL || a->mlen < a->slen || + a->slen < 0 || a->mlen == 0) + return BSTR_ERR; + + if (len > 0) { + if (balloc (a, len) != BSTR_OK) return BSTR_ERR; + bstr__memmove (a->data, b->data + left, len); + a->slen = len; + } else { + a->slen = 0; + } + a->data[a->slen] = (unsigned char) '\0'; + return BSTR_OK; +} + +/* int bassigncstr (bstring a, const char * str) + * + * Overwrite the string a with the contents of char * string str. Note that + * the bstring a must be a well defined and writable bstring. If an error + * occurs BSTR_ERR is returned however a may be partially overwritten. + */ +int bassigncstr (bstring a, const char * str) { +int i; +size_t len; + if (a == NULL || a->data == NULL || a->mlen < a->slen || + a->slen < 0 || a->mlen == 0 || NULL == str) + return BSTR_ERR; + + for (i=0; i < a->mlen; i++) { + if ('\0' == (a->data[i] = str[i])) { + a->slen = i; + return BSTR_OK; + } + } + + a->slen = i; + len = strlen (str + i); + if (len + 1 > (size_t) INT_MAX - i || + 0 > balloc (a, (int) (i + len + 1))) return BSTR_ERR; + bBlockCopy (a->data + i, str + i, (size_t) len + 1); + a->slen += (int) len; + return BSTR_OK; +} + +/* int bassignblk (bstring a, const void * s, int len) + * + * Overwrite the string a with the contents of the block (s, len). Note that + * the bstring a must be a well defined and writable bstring. If an error + * occurs BSTR_ERR is returned and a is not overwritten. + */ +int bassignblk (bstring a, const void * s, int len) { + if (a == NULL || a->data == NULL || a->mlen < a->slen || + a->slen < 0 || a->mlen == 0 || NULL == s || len < 0 || len >= INT_MAX) + return BSTR_ERR; + if (len + 1 > a->mlen && 0 > balloc (a, len + 1)) return BSTR_ERR; + bBlockCopy (a->data, s, (size_t) len); + a->data[len] = (unsigned char) '\0'; + a->slen = len; + return BSTR_OK; +} + +/* int btrunc (bstring b, int n) + * + * Truncate the bstring to at most n characters. + */ +int btrunc (bstring b, int n) { + if (n < 0 || b == NULL || b->data == NULL || b->mlen < b->slen || + b->slen < 0 || b->mlen <= 0) return BSTR_ERR; + if (b->slen > n) { + b->slen = n; + b->data[n] = (unsigned char) '\0'; + } + return BSTR_OK; +} + +#define upcase(c) (toupper ((unsigned char) c)) +#define downcase(c) (tolower ((unsigned char) c)) +#define wspace(c) (isspace ((unsigned char) c)) + +/* int btoupper (bstring b) + * + * Convert contents of bstring to upper case. + */ +int btoupper (bstring b) { +int i, len; + if (b == NULL || b->data == NULL || b->mlen < b->slen || + b->slen < 0 || b->mlen <= 0) return BSTR_ERR; + for (i=0, len = b->slen; i < len; i++) { + b->data[i] = (unsigned char) upcase (b->data[i]); + } + return BSTR_OK; +} + +/* int btolower (bstring b) + * + * Convert contents of bstring to lower case. + */ +int btolower (bstring b) { +int i, len; + if (b == NULL || b->data == NULL || b->mlen < b->slen || + b->slen < 0 || b->mlen <= 0) return BSTR_ERR; + for (i=0, len = b->slen; i < len; i++) { + b->data[i] = (unsigned char) downcase (b->data[i]); + } + return BSTR_OK; +} + +/* int bstricmp (const_bstring b0, const_bstring b1) + * + * Compare two strings without differentiating between case. The return + * value is the difference of the values of the characters where the two + * strings first differ after lower case transformation, otherwise 0 is + * returned indicating that the strings are equal. If the lengths are + * different, then a difference from 0 is given, but if the first extra + * character is '\0', then it is taken to be the value UCHAR_MAX+1. + */ +int bstricmp (const_bstring b0, const_bstring b1) { +int i, v, n; + + if (bdata (b0) == NULL || b0->slen < 0 || + bdata (b1) == NULL || b1->slen < 0) return SHRT_MIN; + if ((n = b0->slen) > b1->slen) n = b1->slen; + else if (b0->slen == b1->slen && b0->data == b1->data) return BSTR_OK; + + for (i = 0; i < n; i ++) { + v = (char) downcase (b0->data[i]) + - (char) downcase (b1->data[i]); + if (0 != v) return v; + } + + if (b0->slen > n) { + v = (char) downcase (b0->data[n]); + if (v) return v; + return UCHAR_MAX + 1; + } + if (b1->slen > n) { + v = - (char) downcase (b1->data[n]); + if (v) return v; + return - (int) (UCHAR_MAX + 1); + } + return BSTR_OK; +} + +/* int bstrnicmp (const_bstring b0, const_bstring b1, int n) + * + * Compare two strings without differentiating between case for at most n + * characters. If the position where the two strings first differ is + * before the nth position, the return value is the difference of the values + * of the characters, otherwise 0 is returned. If the lengths are different + * and less than n characters, then a difference from 0 is given, but if the + * first extra character is '\0', then it is taken to be the value + * UCHAR_MAX+1. + */ +int bstrnicmp (const_bstring b0, const_bstring b1, int n) { +int i, v, m; + + if (bdata (b0) == NULL || b0->slen < 0 || + bdata (b1) == NULL || b1->slen < 0 || n < 0) return SHRT_MIN; + m = n; + if (m > b0->slen) m = b0->slen; + if (m > b1->slen) m = b1->slen; + + if (b0->data != b1->data) { + for (i = 0; i < m; i ++) { + v = (char) downcase (b0->data[i]); + v -= (char) downcase (b1->data[i]); + if (v != 0) return b0->data[i] - b1->data[i]; + } + } + + if (n == m || b0->slen == b1->slen) return BSTR_OK; + + if (b0->slen > m) { + v = (char) downcase (b0->data[m]); + if (v) return v; + return UCHAR_MAX + 1; + } + + v = - (char) downcase (b1->data[m]); + if (v) return v; + return - (int) (UCHAR_MAX + 1); +} + +/* int biseqcaselessblk (const_bstring b, const void * blk, int len) + * + * Compare content of b and the array of bytes in blk for length len for + * equality without differentiating between character case. If the content + * differs other than in case, 0 is returned, if, ignoring case, the content + * is the same, 1 is returned, if there is an error, -1 is returned. If the + * length of the strings are different, this function is O(1). '\0' + * characters are not treated in any special way. + */ +int biseqcaselessblk (const_bstring b, const void * blk, int len) { +int i; + + if (bdata (b) == NULL || b->slen < 0 || + blk == NULL || len < 0) return BSTR_ERR; + if (b->slen != len) return 0; + if (len == 0 || b->data == blk) return 1; + for (i=0; i < len; i++) { + if (b->data[i] != ((unsigned char*)blk)[i]) { + unsigned char c = (unsigned char) downcase (b->data[i]); + if (c != (unsigned char) downcase (((unsigned char*)blk)[i])) + return 0; + } + } + return 1; +} + + +/* int biseqcaseless (const_bstring b0, const_bstring b1) + * + * Compare two strings for equality without differentiating between case. + * If the strings differ other than in case, 0 is returned, if the strings + * are the same, 1 is returned, if there is an error, -1 is returned. If + * the length of the strings are different, this function is O(1). '\0' + * termination characters are not treated in any special way. + */ +int biseqcaseless (const_bstring b0, const_bstring b1) { + if (NULL == b1) return BSTR_ERR; + return biseqcaselessblk (b0, b1->data, b1->slen); +} + +/* int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len) + * + * Compare beginning of string b0 with a block of memory of length len + * without differentiating between case for equality. If the beginning of b0 + * differs from the memory block other than in case (or if b0 is too short), + * 0 is returned, if the strings are the same, 1 is returned, if there is an + * error, -1 is returned. '\0' characters are not treated in any special + * way. + */ +int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len) { +int i; + + if (bdata (b0) == NULL || b0->slen < 0 || NULL == blk || len < 0) + return BSTR_ERR; + if (b0->slen < len) return BSTR_OK; + if (b0->data == (const unsigned char *) blk || len == 0) return 1; + + for (i = 0; i < len; i ++) { + if (b0->data[i] != ((const unsigned char *) blk)[i]) { + if (downcase (b0->data[i]) != + downcase (((const unsigned char *) blk)[i])) return 0; + } + } + return 1; +} + +/* + * int bltrimws (bstring b) + * + * Delete whitespace contiguous from the left end of the string. + */ +int bltrimws (bstring b) { +int i, len; + + if (b == NULL || b->data == NULL || b->mlen < b->slen || + b->slen < 0 || b->mlen <= 0) return BSTR_ERR; + + for (len = b->slen, i = 0; i < len; i++) { + if (!wspace (b->data[i])) { + return bdelete (b, 0, i); + } + } + + b->data[0] = (unsigned char) '\0'; + b->slen = 0; + return BSTR_OK; +} + +/* + * int brtrimws (bstring b) + * + * Delete whitespace contiguous from the right end of the string. + */ +int brtrimws (bstring b) { +int i; + + if (b == NULL || b->data == NULL || b->mlen < b->slen || + b->slen < 0 || b->mlen <= 0) return BSTR_ERR; + + for (i = b->slen - 1; i >= 0; i--) { + if (!wspace (b->data[i])) { + if (b->mlen > i) b->data[i+1] = (unsigned char) '\0'; + b->slen = i + 1; + return BSTR_OK; + } + } + + b->data[0] = (unsigned char) '\0'; + b->slen = 0; + return BSTR_OK; +} + +/* + * int btrimws (bstring b) + * + * Delete whitespace contiguous from both ends of the string. + */ +int btrimws (bstring b) { +int i, j; + + if (b == NULL || b->data == NULL || b->mlen < b->slen || + b->slen < 0 || b->mlen <= 0) return BSTR_ERR; + + for (i = b->slen - 1; i >= 0; i--) { + if (!wspace (b->data[i])) { + if (b->mlen > i) b->data[i+1] = (unsigned char) '\0'; + b->slen = i + 1; + for (j = 0; wspace (b->data[j]); j++) {} + return bdelete (b, 0, j); + } + } + + b->data[0] = (unsigned char) '\0'; + b->slen = 0; + return BSTR_OK; +} + +/* int biseqblk (const_bstring b, const void * blk, int len) + * + * Compare the string b with the character block blk of length len. If the + * content differs, 0 is returned, if the content is the same, 1 is returned, + * if there is an error, -1 is returned. If the length of the strings are + * different, this function is O(1). '\0' characters are not treated in any + * special way. + */ +int biseqblk (const_bstring b, const void * blk, int len) { + if (len < 0 || b == NULL || blk == NULL || b->data == NULL || b->slen < 0) + return BSTR_ERR; + if (b->slen != len) return 0; + if (len == 0 || b->data == blk) return 1; + return !bstr__memcmp (b->data, blk, len); +} + +/* int biseq (const_bstring b0, const_bstring b1) + * + * Compare the string b0 and b1. If the strings differ, 0 is returned, if + * the strings are the same, 1 is returned, if there is an error, -1 is + * returned. If the length of the strings are different, this function is + * O(1). '\0' termination characters are not treated in any special way. + */ +int biseq (const_bstring b0, const_bstring b1) { + if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL || + b0->slen < 0 || b1->slen < 0) return BSTR_ERR; + if (b0->slen != b1->slen) return BSTR_OK; + if (b0->data == b1->data || b0->slen == 0) return 1; + return !bstr__memcmp (b0->data, b1->data, b0->slen); +} + +/* int bisstemeqblk (const_bstring b0, const void * blk, int len) + * + * Compare beginning of string b0 with a block of memory of length len for + * equality. If the beginning of b0 differs from the memory block (or if b0 + * is too short), 0 is returned, if the strings are the same, 1 is returned, + * if there is an error, -1 is returned. '\0' characters are not treated in + * any special way. + */ +int bisstemeqblk (const_bstring b0, const void * blk, int len) { +int i; + + if (bdata (b0) == NULL || b0->slen < 0 || NULL == blk || len < 0) + return BSTR_ERR; + if (b0->slen < len) return BSTR_OK; + if (b0->data == (const unsigned char *) blk || len == 0) return 1; + + for (i = 0; i < len; i ++) { + if (b0->data[i] != ((const unsigned char *) blk)[i]) return BSTR_OK; + } + return 1; +} + +/* int biseqcstr (const_bstring b, const char *s) + * + * Compare the bstring b and char * string s. The C string s must be '\0' + * terminated at exactly the length of the bstring b, and the contents + * between the two must be identical with the bstring b with no '\0' + * characters for the two contents to be considered equal. This is + * equivalent to the condition that their current contents will be always be + * equal when comparing them in the same format after converting one or the + * other. If the strings are equal 1 is returned, if they are unequal 0 is + * returned and if there is a detectable error BSTR_ERR is returned. + */ +int biseqcstr (const_bstring b, const char * s) { +int i; + if (b == NULL || s == NULL || b->data == NULL || b->slen < 0) + return BSTR_ERR; + for (i=0; i < b->slen; i++) { + if (s[i] == '\0' || b->data[i] != (unsigned char) s[i]) + return BSTR_OK; + } + return s[i] == '\0'; +} + +/* int biseqcstrcaseless (const_bstring b, const char *s) + * + * Compare the bstring b and char * string s. The C string s must be '\0' + * terminated at exactly the length of the bstring b, and the contents + * between the two must be identical except for case with the bstring b with + * no '\0' characters for the two contents to be considered equal. This is + * equivalent to the condition that their current contents will be always be + * equal ignoring case when comparing them in the same format after + * converting one or the other. If the strings are equal, except for case, + * 1 is returned, if they are unequal regardless of case 0 is returned and + * if there is a detectable error BSTR_ERR is returned. + */ +int biseqcstrcaseless (const_bstring b, const char * s) { +int i; + if (b == NULL || s == NULL || b->data == NULL || b->slen < 0) + return BSTR_ERR; + for (i=0; i < b->slen; i++) { + if (s[i] == '\0' || + (b->data[i] != (unsigned char) s[i] && + downcase (b->data[i]) != (unsigned char) downcase (s[i]))) + return BSTR_OK; + } + return s[i] == '\0'; +} + +/* int bstrcmp (const_bstring b0, const_bstring b1) + * + * Compare the string b0 and b1. If there is an error, SHRT_MIN is returned, + * otherwise a value less than or greater than zero, indicating that the + * string pointed to by b0 is lexicographically less than or greater than + * the string pointed to by b1 is returned. If the the string lengths are + * unequal but the characters up until the length of the shorter are equal + * then a value less than, or greater than zero, indicating that the string + * pointed to by b0 is shorter or longer than the string pointed to by b1 is + * returned. 0 is returned if and only if the two strings are the same. If + * the length of the strings are different, this function is O(n). Like its + * standard C library counter part strcmp, the comparison does not proceed + * past any '\0' termination characters encountered. + */ +int bstrcmp (const_bstring b0, const_bstring b1) { +int i, v, n; + + if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL || + b0->slen < 0 || b1->slen < 0) return SHRT_MIN; + n = b0->slen; if (n > b1->slen) n = b1->slen; + if (b0->slen == b1->slen && (b0->data == b1->data || b0->slen == 0)) + return BSTR_OK; + + for (i = 0; i < n; i ++) { + v = ((char) b0->data[i]) - ((char) b1->data[i]); + if (v != 0) return v; + if (b0->data[i] == (unsigned char) '\0') return BSTR_OK; + } + + if (b0->slen > n) return 1; + if (b1->slen > n) return -1; + return BSTR_OK; +} + +/* int bstrncmp (const_bstring b0, const_bstring b1, int n) + * + * Compare the string b0 and b1 for at most n characters. If there is an + * error, SHRT_MIN is returned, otherwise a value is returned as if b0 and + * b1 were first truncated to at most n characters then bstrcmp was called + * with these new strings are paremeters. If the length of the strings are + * different, this function is O(n). Like its standard C library counter + * part strcmp, the comparison does not proceed past any '\0' termination + * characters encountered. + */ +int bstrncmp (const_bstring b0, const_bstring b1, int n) { +int i, v, m; + + if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL || + b0->slen < 0 || b1->slen < 0) return SHRT_MIN; + m = n; + if (m > b0->slen) m = b0->slen; + if (m > b1->slen) m = b1->slen; + + if (b0->data != b1->data) { + for (i = 0; i < m; i ++) { + v = ((char) b0->data[i]) - ((char) b1->data[i]); + if (v != 0) return v; + if (b0->data[i] == (unsigned char) '\0') return BSTR_OK; + } + } + + if (n == m || b0->slen == b1->slen) return BSTR_OK; + + if (b0->slen > m) return 1; + return -1; +} + +/* bstring bmidstr (const_bstring b, int left, int len) + * + * Create a bstring which is the substring of b starting from position left + * and running for a length len (clamped by the end of the bstring b.) If + * b is detectably invalid, then NULL is returned. The section described + * by (left, len) is clamped to the boundaries of b. + */ +bstring bmidstr (const_bstring b, int left, int len) { + + if (b == NULL || b->slen < 0 || b->data == NULL) return NULL; + + if (left < 0) { + len += left; + left = 0; + } + + if (len > b->slen - left) len = b->slen - left; + + if (len <= 0) return bfromcstr (""); + return blk2bstr (b->data + left, len); +} + +/* int bdelete (bstring b, int pos, int len) + * + * Removes characters from pos to pos+len-1 inclusive and shifts the tail of + * the bstring starting from pos+len to pos. len must be positive for this + * call to have any effect. The section of the string described by (pos, + * len) is clamped to boundaries of the bstring b. + */ +int bdelete (bstring b, int pos, int len) { + /* Clamp to left side of bstring */ + if (pos < 0) { + len += pos; + pos = 0; + } + + if (len < 0 || b == NULL || b->data == NULL || b->slen < 0 || + b->mlen < b->slen || b->mlen <= 0) + return BSTR_ERR; + if (len > 0 && pos < b->slen) { + if (pos + len >= b->slen) { + b->slen = pos; + } else { + bBlockCopy ((char *) (b->data + pos), + (char *) (b->data + pos + len), + b->slen - (pos+len)); + b->slen -= len; + } + b->data[b->slen] = (unsigned char) '\0'; + } + return BSTR_OK; +} + +/* int bdestroy (bstring b) + * + * Free up the bstring. Note that if b is detectably invalid or not writable + * then no action is performed and BSTR_ERR is returned. Like a freed memory + * allocation, dereferences, writes or any other action on b after it has + * been bdestroyed is undefined. + */ +int bdestroy (bstring b) { + if (b == NULL || b->slen < 0 || b->mlen <= 0 || b->mlen < b->slen || + b->data == NULL) + return BSTR_ERR; + + bstr__free (b->data); + + /* In case there is any stale usage, there is one more chance to + notice this error. */ + + b->slen = -1; + b->mlen = -__LINE__; + b->data = NULL; + + bstr__free (b); + return BSTR_OK; +} + +/* int binstr (const_bstring b1, int pos, const_bstring b2) + * + * Search for the bstring b2 in b1 starting from position pos, and searching + * forward. If it is found then return with the first position where it is + * found, otherwise return BSTR_ERR. Note that this is just a brute force + * string searcher that does not attempt clever things like the Boyer-Moore + * search algorithm. Because of this there are many degenerate cases where + * this can take much longer than it needs to. + */ +int binstr (const_bstring b1, int pos, const_bstring b2) { +int j, ii, ll, lf; +unsigned char * d0; +unsigned char c0; +register unsigned char * d1; +register unsigned char c1; +register int i; + + if (b1 == NULL || b1->data == NULL || b1->slen < 0 || + b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR; + if (b1->slen == pos) return (b2->slen == 0)?pos:BSTR_ERR; + if (b1->slen < pos || pos < 0) return BSTR_ERR; + if (b2->slen == 0) return pos; + + /* No space to find such a string? */ + if ((lf = b1->slen - b2->slen + 1) <= pos) return BSTR_ERR; + + /* An obvious alias case */ + if (b1->data == b2->data && pos == 0) return 0; + + i = pos; + + d0 = b2->data; + d1 = b1->data; + ll = b2->slen; + + /* Peel off the b2->slen == 1 case */ + c0 = d0[0]; + if (1 == ll) { + for (;i < lf; i++) if (c0 == d1[i]) return i; + return BSTR_ERR; + } + + c1 = c0; + j = 0; + lf = b1->slen - 1; + + ii = -1; + if (i < lf) do { + /* Unrolled current character test */ + if (c1 != d1[i]) { + if (c1 != d1[1+i]) { + i += 2; + continue; + } + i++; + } + + /* Take note if this is the start of a potential match */ + if (0 == j) ii = i; + + /* Shift the test character down by one */ + j++; + i++; + + /* If this isn't past the last character continue */ + if (j < ll) { + c1 = d0[j]; + continue; + } + + N0:; + + /* If no characters mismatched, then we matched */ + if (i == ii+j) return ii; + + /* Shift back to the beginning */ + i -= j; + j = 0; + c1 = c0; + } while (i < lf); + + /* Deal with last case if unrolling caused a misalignment */ + if (i == lf && ll == j+1 && c1 == d1[i]) goto N0; + + return BSTR_ERR; +} + +/* int binstrr (const_bstring b1, int pos, const_bstring b2) + * + * Search for the bstring b2 in b1 starting from position pos, and searching + * backward. If it is found then return with the first position where it is + * found, otherwise return BSTR_ERR. Note that this is just a brute force + * string searcher that does not attempt clever things like the Boyer-Moore + * search algorithm. Because of this there are many degenerate cases where + * this can take much longer than it needs to. + */ +int binstrr (const_bstring b1, int pos, const_bstring b2) { +int j, i, l; +unsigned char * d0, * d1; + + if (b1 == NULL || b1->data == NULL || b1->slen < 0 || + b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR; + if (b1->slen == pos && b2->slen == 0) return pos; + if (b1->slen < pos || pos < 0) return BSTR_ERR; + if (b2->slen == 0) return pos; + + /* Obvious alias case */ + if (b1->data == b2->data && pos == 0 && b2->slen <= b1->slen) return 0; + + i = pos; + if ((l = b1->slen - b2->slen) < 0) return BSTR_ERR; + + /* If no space to find such a string then snap back */ + if (l + 1 <= i) i = l; + j = 0; + + d0 = b2->data; + d1 = b1->data; + l = b2->slen; + + for (;;) { + if (d0[j] == d1[i + j]) { + j ++; + if (j >= l) return i; + } else { + i --; + if (i < 0) break; + j=0; + } + } + + return BSTR_ERR; +} + +/* int binstrcaseless (const_bstring b1, int pos, const_bstring b2) + * + * Search for the bstring b2 in b1 starting from position pos, and searching + * forward but without regard to case. If it is found then return with the + * first position where it is found, otherwise return BSTR_ERR. Note that + * this is just a brute force string searcher that does not attempt clever + * things like the Boyer-Moore search algorithm. Because of this there are + * many degenerate cases where this can take much longer than it needs to. + */ +int binstrcaseless (const_bstring b1, int pos, const_bstring b2) { +int j, i, l, ll; +unsigned char * d0, * d1; + + if (b1 == NULL || b1->data == NULL || b1->slen < 0 || + b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR; + if (b1->slen == pos) return (b2->slen == 0)?pos:BSTR_ERR; + if (b1->slen < pos || pos < 0) return BSTR_ERR; + if (b2->slen == 0) return pos; + + l = b1->slen - b2->slen + 1; + + /* No space to find such a string? */ + if (l <= pos) return BSTR_ERR; + + /* An obvious alias case */ + if (b1->data == b2->data && pos == 0) return BSTR_OK; + + i = pos; + j = 0; + + d0 = b2->data; + d1 = b1->data; + ll = b2->slen; + + for (;;) { + if (d0[j] == d1[i + j] || downcase (d0[j]) == downcase (d1[i + j])) { + j ++; + if (j >= ll) return i; + } else { + i ++; + if (i >= l) break; + j=0; + } + } + + return BSTR_ERR; +} + +/* int binstrrcaseless (const_bstring b1, int pos, const_bstring b2) + * + * Search for the bstring b2 in b1 starting from position pos, and searching + * backward but without regard to case. If it is found then return with the + * first position where it is found, otherwise return BSTR_ERR. Note that + * this is just a brute force string searcher that does not attempt clever + * things like the Boyer-Moore search algorithm. Because of this there are + * many degenerate cases where this can take much longer than it needs to. + */ +int binstrrcaseless (const_bstring b1, int pos, const_bstring b2) { +int j, i, l; +unsigned char * d0, * d1; + + if (b1 == NULL || b1->data == NULL || b1->slen < 0 || + b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR; + if (b1->slen == pos && b2->slen == 0) return pos; + if (b1->slen < pos || pos < 0) return BSTR_ERR; + if (b2->slen == 0) return pos; + + /* Obvious alias case */ + if (b1->data == b2->data && pos == 0 && b2->slen <= b1->slen) + return BSTR_OK; + + i = pos; + if ((l = b1->slen - b2->slen) < 0) return BSTR_ERR; + + /* If no space to find such a string then snap back */ + if (l + 1 <= i) i = l; + j = 0; + + d0 = b2->data; + d1 = b1->data; + l = b2->slen; + + for (;;) { + if (d0[j] == d1[i + j] || downcase (d0[j]) == downcase (d1[i + j])) { + j ++; + if (j >= l) return i; + } else { + i --; + if (i < 0) break; + j=0; + } + } + + return BSTR_ERR; +} + + +/* int bstrchrp (const_bstring b, int c, int pos) + * + * Search for the character c in b forwards from the position pos + * (inclusive). + */ +int bstrchrp (const_bstring b, int c, int pos) { +unsigned char * p; + + if (b == NULL || b->data == NULL || b->slen <= pos || pos < 0) + return BSTR_ERR; + p = (unsigned char *) bstr__memchr ((b->data + pos), (unsigned char) c, + (b->slen - pos)); + if (p) return (int) (p - b->data); + return BSTR_ERR; +} + +/* int bstrrchrp (const_bstring b, int c, int pos) + * + * Search for the character c in b backwards from the position pos in string + * (inclusive). + */ +int bstrrchrp (const_bstring b, int c, int pos) { +int i; + + if (b == NULL || b->data == NULL || b->slen <= pos || pos < 0) + return BSTR_ERR; + for (i=pos; i >= 0; i--) { + if (b->data[i] == (unsigned char) c) return i; + } + return BSTR_ERR; +} + +#if !defined (BSTRLIB_AGGRESSIVE_MEMORY_FOR_SPEED_TRADEOFF) +#define LONG_LOG_BITS_QTY (3) +#define LONG_BITS_QTY (1 << LONG_LOG_BITS_QTY) +#define LONG_TYPE unsigned char + +#define CFCLEN ((1 << CHAR_BIT) / LONG_BITS_QTY) +struct charField { LONG_TYPE content[CFCLEN]; }; +#define testInCharField(cf,c) ((cf)->content[(c) >> LONG_LOG_BITS_QTY] & \ + (((long)1) << ((c) & (LONG_BITS_QTY-1)))) +#define setInCharField(cf,idx) { \ + unsigned int c = (unsigned int) (idx); \ + (cf)->content[c >> LONG_LOG_BITS_QTY] |= \ + (LONG_TYPE) (1ul << (c & (LONG_BITS_QTY-1))); \ +} + +#else + +#define CFCLEN (1 << CHAR_BIT) +struct charField { unsigned char content[CFCLEN]; }; +#define testInCharField(cf,c) ((cf)->content[(unsigned char) (c)]) +#define setInCharField(cf,idx) (cf)->content[(unsigned int) (idx)] = ~0 + +#endif + +/* Convert a bstring to charField */ +static int buildCharField (struct charField * cf, const_bstring b) { +int i; + if (b == NULL || b->data == NULL || b->slen <= 0) return BSTR_ERR; + memset ((void *) cf->content, 0, sizeof (struct charField)); + for (i=0; i < b->slen; i++) { + setInCharField (cf, b->data[i]); + } + return BSTR_OK; +} + +static void invertCharField (struct charField * cf) { +int i; + for (i=0; i < CFCLEN; i++) cf->content[i] = ~cf->content[i]; +} + +/* Inner engine for binchr */ +static int binchrCF (const unsigned char * data, int len, int pos, + const struct charField * cf) { +int i; + for (i=pos; i < len; i++) { + unsigned char c = (unsigned char) data[i]; + if (testInCharField (cf, c)) return i; + } + return BSTR_ERR; +} + +/* int binchr (const_bstring b0, int pos, const_bstring b1); + * + * Search for the first position in b0 starting from pos or after, in which + * one of the characters in b1 is found and return it. If such a position + * does not exist in b0, then BSTR_ERR is returned. + */ +int binchr (const_bstring b0, int pos, const_bstring b1) { +struct charField chrs; + if (pos < 0 || b0 == NULL || b0->data == NULL || + b0->slen <= pos) return BSTR_ERR; + if (1 == b1->slen) return bstrchrp (b0, b1->data[0], pos); + if (0 > buildCharField (&chrs, b1)) return BSTR_ERR; + return binchrCF (b0->data, b0->slen, pos, &chrs); +} + +/* Inner engine for binchrr */ +static int binchrrCF (const unsigned char * data, int pos, + const struct charField * cf) { +int i; + for (i=pos; i >= 0; i--) { + unsigned int c = (unsigned int) data[i]; + if (testInCharField (cf, c)) return i; + } + return BSTR_ERR; +} + +/* int binchrr (const_bstring b0, int pos, const_bstring b1); + * + * Search for the last position in b0 no greater than pos, in which one of + * the characters in b1 is found and return it. If such a position does not + * exist in b0, then BSTR_ERR is returned. + */ +int binchrr (const_bstring b0, int pos, const_bstring b1) { +struct charField chrs; + if (pos < 0 || b0 == NULL || b0->data == NULL || b1 == NULL || + b0->slen < pos) return BSTR_ERR; + if (pos == b0->slen) pos--; + if (1 == b1->slen) return bstrrchrp (b0, b1->data[0], pos); + if (0 > buildCharField (&chrs, b1)) return BSTR_ERR; + return binchrrCF (b0->data, pos, &chrs); +} + +/* int bninchr (const_bstring b0, int pos, const_bstring b1); + * + * Search for the first position in b0 starting from pos or after, in which + * none of the characters in b1 is found and return it. If such a position + * does not exist in b0, then BSTR_ERR is returned. + */ +int bninchr (const_bstring b0, int pos, const_bstring b1) { +struct charField chrs; + if (pos < 0 || b0 == NULL || b0->data == NULL || + b0->slen <= pos) return BSTR_ERR; + if (buildCharField (&chrs, b1) < 0) return BSTR_ERR; + invertCharField (&chrs); + return binchrCF (b0->data, b0->slen, pos, &chrs); +} + +/* int bninchrr (const_bstring b0, int pos, const_bstring b1); + * + * Search for the last position in b0 no greater than pos, in which none of + * the characters in b1 is found and return it. If such a position does not + * exist in b0, then BSTR_ERR is returned. + */ +int bninchrr (const_bstring b0, int pos, const_bstring b1) { +struct charField chrs; + if (pos < 0 || b0 == NULL || b0->data == NULL || + b0->slen < pos) return BSTR_ERR; + if (pos == b0->slen) pos--; + if (buildCharField (&chrs, b1) < 0) return BSTR_ERR; + invertCharField (&chrs); + return binchrrCF (b0->data, pos, &chrs); +} + +/* int bsetstr (bstring b0, int pos, bstring b1, unsigned char fill) + * + * Overwrite the string b0 starting at position pos with the string b1. If + * the position pos is past the end of b0, then the character "fill" is + * appended as necessary to make up the gap between the end of b0 and pos. + * If b1 is NULL, it behaves as if it were a 0-length string. + */ +int bsetstr (bstring b0, int pos, const_bstring b1, unsigned char fill) { +int d, newlen; +ptrdiff_t pd; +bstring aux = (bstring) b1; + + if (pos < 0 || b0 == NULL || b0->slen < 0 || NULL == b0->data || + b0->mlen < b0->slen || b0->mlen <= 0) return BSTR_ERR; + if (b1 != NULL && (b1->slen < 0 || b1->data == NULL)) return BSTR_ERR; + + d = pos; + + /* Aliasing case */ + if (NULL != aux) { + if ((pd = (ptrdiff_t) (b1->data - b0->data)) >= 0 && + pd < (ptrdiff_t) b0->mlen) { + if (NULL == (aux = bstrcpy (b1))) return BSTR_ERR; + } + d += aux->slen; + } + + /* Increase memory size if necessary */ + if (balloc (b0, d + 1) != BSTR_OK) { + if (aux != b1) bdestroy (aux); + return BSTR_ERR; + } + + newlen = b0->slen; + + /* Fill in "fill" character as necessary */ + if (pos > newlen) { + bstr__memset (b0->data + b0->slen, (int) fill, + (size_t) (pos - b0->slen)); + newlen = pos; + } + + /* Copy b1 to position pos in b0. */ + if (aux != NULL) { + bBlockCopy ((char *) (b0->data + pos), (char *) aux->data, aux->slen); + if (aux != b1) bdestroy (aux); + } + + /* Indicate the potentially increased size of b0 */ + if (d > newlen) newlen = d; + + b0->slen = newlen; + b0->data[newlen] = (unsigned char) '\0'; + + return BSTR_OK; +} + +/* int binsertblk (bstring b, int pos, const void * blk, int len, + * unsigned char fill) + * + * Inserts the block of characters at blk with length len into b at position + * pos. If the position pos is past the end of b, then the character "fill" + * is appended as necessary to make up the gap between the end of b1 and pos. + * Unlike bsetstr, binsert does not allow b2 to be NULL. + */ +int binsertblk (bstring b, int pos, const void * blk, int len, + unsigned char fill) { +int d, l; +unsigned char* aux = (unsigned char*) blk; + + if (b == NULL || blk == NULL || pos < 0 || len < 0 || b->slen < 0 || + b->mlen <= 0 || b->mlen < b->slen) return BSTR_ERR; + + /* Compute the two possible end pointers */ + d = b->slen + len; + l = pos + len; + if ((d|l) < 0) return BSTR_ERR; /* Integer wrap around. */ + + /* Aliasing case */ + if (((size_t) ((unsigned char*) blk + len)) >= ((size_t) b->data) && + ((size_t) blk) < ((size_t) (b->data + b->mlen))) { + if (NULL == (aux = (unsigned char*) bstr__alloc (len))) + return BSTR_ERR; + bstr__memcpy (aux, blk, len); + } + + if (l > d) { + /* Inserting past the end of the string */ + if (balloc (b, l + 1) != BSTR_OK) { + if (aux != (unsigned char*) blk) bstr__free (aux); + return BSTR_ERR; + } + bstr__memset (b->data + b->slen, (int) fill, + (size_t) (pos - b->slen)); + b->slen = l; + } else { + /* Inserting in the middle of the string */ + if (balloc (b, d + 1) != BSTR_OK) { + if (aux != (unsigned char*) blk) bstr__free (aux); + return BSTR_ERR; + } + bBlockCopy (b->data + l, b->data + pos, d - l); + b->slen = d; + } + bBlockCopy (b->data + pos, aux, len); + b->data[b->slen] = (unsigned char) '\0'; + if (aux != (unsigned char*) blk) bstr__free (aux); + return BSTR_OK; +} + +/* int binsert (bstring b1, int pos, const_bstring b2, unsigned char fill) + * + * Inserts the string b2 into b1 at position pos. If the position pos is + * past the end of b1, then the character "fill" is appended as necessary to + * make up the gap between the end of b1 and pos. Unlike bsetstr, binsert + * does not allow b2 to be NULL. + */ +int binsert (bstring b1, int pos, const_bstring b2, unsigned char fill) { + if (NULL == b2 || (b2->mlen > 0 && b2->slen > b2->mlen)) return BSTR_ERR; + return binsertblk (b1, pos, b2->data, b2->slen, fill); +} + +/* int breplace (bstring b1, int pos, int len, bstring b2, + * unsigned char fill) + * + * Replace a section of a string from pos for a length len with the string + * b2. fill is used is pos > b1->slen. + */ +int breplace (bstring b1, int pos, int len, const_bstring b2, + unsigned char fill) { +int pl, ret; +ptrdiff_t pd; +bstring aux = (bstring) b2; + + if (pos < 0 || len < 0) return BSTR_ERR; + if (pos > INT_MAX - len) return BSTR_ERR; /* Overflow */ + pl = pos + len; + if (b1 == NULL || b2 == NULL || b1->data == NULL || b2->data == NULL || + b1->slen < 0 || b2->slen < 0 || b1->mlen < b1->slen || + b1->mlen <= 0) return BSTR_ERR; + + /* Straddles the end? */ + if (pl >= b1->slen) { + if ((ret = bsetstr (b1, pos, b2, fill)) < 0) return ret; + if (pos + b2->slen < b1->slen) { + b1->slen = pos + b2->slen; + b1->data[b1->slen] = (unsigned char) '\0'; + } + return ret; + } + + /* Aliasing case */ + if ((pd = (ptrdiff_t) (b2->data - b1->data)) >= 0 && + pd < (ptrdiff_t) b1->slen) { + if (NULL == (aux = bstrcpy (b2))) return BSTR_ERR; + } + + if (aux->slen > len) { + if (balloc (b1, b1->slen + aux->slen - len) != BSTR_OK) { + if (aux != b2) bdestroy (aux); + return BSTR_ERR; + } + } + + if (aux->slen != len) bstr__memmove (b1->data + pos + aux->slen, + b1->data + pos + len, + b1->slen - (pos + len)); + bstr__memcpy (b1->data + pos, aux->data, aux->slen); + b1->slen += aux->slen - len; + b1->data[b1->slen] = (unsigned char) '\0'; + if (aux != b2) bdestroy (aux); + return BSTR_OK; +} + +/* + * findreplaceengine is used to implement bfindreplace and + * bfindreplacecaseless. It works by breaking the three cases of + * expansion, reduction and replacement, and solving each of these + * in the most efficient way possible. + */ + +typedef int (*instr_fnptr) (const_bstring s1, int pos, const_bstring s2); + +#define INITIAL_STATIC_FIND_INDEX_COUNT 32 + +static int findreplaceengine (bstring b, const_bstring find, + const_bstring repl, int pos, + instr_fnptr instr) { +int i, ret, delta, acc; +unsigned int mlen, slen; +int * d; +int static_d[INITIAL_STATIC_FIND_INDEX_COUNT+1]; /* This +1 is for LINT. */ +ptrdiff_t pd; +bstring auxf = (bstring) find; +bstring auxr = (bstring) repl; + + if (b == NULL || b->data == NULL || find == NULL || + find->data == NULL || repl == NULL || repl->data == NULL || + pos < 0 || find->slen <= 0 || b->mlen <= 0 || b->slen > b->mlen || + b->slen < 0 || repl->slen < 0) return BSTR_ERR; + if (pos > b->slen - find->slen) return BSTR_OK; + + /* Alias with find string */ + pd = (ptrdiff_t) (find->data - b->data); + if ((ptrdiff_t) (pos - find->slen) < pd && pd < (ptrdiff_t) b->slen) { + if (NULL == (auxf = bstrcpy (find))) return BSTR_ERR; + } + + /* Alias with repl string */ + pd = (ptrdiff_t) (repl->data - b->data); + if ((ptrdiff_t) (pos - repl->slen) < pd && pd < (ptrdiff_t) b->slen) { + if (NULL == (auxr = bstrcpy (repl))) { + if (auxf != find) bdestroy (auxf); + return BSTR_ERR; + } + } + + delta = auxf->slen - auxr->slen; + + /* in-place replacement since find and replace strings are of equal + length */ + if (delta == 0) { + while ((pos = instr (b, pos, auxf)) >= 0) { + bstr__memcpy (b->data + pos, auxr->data, auxr->slen); + pos += auxf->slen; + } + if (auxf != find) bdestroy (auxf); + if (auxr != repl) bdestroy (auxr); + return BSTR_OK; + } + + /* shrinking replacement since auxf->slen > auxr->slen */ + if (delta > 0) { + acc = 0; + + while ((i = instr (b, pos, auxf)) >= 0) { + if (acc && i > pos) + bstr__memmove (b->data + pos - acc, b->data + pos, i - pos); + if (auxr->slen) + bstr__memcpy (b->data + i - acc, auxr->data, auxr->slen); + acc += delta; + pos = i + auxf->slen; + } + + if (acc) { + i = b->slen; + if (i > pos) + bstr__memmove (b->data + pos - acc, b->data + pos, i - pos); + b->slen -= acc; + b->data[b->slen] = (unsigned char) '\0'; + } + + if (auxf != find) bdestroy (auxf); + if (auxr != repl) bdestroy (auxr); + return BSTR_OK; + } + + /* expanding replacement since find->slen < repl->slen. Its a lot + more complicated. This works by first finding all the matches and + storing them to a growable array, then doing at most one resize of + the destination bstring and then performing the direct memory transfers + of the string segment pieces to form the final result. The growable + array of matches uses a deferred doubling reallocing strategy. What + this means is that it starts as a reasonably fixed sized auto array in + the hopes that many if not most cases will never need to grow this + array. But it switches as soon as the bounds of the array will be + exceeded. An extra find result is always appended to this array that + corresponds to the end of the destination string, so slen is checked + against mlen - 1 rather than mlen before resizing. + */ + + mlen = INITIAL_STATIC_FIND_INDEX_COUNT; + d = (int *) static_d; /* Avoid malloc for trivial/initial cases */ + acc = slen = 0; + + while ((pos = instr (b, pos, auxf)) >= 0) { + if (slen >= mlen - 1) { + int *t; + int sl; + /* Overflow */ + if (mlen > (INT_MAX / sizeof(int *)) / 2) { + ret = BSTR_ERR; + goto done; + } + mlen += mlen; + sl = sizeof (int *) * mlen; + if (static_d == d) d = NULL; /* static_d cannot be realloced */ + if (NULL == (t = (int *) bstr__realloc (d, sl))) { + ret = BSTR_ERR; + goto done; + } + if (NULL == d) bstr__memcpy (t, static_d, sizeof (static_d)); + d = t; + } + d[slen] = pos; + slen++; + acc -= delta; + pos += auxf->slen; + if (pos < 0 || acc < 0) { + ret = BSTR_ERR; + goto done; + } + } + + /* slen <= INITIAL_STATIC_INDEX_COUNT-1 or mlen-1 here. */ + d[slen] = b->slen; + + if (BSTR_OK == (ret = balloc (b, b->slen + acc + 1))) { + b->slen += acc; + for (i = slen-1; i >= 0; i--) { + int s, l; + s = d[i] + auxf->slen; + l = d[i+1] - s; /* d[slen] may be accessed here. */ + if (l) { + bstr__memmove (b->data + s + acc, b->data + s, l); + } + if (auxr->slen) { + bstr__memmove (b->data + s + acc - auxr->slen, + auxr->data, auxr->slen); + } + acc += delta; + } + b->data[b->slen] = (unsigned char) '\0'; + } + + done:; + if (static_d != d) bstr__free (d); + if (auxf != find) bdestroy (auxf); + if (auxr != repl) bdestroy (auxr); + return ret; +} + +/* int bfindreplace (bstring b, const_bstring find, const_bstring repl, + * int pos) + * + * Replace all occurrences of a find string with a replace string after a + * given point in a bstring. + */ +int bfindreplace (bstring b, const_bstring find, const_bstring repl, + int pos) { + return findreplaceengine (b, find, repl, pos, binstr); +} + +/* int bfindreplacecaseless (bstring b, const_bstring find, + * const_bstring repl, int pos) + * + * Replace all occurrences of a find string, ignoring case, with a replace + * string after a given point in a bstring. + */ +int bfindreplacecaseless (bstring b, const_bstring find, const_bstring repl, + int pos) { + return findreplaceengine (b, find, repl, pos, binstrcaseless); +} + +/* int binsertch (bstring b, int pos, int len, unsigned char fill) + * + * Inserts the character fill repeatedly into b at position pos for a + * length len. If the position pos is past the end of b, then the + * character "fill" is appended as necessary to make up the gap between the + * end of b and the position pos + len. + */ +int binsertch (bstring b, int pos, int len, unsigned char fill) { +int d, l, i; + + if (pos < 0 || b == NULL || b->slen < 0 || b->mlen < b->slen || + b->mlen <= 0 || len < 0) return BSTR_ERR; + + /* Compute the two possible end pointers */ + d = b->slen + len; + l = pos + len; + if ((d|l) < 0) return BSTR_ERR; + + if (l > d) { + /* Inserting past the end of the string */ + if (balloc (b, l + 1) != BSTR_OK) return BSTR_ERR; + pos = b->slen; + b->slen = l; + } else { + /* Inserting in the middle of the string */ + if (balloc (b, d + 1) != BSTR_OK) return BSTR_ERR; + for (i = d - 1; i >= l; i--) { + b->data[i] = b->data[i - len]; + } + b->slen = d; + } + + for (i=pos; i < l; i++) b->data[i] = fill; + b->data[b->slen] = (unsigned char) '\0'; + return BSTR_OK; +} + +/* int bpattern (bstring b, int len) + * + * Replicate the bstring, b in place, end to end repeatedly until it + * surpasses len characters, then chop the result to exactly len characters. + * This function operates in-place. The function will return with BSTR_ERR + * if b is NULL or of length 0, otherwise BSTR_OK is returned. + */ +int bpattern (bstring b, int len) { +int i, d; + + d = blength (b); + if (d <= 0 || len < 0 || balloc (b, len + 1) != BSTR_OK) return BSTR_ERR; + if (len > 0) { + if (d == 1) return bsetstr (b, len, NULL, b->data[0]); + for (i = d; i < len; i++) b->data[i] = b->data[i - d]; + } + b->data[len] = (unsigned char) '\0'; + b->slen = len; + return BSTR_OK; +} + +#define BS_BUFF_SZ (1024) + +/* int breada (bstring b, bNread readPtr, void * parm) + * + * Use a finite buffer fread-like function readPtr to concatenate to the + * bstring b the entire contents of file-like source data in a roughly + * efficient way. + */ +int breada (bstring b, bNread readPtr, void * parm) { +int i, l, n; + + if (b == NULL || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen || + readPtr == NULL) return BSTR_ERR; + + i = b->slen; + for (n=i+16; ; n += ((n < BS_BUFF_SZ) ? n : BS_BUFF_SZ)) { + if (BSTR_OK != balloc (b, n + 1)) return BSTR_ERR; + l = (int) readPtr ((void *) (b->data + i), 1, n - i, parm); + i += l; + b->slen = i; + if (i < n) break; + } + + b->data[i] = (unsigned char) '\0'; + return BSTR_OK; +} + +/* bstring bread (bNread readPtr, void * parm) + * + * Use a finite buffer fread-like function readPtr to create a bstring + * filled with the entire contents of file-like source data in a roughly + * efficient way. + */ +bstring bread (bNread readPtr, void * parm) { +bstring buff; + + if (0 > breada (buff = bfromcstr (""), readPtr, parm)) { + bdestroy (buff); + return NULL; + } + return buff; +} + +/* int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator) + * + * Use an fgetc-like single character stream reading function (getcPtr) to + * obtain a sequence of characters which are concatenated to the end of the + * bstring b. The stream read is terminated by the passed in terminator + * parameter. + * + * If getcPtr returns with a negative number, or the terminator character + * (which is appended) is read, then the stream reading is halted and the + * function returns with a partial result in b. If there is an empty partial + * result, 1 is returned. If no characters are read, or there is some other + * detectable error, BSTR_ERR is returned. + */ +int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator) { +int c, d, e; + + if (b == NULL || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen || + getcPtr == NULL) return BSTR_ERR; + d = 0; + e = b->mlen - 2; + + while ((c = getcPtr (parm)) >= 0) { + if (d > e) { + b->slen = d; + if (balloc (b, d + 2) != BSTR_OK) return BSTR_ERR; + e = b->mlen - 2; + } + b->data[d] = (unsigned char) c; + d++; + if (c == terminator) break; + } + + b->data[d] = (unsigned char) '\0'; + b->slen = d; + + return d == 0 && c < 0; +} + +/* int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator) + * + * Use an fgetc-like single character stream reading function (getcPtr) to + * obtain a sequence of characters which are concatenated to the end of the + * bstring b. The stream read is terminated by the passed in terminator + * parameter. + * + * If getcPtr returns with a negative number, or the terminator character + * (which is appended) is read, then the stream reading is halted and the + * function returns with a partial result concatentated to b. If there is + * an empty partial result, 1 is returned. If no characters are read, or + * there is some other detectable error, BSTR_ERR is returned. + */ +int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator) { +int c, d, e; + + if (b == NULL || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen || + getcPtr == NULL) return BSTR_ERR; + d = b->slen; + e = b->mlen - 2; + + while ((c = getcPtr (parm)) >= 0) { + if (d > e) { + b->slen = d; + if (balloc (b, d + 2) != BSTR_OK) return BSTR_ERR; + e = b->mlen - 2; + } + b->data[d] = (unsigned char) c; + d++; + if (c == terminator) break; + } + + b->data[d] = (unsigned char) '\0'; + b->slen = d; + + return d == 0 && c < 0; +} + +/* bstring bgets (bNgetc getcPtr, void * parm, char terminator) + * + * Use an fgetc-like single character stream reading function (getcPtr) to + * obtain a sequence of characters which are concatenated into a bstring. + * The stream read is terminated by the passed in terminator function. + * + * If getcPtr returns with a negative number, or the terminator character + * (which is appended) is read, then the stream reading is halted and the + * result obtained thus far is returned. If no characters are read, or + * there is some other detectable error, NULL is returned. + */ +bstring bgets (bNgetc getcPtr, void * parm, char terminator) { +bstring buff; + + if (0 > bgetsa (buff = bfromcstr (""), getcPtr, parm, terminator) || + 0 >= buff->slen) { + bdestroy (buff); + buff = NULL; + } + return buff; +} + +struct bStream { + bstring buff; /* Buffer for over-reads */ + void * parm; /* The stream handle for core stream */ + bNread readFnPtr; /* fread compatible fnptr for core stream */ + int isEOF; /* track file's EOF state */ + int maxBuffSz; +}; + +/* struct bStream * bsopen (bNread readPtr, void * parm) + * + * Wrap a given open stream (described by a fread compatible function + * pointer and stream handle) into an open bStream suitable for the bstring + * library streaming functions. + */ +struct bStream * bsopen (bNread readPtr, void * parm) { +struct bStream * s; + + if (readPtr == NULL) return NULL; + s = (struct bStream *) bstr__alloc (sizeof (struct bStream)); + if (s == NULL) return NULL; + s->parm = parm; + s->buff = bfromcstr (""); + s->readFnPtr = readPtr; + s->maxBuffSz = BS_BUFF_SZ; + s->isEOF = 0; + return s; +} + +/* int bsbufflength (struct bStream * s, int sz) + * + * Set the length of the buffer used by the bStream. If sz is zero, the + * length is not set. This function returns with the previous length. + */ +int bsbufflength (struct bStream * s, int sz) { +int oldSz; + if (s == NULL || sz < 0) return BSTR_ERR; + oldSz = s->maxBuffSz; + if (sz > 0) s->maxBuffSz = sz; + return oldSz; +} + +int bseof (const struct bStream * s) { + if (s == NULL || s->readFnPtr == NULL) return BSTR_ERR; + return s->isEOF && (s->buff->slen == 0); +} + +/* void * bsclose (struct bStream * s) + * + * Close the bStream, and return the handle to the stream that was originally + * used to open the given stream. + */ +void * bsclose (struct bStream * s) { +void * parm; + if (s == NULL) return NULL; + s->readFnPtr = NULL; + if (s->buff) bdestroy (s->buff); + s->buff = NULL; + parm = s->parm; + s->parm = NULL; + s->isEOF = 1; + bstr__free (s); + return parm; +} + +/* int bsreadlna (bstring r, struct bStream * s, char terminator) + * + * Read a bstring terminated by the terminator character or the end of the + * stream from the bStream (s) and return it into the parameter r. This + * function may read additional characters from the core stream that are not + * returned, but will be retained for subsequent read operations. + */ +int bsreadlna (bstring r, struct bStream * s, char terminator) { +int i, l, ret, rlo; +char * b; +struct tagbstring x; + + if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0 || + r->slen < 0 || r->mlen < r->slen) return BSTR_ERR; + l = s->buff->slen; + if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR; + b = (char *) s->buff->data; + x.data = (unsigned char *) b; + + /* First check if the current buffer holds the terminator */ + b[l] = terminator; /* Set sentinel */ + for (i=0; b[i] != terminator; i++) ; + if (i < l) { + x.slen = i + 1; + ret = bconcat (r, &x); + s->buff->slen = l; + if (BSTR_OK == ret) bdelete (s->buff, 0, i + 1); + return BSTR_OK; + } + + rlo = r->slen; + + /* If not then just concatenate the entire buffer to the output */ + x.slen = l; + if (BSTR_OK != bconcat (r, &x)) return BSTR_ERR; + + /* Perform direct in-place reads into the destination to allow for + the minimum of data-copies */ + for (;;) { + if (BSTR_OK != balloc (r, r->slen + s->maxBuffSz + 1)) + return BSTR_ERR; + b = (char *) (r->data + r->slen); + l = (int) s->readFnPtr (b, 1, s->maxBuffSz, s->parm); + if (l <= 0) { + r->data[r->slen] = (unsigned char) '\0'; + s->buff->slen = 0; + s->isEOF = 1; + /* If nothing was read return with an error message */ + return BSTR_ERR & -(r->slen == rlo); + } + b[l] = terminator; /* Set sentinel */ + for (i=0; b[i] != terminator; i++) ; + if (i < l) break; + r->slen += l; + } + + /* Terminator found, push over-read back to buffer */ + i++; + r->slen += i; + s->buff->slen = l - i; + bstr__memcpy (s->buff->data, b + i, l - i); + r->data[r->slen] = (unsigned char) '\0'; + return BSTR_OK; +} + +/* int bsreadlnsa (bstring r, struct bStream * s, bstring term) + * + * Read a bstring terminated by any character in the term string or the end + * of the stream from the bStream (s) and return it into the parameter r. + * This function may read additional characters from the core stream that + * are not returned, but will be retained for subsequent read operations. + */ +int bsreadlnsa (bstring r, struct bStream * s, const_bstring term) { +int i, l, ret, rlo; +unsigned char * b; +struct tagbstring x; +struct charField cf; + + if (s == NULL || s->buff == NULL || r == NULL || term == NULL || + term->data == NULL || r->mlen <= 0 || r->slen < 0 || + r->mlen < r->slen) return BSTR_ERR; + if (term->slen == 1) return bsreadlna (r, s, term->data[0]); + if (term->slen < 1 || buildCharField (&cf, term)) return BSTR_ERR; + + l = s->buff->slen; + if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR; + b = (unsigned char *) s->buff->data; + x.data = b; + + /* First check if the current buffer holds the terminator */ + b[l] = term->data[0]; /* Set sentinel */ + for (i=0; !testInCharField (&cf, b[i]); i++) ; + if (i < l) { + x.slen = i + 1; + ret = bconcat (r, &x); + s->buff->slen = l; + if (BSTR_OK == ret) bdelete (s->buff, 0, i + 1); + return BSTR_OK; + } + + rlo = r->slen; + + /* If not then just concatenate the entire buffer to the output */ + x.slen = l; + if (BSTR_OK != bconcat (r, &x)) return BSTR_ERR; + + /* Perform direct in-place reads into the destination to allow for + the minimum of data-copies */ + for (;;) { + if (BSTR_OK != balloc (r, r->slen + s->maxBuffSz + 1)) + return BSTR_ERR; + b = (unsigned char *) (r->data + r->slen); + l = (int) s->readFnPtr (b, 1, s->maxBuffSz, s->parm); + if (l <= 0) { + r->data[r->slen] = (unsigned char) '\0'; + s->buff->slen = 0; + s->isEOF = 1; + /* If nothing was read return with an error message */ + return BSTR_ERR & -(r->slen == rlo); + } + + b[l] = term->data[0]; /* Set sentinel */ + for (i=0; !testInCharField (&cf, b[i]); i++) ; + if (i < l) break; + r->slen += l; + } + + /* Terminator found, push over-read back to buffer */ + i++; + r->slen += i; + s->buff->slen = l - i; + bstr__memcpy (s->buff->data, b + i, l - i); + r->data[r->slen] = (unsigned char) '\0'; + return BSTR_OK; +} + +/* int bsreada (bstring r, struct bStream * s, int n) + * + * Read a bstring of length n (or, if it is fewer, as many bytes as is + * remaining) from the bStream. This function may read additional + * characters from the core stream that are not returned, but will be + * retained for subsequent read operations. This function will not read + * additional characters from the core stream beyond virtual stream pointer. + */ +int bsreada (bstring r, struct bStream * s, int n) { +int l, ret, orslen; +char * b; +struct tagbstring x; + + if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0 + || r->slen < 0 || r->mlen < r->slen || n <= 0) return BSTR_ERR; + + if (n > INT_MAX - r->slen) return BSTR_ERR; + n += r->slen; + + l = s->buff->slen; + + orslen = r->slen; + + if (0 == l) { + if (s->isEOF) return BSTR_ERR; + if (r->mlen > n) { + l = (int) s->readFnPtr (r->data + r->slen, 1, n - r->slen, + s->parm); + if (0 >= l || l > n - r->slen) { + s->isEOF = 1; + return BSTR_ERR; + } + r->slen += l; + r->data[r->slen] = (unsigned char) '\0'; + return 0; + } + } + + if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR; + b = (char *) s->buff->data; + x.data = (unsigned char *) b; + + do { + if (l + r->slen >= n) { + x.slen = n - r->slen; + ret = bconcat (r, &x); + s->buff->slen = l; + if (BSTR_OK == ret) bdelete (s->buff, 0, x.slen); + return BSTR_ERR & -(r->slen == orslen); + } + + x.slen = l; + if (BSTR_OK != bconcat (r, &x)) break; + + l = n - r->slen; + if (l > s->maxBuffSz) l = s->maxBuffSz; + + l = (int) s->readFnPtr (b, 1, l, s->parm); + + } while (l > 0); + if (l < 0) l = 0; + if (l == 0) s->isEOF = 1; + s->buff->slen = l; + return BSTR_ERR & -(r->slen == orslen); +} + +/* int bsreadln (bstring r, struct bStream * s, char terminator) + * + * Read a bstring terminated by the terminator character or the end of the + * stream from the bStream (s) and return it into the parameter r. This + * function may read additional characters from the core stream that are not + * returned, but will be retained for subsequent read operations. + */ +int bsreadln (bstring r, struct bStream * s, char terminator) { + if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0) + return BSTR_ERR; + if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR; + r->slen = 0; + return bsreadlna (r, s, terminator); +} + +/* int bsreadlns (bstring r, struct bStream * s, bstring term) + * + * Read a bstring terminated by any character in the term string or the end + * of the stream from the bStream (s) and return it into the parameter r. + * This function may read additional characters from the core stream that + * are not returned, but will be retained for subsequent read operations. + */ +int bsreadlns (bstring r, struct bStream * s, const_bstring term) { + if (s == NULL || s->buff == NULL || r == NULL || term == NULL + || term->data == NULL || r->mlen <= 0) return BSTR_ERR; + if (term->slen == 1) return bsreadln (r, s, term->data[0]); + if (term->slen < 1) return BSTR_ERR; + if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR; + r->slen = 0; + return bsreadlnsa (r, s, term); +} + +/* int bsread (bstring r, struct bStream * s, int n) + * + * Read a bstring of length n (or, if it is fewer, as many bytes as is + * remaining) from the bStream. This function may read additional + * characters from the core stream that are not returned, but will be + * retained for subsequent read operations. This function will not read + * additional characters from the core stream beyond virtual stream pointer. + */ +int bsread (bstring r, struct bStream * s, int n) { + if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0 + || n <= 0) return BSTR_ERR; + if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR; + r->slen = 0; + return bsreada (r, s, n); +} + +/* int bsunread (struct bStream * s, const_bstring b) + * + * Insert a bstring into the bStream at the current position. These + * characters will be read prior to those that actually come from the core + * stream. + */ +int bsunread (struct bStream * s, const_bstring b) { + if (s == NULL || s->buff == NULL) return BSTR_ERR; + return binsert (s->buff, 0, b, (unsigned char) '?'); +} + +/* int bspeek (bstring r, const struct bStream * s) + * + * Return the currently buffered characters from the bStream that will be + * read prior to reads from the core stream. + */ +int bspeek (bstring r, const struct bStream * s) { + if (s == NULL || s->buff == NULL) return BSTR_ERR; + return bassign (r, s->buff); +} + +/* bstring bjoinblk (const struct bstrList * bl, void * blk, int len); + * + * Join the entries of a bstrList into one bstring by sequentially + * concatenating them with the content from blk for length len in between. + * If there is an error NULL is returned, otherwise a bstring with the + * correct result is returned. + */ +bstring bjoinblk (const struct bstrList * bl, const void * blk, int len) { +bstring b; +unsigned char * p; +int i, c, v; + + if (bl == NULL || bl->qty < 0) return NULL; + if (len < 0) return NULL; + if (len > 0 && blk == NULL) return NULL; + if (bl->qty < 1) return bfromStatic (""); + + for (i = 0, c = 1; i < bl->qty; i++) { + v = bl->entry[i]->slen; + if (v < 0) return NULL; /* Invalid input */ + if (v > INT_MAX - c) return NULL; /* Overflow */ + c += v; + } + + b = (bstring) bstr__alloc (sizeof (struct tagbstring)); + if (len == 0) { + p = b->data = (unsigned char *) bstr__alloc (c); + if (p == NULL) { + bstr__free (b); + return NULL; + } + for (i = 0; i < bl->qty; i++) { + v = bl->entry[i]->slen; + bstr__memcpy (p, bl->entry[i]->data, v); + p += v; + } + } else { + v = (bl->qty - 1) * len; + if ((bl->qty > 512 || len > 127) && + v / len != bl->qty - 1) return NULL; /* Overflow */ + if (v > INT_MAX - c) return NULL; /* Overflow */ + c += v; + p = b->data = (unsigned char *) bstr__alloc (c); + if (p == NULL) { + bstr__free (b); + return NULL; + } + v = bl->entry[0]->slen; + bstr__memcpy (p, bl->entry[0]->data, v); + p += v; + for (i = 1; i < bl->qty; i++) { + bstr__memcpy (p, blk, len); + p += len; + v = bl->entry[i]->slen; + if (v) { + bstr__memcpy (p, bl->entry[i]->data, v); + p += v; + } + } + } + b->mlen = c; + b->slen = c-1; + b->data[c-1] = (unsigned char) '\0'; + return b; +} + +/* bstring bjoin (const struct bstrList * bl, const_bstring sep); + * + * Join the entries of a bstrList into one bstring by sequentially + * concatenating them with the sep string in between. If there is an error + * NULL is returned, otherwise a bstring with the correct result is returned. + */ +bstring bjoin (const struct bstrList * bl, const_bstring sep) { + if (sep != NULL && (sep->slen < 0 || sep->data == NULL)) return NULL; + return bjoinblk (bl, sep->data, sep->slen); +} + +#define BSSSC_BUFF_LEN (256) + +/* int bssplitscb (struct bStream * s, const_bstring splitStr, + * int (* cb) (void * parm, int ofs, const_bstring entry), + * void * parm) + * + * Iterate the set of disjoint sequential substrings read from a stream + * divided by any of the characters in splitStr. An empty splitStr causes + * the whole stream to be iterated once. + * + * Note: At the point of calling the cb function, the bStream pointer is + * pointed exactly at the position right after having read the split + * character. The cb function can act on the stream by causing the bStream + * pointer to move, and bssplitscb will continue by starting the next split + * at the position of the pointer after the return from cb. + * + * However, if the cb causes the bStream s to be destroyed then the cb must + * return with a negative value, otherwise bssplitscb will continue in an + * undefined manner. + */ +int bssplitscb (struct bStream * s, const_bstring splitStr, + int (* cb) (void * parm, int ofs, const_bstring entry), void * parm) { +struct charField chrs; +bstring buff; +int i, p, ret; + + if (cb == NULL || s == NULL || s->readFnPtr == NULL || + splitStr == NULL || splitStr->slen < 0) return BSTR_ERR; + + if (NULL == (buff = bfromcstr (""))) return BSTR_ERR; + + if (splitStr->slen == 0) { + while (bsreada (buff, s, BSSSC_BUFF_LEN) >= 0) ; + if ((ret = cb (parm, 0, buff)) > 0) + ret = 0; + } else { + buildCharField (&chrs, splitStr); + ret = p = i = 0; + for (;;) { + if (i >= buff->slen) { + bsreada (buff, s, BSSSC_BUFF_LEN); + if (i >= buff->slen) { + if (0 < (ret = cb (parm, p, buff))) ret = 0; + break; + } + } + if (testInCharField (&chrs, buff->data[i])) { + struct tagbstring t; + unsigned char c; + + blk2tbstr (t, buff->data + i + 1, buff->slen - (i + 1)); + if ((ret = bsunread (s, &t)) < 0) break; + buff->slen = i; + c = buff->data[i]; + buff->data[i] = (unsigned char) '\0'; + if ((ret = cb (parm, p, buff)) < 0) break; + buff->data[i] = c; + buff->slen = 0; + p += i + 1; + i = -1; + } + i++; + } + } + + bdestroy (buff); + return ret; +} + +/* int bssplitstrcb (struct bStream * s, const_bstring splitStr, + * int (* cb) (void * parm, int ofs, const_bstring entry), + * void * parm) + * + * Iterate the set of disjoint sequential substrings read from a stream + * divided by the entire substring splitStr. An empty splitStr causes + * each character of the stream to be iterated. + * + * Note: At the point of calling the cb function, the bStream pointer is + * pointed exactly at the position right after having read the split + * character. The cb function can act on the stream by causing the bStream + * pointer to move, and bssplitscb will continue by starting the next split + * at the position of the pointer after the return from cb. + * + * However, if the cb causes the bStream s to be destroyed then the cb must + * return with a negative value, otherwise bssplitscb will continue in an + * undefined manner. + */ +int bssplitstrcb (struct bStream * s, const_bstring splitStr, + int (* cb) (void * parm, int ofs, const_bstring entry), void * parm) { +bstring buff; +int i, p, ret; + + if (cb == NULL || s == NULL || s->readFnPtr == NULL + || splitStr == NULL || splitStr->slen < 0) return BSTR_ERR; + + if (splitStr->slen == 1) return bssplitscb (s, splitStr, cb, parm); + + if (NULL == (buff = bfromcstr (""))) return BSTR_ERR; + + if (splitStr->slen == 0) { + for (i=0; bsreada (buff, s, BSSSC_BUFF_LEN) >= 0; i++) { + if ((ret = cb (parm, 0, buff)) < 0) { + bdestroy (buff); + return ret; + } + buff->slen = 0; + } + return BSTR_OK; + } else { + ret = p = i = 0; + for (i=p=0;;) { + if ((ret = binstr (buff, 0, splitStr)) >= 0) { + struct tagbstring t; + blk2tbstr (t, buff->data, ret); + i = ret + splitStr->slen; + if ((ret = cb (parm, p, &t)) < 0) break; + p += i; + bdelete (buff, 0, i); + } else { + bsreada (buff, s, BSSSC_BUFF_LEN); + if (bseof (s)) { + if ((ret = cb (parm, p, buff)) > 0) ret = 0; + break; + } + } + } + } + + bdestroy (buff); + return ret; +} + +/* int bstrListCreate (void) + * + * Create a bstrList. + */ +struct bstrList * bstrListCreate (void) { +struct bstrList * sl = + (struct bstrList *) bstr__alloc (sizeof (struct bstrList)); + if (sl) { + sl->entry = (bstring *) bstr__alloc (1*sizeof (bstring)); + if (!sl->entry) { + bstr__free (sl); + sl = NULL; + } else { + sl->qty = 0; + sl->mlen = 1; + } + } + return sl; +} + +/* int bstrListDestroy (struct bstrList * sl) + * + * Destroy a bstrList that has been created by bsplit, bsplits or + * bstrListCreate. + */ +int bstrListDestroy (struct bstrList * sl) { +int i; + if (sl == NULL || sl->qty < 0) return BSTR_ERR; + for (i=0; i < sl->qty; i++) { + if (sl->entry[i]) { + bdestroy (sl->entry[i]); + sl->entry[i] = NULL; + } + } + sl->qty = -1; + sl->mlen = -1; + bstr__free (sl->entry); + sl->entry = NULL; + bstr__free (sl); + return BSTR_OK; +} + +/* int bstrListAlloc (struct bstrList * sl, int msz) + * + * Ensure that there is memory for at least msz number of entries for the + * list. + */ +int bstrListAlloc (struct bstrList * sl, int msz) { +bstring * l; +int smsz; +size_t nsz; + if (!sl || msz <= 0 || !sl->entry || sl->qty < 0 || sl->mlen <= 0 || + sl->qty > sl->mlen) return BSTR_ERR; + if (sl->mlen >= msz) return BSTR_OK; + smsz = snapUpSize (msz); + nsz = ((size_t) smsz) * sizeof (bstring); + if (nsz < (size_t) smsz) return BSTR_ERR; + l = (bstring *) bstr__realloc (sl->entry, nsz); + if (!l) { + smsz = msz; + nsz = ((size_t) smsz) * sizeof (bstring); + l = (bstring *) bstr__realloc (sl->entry, nsz); + if (!l) return BSTR_ERR; + } + sl->mlen = smsz; + sl->entry = l; + return BSTR_OK; +} + +/* int bstrListAllocMin (struct bstrList * sl, int msz) + * + * Try to allocate the minimum amount of memory for the list to include at + * least msz entries or sl->qty whichever is greater. + */ +int bstrListAllocMin (struct bstrList * sl, int msz) { +bstring * l; +size_t nsz; + if (!sl || msz <= 0 || !sl->entry || sl->qty < 0 || sl->mlen <= 0 || + sl->qty > sl->mlen) return BSTR_ERR; + if (msz < sl->qty) msz = sl->qty; + if (sl->mlen == msz) return BSTR_OK; + nsz = ((size_t) msz) * sizeof (bstring); + if (nsz < (size_t) msz) return BSTR_ERR; + l = (bstring *) bstr__realloc (sl->entry, nsz); + if (!l) return BSTR_ERR; + sl->mlen = msz; + sl->entry = l; + return BSTR_OK; +} + +/* int bsplitcb (const_bstring str, unsigned char splitChar, int pos, + * int (* cb) (void * parm, int ofs, int len), void * parm) + * + * Iterate the set of disjoint sequential substrings over str divided by the + * character in splitChar. + * + * Note: Non-destructive modification of str from within the cb function + * while performing this split is not undefined. bsplitcb behaves in + * sequential lock step with calls to cb. I.e., after returning from a cb + * that return a non-negative integer, bsplitcb continues from the position + * 1 character after the last detected split character and it will halt + * immediately if the length of str falls below this point. However, if the + * cb function destroys str, then it *must* return with a negative value, + * otherwise bsplitcb will continue in an undefined manner. + */ +int bsplitcb (const_bstring str, unsigned char splitChar, int pos, + int (* cb) (void * parm, int ofs, int len), void * parm) { +int i, p, ret; + + if (cb == NULL || str == NULL || pos < 0 || pos > str->slen) + return BSTR_ERR; + + p = pos; + do { + for (i=p; i < str->slen; i++) { + if (str->data[i] == splitChar) break; + } + if ((ret = cb (parm, p, i - p)) < 0) return ret; + p = i + 1; + } while (p <= str->slen); + return BSTR_OK; +} + +/* int bsplitscb (const_bstring str, const_bstring splitStr, int pos, + * int (* cb) (void * parm, int ofs, int len), void * parm) + * + * Iterate the set of disjoint sequential substrings over str divided by any + * of the characters in splitStr. An empty splitStr causes the whole str to + * be iterated once. + * + * Note: Non-destructive modification of str from within the cb function + * while performing this split is not undefined. bsplitscb behaves in + * sequential lock step with calls to cb. I.e., after returning from a cb + * that return a non-negative integer, bsplitscb continues from the position + * 1 character after the last detected split character and it will halt + * immediately if the length of str falls below this point. However, if the + * cb function destroys str, then it *must* return with a negative value, + * otherwise bsplitscb will continue in an undefined manner. + */ +int bsplitscb (const_bstring str, const_bstring splitStr, int pos, + int (* cb) (void * parm, int ofs, int len), void * parm) { +struct charField chrs; +int i, p, ret; + + if (cb == NULL || str == NULL || pos < 0 || pos > str->slen + || splitStr == NULL || splitStr->slen < 0) return BSTR_ERR; + if (splitStr->slen == 0) { + if ((ret = cb (parm, 0, str->slen)) > 0) ret = 0; + return ret; + } + + if (splitStr->slen == 1) + return bsplitcb (str, splitStr->data[0], pos, cb, parm); + + buildCharField (&chrs, splitStr); + + p = pos; + do { + for (i=p; i < str->slen; i++) { + if (testInCharField (&chrs, str->data[i])) break; + } + if ((ret = cb (parm, p, i - p)) < 0) return ret; + p = i + 1; + } while (p <= str->slen); + return BSTR_OK; +} + +/* int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos, + * int (* cb) (void * parm, int ofs, int len), void * parm) + * + * Iterate the set of disjoint sequential substrings over str divided by the + * substring splitStr. An empty splitStr causes the whole str to be + * iterated once. + * + * Note: Non-destructive modification of str from within the cb function + * while performing this split is not undefined. bsplitstrcb behaves in + * sequential lock step with calls to cb. I.e., after returning from a cb + * that return a non-negative integer, bsplitscb continues from the position + * 1 character after the last detected split character and it will halt + * immediately if the length of str falls below this point. However, if the + * cb function destroys str, then it *must* return with a negative value, + * otherwise bsplitscb will continue in an undefined manner. + */ +int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos, + int (* cb) (void * parm, int ofs, int len), void * parm) { +int i, p, ret; + + if (cb == NULL || str == NULL || pos < 0 || pos > str->slen + || splitStr == NULL || splitStr->slen < 0) return BSTR_ERR; + + if (0 == splitStr->slen) { + for (i=pos; i < str->slen; i++) { + if ((ret = cb (parm, i, 1)) < 0) return ret; + } + return BSTR_OK; + } + + if (splitStr->slen == 1) + return bsplitcb (str, splitStr->data[0], pos, cb, parm); + + for (i=p=pos; i <= str->slen - splitStr->slen; i++) { + if (0 == bstr__memcmp (splitStr->data, str->data + i, + splitStr->slen)) { + if ((ret = cb (parm, p, i - p)) < 0) return ret; + i += splitStr->slen; + p = i; + } + } + if ((ret = cb (parm, p, str->slen - p)) < 0) return ret; + return BSTR_OK; +} + +struct genBstrList { + bstring b; + struct bstrList * bl; +}; + +static int bscb (void * parm, int ofs, int len) { +struct genBstrList * g = (struct genBstrList *) parm; + if (g->bl->qty >= g->bl->mlen) { + int mlen = g->bl->mlen * 2; + bstring * tbl; + + while (g->bl->qty >= mlen) { + if (mlen < g->bl->mlen) return BSTR_ERR; + mlen += mlen; + } + + tbl = (bstring *) bstr__realloc (g->bl->entry, + sizeof (bstring) * mlen); + if (tbl == NULL) return BSTR_ERR; + + g->bl->entry = tbl; + g->bl->mlen = mlen; + } + + g->bl->entry[g->bl->qty] = bmidstr (g->b, ofs, len); + g->bl->qty++; + return BSTR_OK; +} + +/* struct bstrList * bsplit (const_bstring str, unsigned char splitChar) + * + * Create an array of sequential substrings from str divided by the character + * splitChar. + */ +struct bstrList * bsplit (const_bstring str, unsigned char splitChar) { +struct genBstrList g; + + if (str == NULL || str->data == NULL || str->slen < 0) return NULL; + + g.bl = (struct bstrList *) bstr__alloc (sizeof (struct bstrList)); + if (g.bl == NULL) return NULL; + g.bl->mlen = 4; + g.bl->entry = (bstring *) bstr__alloc (g.bl->mlen * sizeof (bstring)); + if (NULL == g.bl->entry) { + bstr__free (g.bl); + return NULL; + } + + g.b = (bstring) str; + g.bl->qty = 0; + if (bsplitcb (str, splitChar, 0, bscb, &g) < 0) { + bstrListDestroy (g.bl); + return NULL; + } + return g.bl; +} + +/* struct bstrList * bsplitstr (const_bstring str, const_bstring splitStr) + * + * Create an array of sequential substrings from str divided by the entire + * substring splitStr. + */ +struct bstrList * bsplitstr (const_bstring str, const_bstring splitStr) { +struct genBstrList g; + + if (str == NULL || str->data == NULL || str->slen < 0) return NULL; + + g.bl = (struct bstrList *) bstr__alloc (sizeof (struct bstrList)); + if (g.bl == NULL) return NULL; + g.bl->mlen = 4; + g.bl->entry = (bstring *) bstr__alloc (g.bl->mlen * sizeof (bstring)); + if (NULL == g.bl->entry) { + bstr__free (g.bl); + return NULL; + } + + g.b = (bstring) str; + g.bl->qty = 0; + if (bsplitstrcb (str, splitStr, 0, bscb, &g) < 0) { + bstrListDestroy (g.bl); + return NULL; + } + return g.bl; +} + +/* struct bstrList * bsplits (const_bstring str, bstring splitStr) + * + * Create an array of sequential substrings from str divided by any of the + * characters in splitStr. An empty splitStr causes a single entry bstrList + * containing a copy of str to be returned. + */ +struct bstrList * bsplits (const_bstring str, const_bstring splitStr) { +struct genBstrList g; + + if ( str == NULL || str->slen < 0 || str->data == NULL || + splitStr == NULL || splitStr->slen < 0 || splitStr->data == NULL) + return NULL; + + g.bl = (struct bstrList *) bstr__alloc (sizeof (struct bstrList)); + if (g.bl == NULL) return NULL; + g.bl->mlen = 4; + g.bl->entry = (bstring *) bstr__alloc (g.bl->mlen * sizeof (bstring)); + if (NULL == g.bl->entry) { + bstr__free (g.bl); + return NULL; + } + g.b = (bstring) str; + g.bl->qty = 0; + + if (bsplitscb (str, splitStr, 0, bscb, &g) < 0) { + bstrListDestroy (g.bl); + return NULL; + } + return g.bl; +} + +#if defined (__TURBOC__) && !defined (__BORLANDC__) +# ifndef BSTRLIB_NOVSNP +# define BSTRLIB_NOVSNP +# endif +#endif + +/* Give WATCOM C/C++, MSVC some latitude for their non-support of vsnprintf */ +#if defined(__WATCOMC__) || defined(_MSC_VER) +#define exvsnprintf(r,b,n,f,a) {r = _vsnprintf (b,n,f,a);} +#else +#ifdef BSTRLIB_NOVSNP +/* This is just a hack. If you are using a system without a vsnprintf, it is + not recommended that bformat be used at all. */ +#define exvsnprintf(r,b,n,f,a) {vsprintf (b,f,a); r = -1;} +#define START_VSNBUFF (256) +#else + +#if defined(__GNUC__) && !defined(__APPLE__) +/* Something is making gcc complain about this prototype not being here, so + I've just gone ahead and put it in. */ +extern int vsnprintf (char *buf, size_t count, const char *format, va_list arg); +#endif + +#define exvsnprintf(r,b,n,f,a) {r = vsnprintf (b,n,f,a);} +#endif +#endif + +#if !defined (BSTRLIB_NOVSNP) + +#ifndef START_VSNBUFF +#define START_VSNBUFF (16) +#endif + +/* On IRIX vsnprintf returns n-1 when the operation would overflow the target + buffer, WATCOM and MSVC both return -1, while C99 requires that the + returned value be exactly what the length would be if the buffer would be + large enough. This leads to the idea that if the return value is larger + than n, then changing n to the return value will reduce the number of + iterations required. */ + +/* int bformata (bstring b, const char * fmt, ...) + * + * After the first parameter, it takes the same parameters as printf (), but + * rather than outputting results to stdio, it appends the results to + * a bstring which contains what would have been output. Note that if there + * is an early generation of a '\0' character, the bstring will be truncated + * to this end point. + */ +int bformata (bstring b, const char * fmt, ...) { +va_list arglist; +bstring buff; +int n, r; + + if (b == NULL || fmt == NULL || b->data == NULL || b->mlen <= 0 + || b->slen < 0 || b->slen > b->mlen) return BSTR_ERR; + + /* Since the length is not determinable beforehand, a search is + performed using the truncating "vsnprintf" call (to avoid buffer + overflows) on increasing potential sizes for the output result. */ + + if ((n = (int) (2*strlen (fmt))) < START_VSNBUFF) n = START_VSNBUFF; + if (NULL == (buff = bfromcstralloc (n + 2, ""))) { + n = 1; + if (NULL == (buff = bfromcstralloc (n + 2, ""))) return BSTR_ERR; + } + + for (;;) { + va_start (arglist, fmt); + exvsnprintf (r, (char *) buff->data, n + 1, fmt, arglist); + va_end (arglist); + + buff->data[n] = (unsigned char) '\0'; + buff->slen = (int) (strlen) ((char *) buff->data); + + if (buff->slen < n) break; + + if (r > n) n = r; else n += n; + + if (BSTR_OK != balloc (buff, n + 2)) { + bdestroy (buff); + return BSTR_ERR; + } + } + + r = bconcat (b, buff); + bdestroy (buff); + return r; +} + +/* int bassignformat (bstring b, const char * fmt, ...) + * + * After the first parameter, it takes the same parameters as printf (), but + * rather than outputting results to stdio, it outputs the results to + * the bstring parameter b. Note that if there is an early generation of a + * '\0' character, the bstring will be truncated to this end point. + */ +int bassignformat (bstring b, const char * fmt, ...) { +va_list arglist; +bstring buff; +int n, r; + + if (b == NULL || fmt == NULL || b->data == NULL || b->mlen <= 0 + || b->slen < 0 || b->slen > b->mlen) return BSTR_ERR; + + /* Since the length is not determinable beforehand, a search is + performed using the truncating "vsnprintf" call (to avoid buffer + overflows) on increasing potential sizes for the output result. */ + + if ((n = (int) (2*strlen (fmt))) < START_VSNBUFF) n = START_VSNBUFF; + if (NULL == (buff = bfromcstralloc (n + 2, ""))) { + n = 1; + if (NULL == (buff = bfromcstralloc (n + 2, ""))) return BSTR_ERR; + } + + for (;;) { + va_start (arglist, fmt); + exvsnprintf (r, (char *) buff->data, n + 1, fmt, arglist); + va_end (arglist); + + buff->data[n] = (unsigned char) '\0'; + buff->slen = (int) (strlen) ((char *) buff->data); + + if (buff->slen < n) break; + + if (r > n) n = r; else n += n; + + if (BSTR_OK != balloc (buff, n + 2)) { + bdestroy (buff); + return BSTR_ERR; + } + } + + r = bassign (b, buff); + bdestroy (buff); + return r; +} + +/* bstring bformat (const char * fmt, ...) + * + * Takes the same parameters as printf (), but rather than outputting results + * to stdio, it forms a bstring which contains what would have been output. + * Note that if there is an early generation of a '\0' character, the + * bstring will be truncated to this end point. + */ +bstring bformat (const char * fmt, ...) { +va_list arglist; +bstring buff; +int n, r; + + if (fmt == NULL) return NULL; + + /* Since the length is not determinable beforehand, a search is + performed using the truncating "vsnprintf" call (to avoid buffer + overflows) on increasing potential sizes for the output result. */ + + if ((n = (int) (2*strlen (fmt))) < START_VSNBUFF) n = START_VSNBUFF; + if (NULL == (buff = bfromcstralloc (n + 2, ""))) { + n = 1; + if (NULL == (buff = bfromcstralloc (n + 2, ""))) return NULL; + } + + for (;;) { + va_start (arglist, fmt); + exvsnprintf (r, (char *) buff->data, n + 1, fmt, arglist); + va_end (arglist); + + buff->data[n] = (unsigned char) '\0'; + buff->slen = (int) (strlen) ((char *) buff->data); + + if (buff->slen < n) break; + + if (r > n) n = r; else n += n; + + if (BSTR_OK != balloc (buff, n + 2)) { + bdestroy (buff); + return NULL; + } + } + + return buff; +} + +/* int bvcformata (bstring b, int count, const char * fmt, va_list arglist) + * + * The bvcformata function formats data under control of the format control + * string fmt and attempts to append the result to b. The fmt parameter is + * the same as that of the printf function. The variable argument list is + * replaced with arglist, which has been initialized by the va_start macro. + * The size of the output is upper bounded by count. If the required output + * exceeds count, the string b is not augmented with any contents and a value + * below BSTR_ERR is returned. If a value below -count is returned then it + * is recommended that the negative of this value be used as an update to the + * count in a subsequent pass. On other errors, such as running out of + * memory, parameter errors or numeric wrap around BSTR_ERR is returned. + * BSTR_OK is returned when the output is successfully generated and + * appended to b. + * + * Note: There is no sanity checking of arglist, and this function is + * destructive of the contents of b from the b->slen point onward. If there + * is an early generation of a '\0' character, the bstring will be truncated + * to this end point. + */ +int bvcformata (bstring b, int count, const char * fmt, va_list arg) { +int n, r, l; + + if (b == NULL || fmt == NULL || count <= 0 || b->data == NULL + || b->mlen <= 0 || b->slen < 0 || b->slen > b->mlen) return BSTR_ERR; + + if (count > (n = b->slen + count) + 2) return BSTR_ERR; + if (BSTR_OK != balloc (b, n + 2)) return BSTR_ERR; + + exvsnprintf (r, (char *) b->data + b->slen, count + 2, fmt, arg); + b->data[b->slen + count + 2] = '\0'; + + /* Did the operation complete successfully within bounds? */ + + if (n >= (l = b->slen + (int) (strlen) ((char *) b->data + b->slen))) { + b->slen = l; + return BSTR_OK; + } + + /* Abort, since the buffer was not large enough. The return value + tries to help set what the retry length should be. */ + + b->data[b->slen] = '\0'; + if (r > count+1) { + l = r; + } else { + if (count > INT_MAX / 2) + l = INT_MAX; + else + l = count + count; + } + n = -l; + if (n > BSTR_ERR-1) n = BSTR_ERR-1; + return n; +} + +#endif diff --git a/src/bstrlib.h b/src/bstrlib.h @@ -0,0 +1,332 @@ +/* SPDX-License-Identifier: BSD-3-Clause */ +/* + * Copyright © 2014 Paul Hsieh + * Copyright © 2020 rsiddharth + */ + +/* + * This is a slightly modified version of bstrlib.h from the bstrlib + * library (https://github.com/websnarf/bstrlib/releases/tag/v1.0.0). + */ + +/* + * This source file is part of the bstring string library. This code was + * written by Paul Hsieh in 2002-2015, and is covered by the BSD open source + * license and the GPL. Refer to the accompanying documentation for details + * on usage and license. + */ + +/* + * bstrlib.h + * + * This file is the interface for the core bstring functions. + */ + +#ifndef BSTRLIB_INCLUDE +#define BSTRLIB_INCLUDE + +#ifdef __cplusplus +extern "C" { +#endif + +#include <stdarg.h> +#include <string.h> +#include <limits.h> +#include <ctype.h> + +#if !defined (BSTRLIB_VSNP_OK) && !defined (BSTRLIB_NOVSNP) +# if defined (__TURBOC__) && !defined (__BORLANDC__) +# define BSTRLIB_NOVSNP +# endif +#endif + +#define BSTR_ERR (-1) +#define BSTR_OK (0) +#define BSTR_BS_BUFF_LENGTH_GET (0) + +typedef struct tagbstring * bstring; +typedef const struct tagbstring * const_bstring; + +/* Version */ +#define BSTR_VER_MAJOR 1 +#define BSTR_VER_MINOR 0 +#define BSTR_VER_UPDATE 0 + +/* Copy functions */ +#define cstr2bstr bfromcstr +extern bstring bfromcstr (const char * str); +extern bstring bfromcstralloc (int mlen, const char * str); +extern bstring bfromcstrrangealloc (int minl, int maxl, const char* str); +extern bstring blk2bstr (const void * blk, int len); +extern char * bstr2cstr (const_bstring s, char z); +extern int bcstrfree (char * s); +extern bstring bstrcpy (const_bstring b1); +extern int bassign (bstring a, const_bstring b); +extern int bassignmidstr (bstring a, const_bstring b, int left, int len); +extern int bassigncstr (bstring a, const char * str); +extern int bassignblk (bstring a, const void * s, int len); + +/* Destroy function */ +extern int bdestroy (bstring b); + +/* Space allocation hinting functions */ +extern int balloc (bstring s, int len); +extern int ballocmin (bstring b, int len); + +/* Substring extraction */ +extern bstring bmidstr (const_bstring b, int left, int len); + +/* Various standard manipulations */ +extern int bconcat (bstring b0, const_bstring b1); +extern int bconchar (bstring b0, char c); +extern int bcatcstr (bstring b, const char * s); +extern int bcatblk (bstring b, const void * s, int len); +extern int binsert (bstring s1, int pos, const_bstring s2, unsigned char fill); +extern int binsertblk (bstring s1, int pos, const void * s2, int len, unsigned char fill); +extern int binsertch (bstring s1, int pos, int len, unsigned char fill); +extern int breplace (bstring b1, int pos, int len, const_bstring b2, unsigned char fill); +extern int bdelete (bstring s1, int pos, int len); +extern int bsetstr (bstring b0, int pos, const_bstring b1, unsigned char fill); +extern int btrunc (bstring b, int n); + +/* Scan/search functions */ +extern int bstricmp (const_bstring b0, const_bstring b1); +extern int bstrnicmp (const_bstring b0, const_bstring b1, int n); +extern int biseqcaseless (const_bstring b0, const_bstring b1); +extern int biseqcaselessblk (const_bstring b, const void * blk, int len); +extern int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len); +extern int biseq (const_bstring b0, const_bstring b1); +extern int biseqblk (const_bstring b, const void * blk, int len); +extern int bisstemeqblk (const_bstring b0, const void * blk, int len); +extern int biseqcstr (const_bstring b, const char * s); +extern int biseqcstrcaseless (const_bstring b, const char * s); +extern int bstrcmp (const_bstring b0, const_bstring b1); +extern int bstrncmp (const_bstring b0, const_bstring b1, int n); +extern int binstr (const_bstring s1, int pos, const_bstring s2); +extern int binstrr (const_bstring s1, int pos, const_bstring s2); +extern int binstrcaseless (const_bstring s1, int pos, const_bstring s2); +extern int binstrrcaseless (const_bstring s1, int pos, const_bstring s2); +extern int bstrchrp (const_bstring b, int c, int pos); +extern int bstrrchrp (const_bstring b, int c, int pos); +#define bstrchr(b,c) bstrchrp ((b), (c), 0) +#define bstrrchr(b,c) bstrrchrp ((b), (c), blength(b)-1) +extern int binchr (const_bstring b0, int pos, const_bstring b1); +extern int binchrr (const_bstring b0, int pos, const_bstring b1); +extern int bninchr (const_bstring b0, int pos, const_bstring b1); +extern int bninchrr (const_bstring b0, int pos, const_bstring b1); +extern int bfindreplace (bstring b, const_bstring find, const_bstring repl, int pos); +extern int bfindreplacecaseless (bstring b, const_bstring find, const_bstring repl, int pos); + +/* List of string container functions */ +struct bstrList { + int qty, mlen; + bstring * entry; +}; +extern struct bstrList * bstrListCreate (void); +extern int bstrListDestroy (struct bstrList * sl); +extern int bstrListAlloc (struct bstrList * sl, int msz); +extern int bstrListAllocMin (struct bstrList * sl, int msz); + +/* String split and join functions */ +extern struct bstrList * bsplit (const_bstring str, unsigned char splitChar); +extern struct bstrList * bsplits (const_bstring str, const_bstring splitStr); +extern struct bstrList * bsplitstr (const_bstring str, const_bstring splitStr); +extern bstring bjoin (const struct bstrList * bl, const_bstring sep); +extern bstring bjoinblk (const struct bstrList * bl, const void * s, int len); +extern int bsplitcb (const_bstring str, unsigned char splitChar, int pos, + int (* cb) (void * parm, int ofs, int len), void * parm); +extern int bsplitscb (const_bstring str, const_bstring splitStr, int pos, + int (* cb) (void * parm, int ofs, int len), void * parm); +extern int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos, + int (* cb) (void * parm, int ofs, int len), void * parm); + +/* Miscellaneous functions */ +extern int bpattern (bstring b, int len); +extern int btoupper (bstring b); +extern int btolower (bstring b); +extern int bltrimws (bstring b); +extern int brtrimws (bstring b); +extern int btrimws (bstring b); + +#if !defined (BSTRLIB_NOVSNP) +extern bstring bformat (const char * fmt, ...); +extern int bformata (bstring b, const char * fmt, ...); +extern int bassignformat (bstring b, const char * fmt, ...); +extern int bvcformata (bstring b, int count, const char * fmt, va_list arglist); + +#define bvformata(ret, b, fmt, lastarg) { \ +bstring bstrtmp_b = (b); \ +const char * bstrtmp_fmt = (fmt); \ +int bstrtmp_r = BSTR_ERR, bstrtmp_sz = 16; \ + for (;;) { \ + va_list bstrtmp_arglist; \ + va_start (bstrtmp_arglist, lastarg); \ + bstrtmp_r = bvcformata (bstrtmp_b, bstrtmp_sz, bstrtmp_fmt, bstrtmp_arglist); \ + va_end (bstrtmp_arglist); \ + if (bstrtmp_r >= 0) { /* Everything went ok */ \ + bstrtmp_r = BSTR_OK; \ + break; \ + } else if (-bstrtmp_r <= bstrtmp_sz) { /* A real error? */ \ + bstrtmp_r = BSTR_ERR; \ + break; \ + } \ + bstrtmp_sz = -bstrtmp_r; /* Doubled or target size */ \ + } \ + ret = bstrtmp_r; \ +} + +#endif + +typedef int (*bNgetc) (void *parm); +typedef size_t (* bNread) (void *buff, size_t elsize, size_t nelem, void *parm); + +/* Input functions */ +extern bstring bgets (bNgetc getcPtr, void * parm, char terminator); +extern bstring bread (bNread readPtr, void * parm); +extern int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator); +extern int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator); +extern int breada (bstring b, bNread readPtr, void * parm); + +/* Stream functions */ +extern struct bStream * bsopen (bNread readPtr, void * parm); +extern void * bsclose (struct bStream * s); +extern int bsbufflength (struct bStream * s, int sz); +extern int bsreadln (bstring b, struct bStream * s, char terminator); +extern int bsreadlns (bstring r, struct bStream * s, const_bstring term); +extern int bsread (bstring b, struct bStream * s, int n); +extern int bsreadlna (bstring b, struct bStream * s, char terminator); +extern int bsreadlnsa (bstring r, struct bStream * s, const_bstring term); +extern int bsreada (bstring b, struct bStream * s, int n); +extern int bsunread (struct bStream * s, const_bstring b); +extern int bspeek (bstring r, const struct bStream * s); +extern int bssplitscb (struct bStream * s, const_bstring splitStr, + int (* cb) (void * parm, int ofs, const_bstring entry), void * parm); +extern int bssplitstrcb (struct bStream * s, const_bstring splitStr, + int (* cb) (void * parm, int ofs, const_bstring entry), void * parm); +extern int bseof (const struct bStream * s); + +struct tagbstring { + int mlen; + int slen; + unsigned char * data; +}; + +/* Accessor macros */ +#define blengthe(b, e) (((b) == (void *)0 || (b)->slen < 0) ? (int)(e) : ((b)->slen)) +#define blength(b) (blengthe ((b), 0)) +#define bdataofse(b, o, e) (((b) == (void *)0 || (b)->data == (void*)0) ? (char *)(e) : ((char *)(b)->data) + (o)) +#define bdataofs(b, o) (bdataofse ((b), (o), (void *)0)) +#define bdatae(b, e) (bdataofse (b, 0, e)) +#define bdata(b) (bdataofs (b, 0)) +#define bchare(b, p, e) ((((unsigned)(p)) < (unsigned)blength(b)) ? ((b)->data[(p)]) : (e)) +#define bchar(b, p) bchare ((b), (p), '\0') + +/* Static constant string initialization macro */ +#define bsStaticMlen(q,m) {(m), (int) sizeof(q)-1, (unsigned char *) ("" q "")} +#if defined(_MSC_VER) +# define bsStatic(q) bsStaticMlen(q,-32) +#endif +#ifndef bsStatic +# define bsStatic(q) bsStaticMlen(q,-__LINE__) +#endif + +/* Static constant block parameter pair */ +#define bsStaticBlkParms(q) ((void *)("" q "")), ((int) sizeof(q)-1) + +#define bcatStatic(b,s) ((bcatblk)((b), bsStaticBlkParms(s))) +#define bfromStatic(s) ((blk2bstr)(bsStaticBlkParms(s))) +#define bassignStatic(b,s) ((bassignblk)((b), bsStaticBlkParms(s))) +#define binsertStatic(b,p,s,f) ((binsertblk)((b), (p), bsStaticBlkParms(s), (f))) +#define bjoinStatic(b,s) ((bjoinblk)((b), bsStaticBlkParms(s))) +#define biseqStatic(b,s) ((biseqblk)((b), bsStaticBlkParms(s))) +#define bisstemeqStatic(b,s) ((bisstemeqblk)((b), bsStaticBlkParms(s))) +#define biseqcaselessStatic(b,s) ((biseqcaselessblk)((b), bsStaticBlkParms(s))) +#define bisstemeqcaselessStatic(b,s) ((bisstemeqcaselessblk)((b), bsStaticBlkParms(s))) + +/* Reference building macros */ +#define cstr2tbstr btfromcstr +#define btfromcstr(t,s) { \ + (t).data = (unsigned char *) (s); \ + (t).slen = ((t).data) ? ((int) (strlen) ((char *)(t).data)) : 0; \ + (t).mlen = -1; \ +} +#define blk2tbstr(t,s,l) { \ + (t).data = (unsigned char *) (s); \ + (t).slen = l; \ + (t).mlen = -1; \ +} +#define btfromblk(t,s,l) blk2tbstr(t,s,l) +#define bmid2tbstr(t,b,p,l) { \ + const_bstring bstrtmp_s = (b); \ + if (bstrtmp_s && bstrtmp_s->data && bstrtmp_s->slen >= 0) { \ + int bstrtmp_left = (p); \ + int bstrtmp_len = (l); \ + if (bstrtmp_left < 0) { \ + bstrtmp_len += bstrtmp_left; \ + bstrtmp_left = 0; \ + } \ + if (bstrtmp_len > bstrtmp_s->slen - bstrtmp_left) \ + bstrtmp_len = bstrtmp_s->slen - bstrtmp_left; \ + if (bstrtmp_len <= 0) { \ + (t).data = (unsigned char *)""; \ + (t).slen = 0; \ + } else { \ + (t).data = bstrtmp_s->data + bstrtmp_left; \ + (t).slen = bstrtmp_len; \ + } \ + } else { \ + (t).data = (unsigned char *)""; \ + (t).slen = 0; \ + } \ + (t).mlen = -__LINE__; \ +} +#define btfromblkltrimws(t,s,l) { \ + int bstrtmp_idx = 0, bstrtmp_len = (l); \ + unsigned char * bstrtmp_s = (s); \ + if (bstrtmp_s && bstrtmp_len >= 0) { \ + for (; bstrtmp_idx < bstrtmp_len; bstrtmp_idx++) { \ + if (!isspace (bstrtmp_s[bstrtmp_idx])) break; \ + } \ + } \ + (t).data = bstrtmp_s + bstrtmp_idx; \ + (t).slen = bstrtmp_len - bstrtmp_idx; \ + (t).mlen = -__LINE__; \ +} +#define btfromblkrtrimws(t,s,l) { \ + int bstrtmp_len = (l) - 1; \ + unsigned char * bstrtmp_s = (s); \ + if (bstrtmp_s && bstrtmp_len >= 0) { \ + for (; bstrtmp_len >= 0; bstrtmp_len--) { \ + if (!isspace (bstrtmp_s[bstrtmp_len])) break; \ + } \ + } \ + (t).data = bstrtmp_s; \ + (t).slen = bstrtmp_len + 1; \ + (t).mlen = -__LINE__; \ +} +#define btfromblktrimws(t,s,l) { \ + int bstrtmp_idx = 0, bstrtmp_len = (l) - 1; \ + unsigned char * bstrtmp_s = (s); \ + if (bstrtmp_s && bstrtmp_len >= 0) { \ + for (; bstrtmp_idx <= bstrtmp_len; bstrtmp_idx++) { \ + if (!isspace (bstrtmp_s[bstrtmp_idx])) break; \ + } \ + for (; bstrtmp_len >= bstrtmp_idx; bstrtmp_len--) { \ + if (!isspace (bstrtmp_s[bstrtmp_len])) break; \ + } \ + } \ + (t).data = bstrtmp_s + bstrtmp_idx; \ + (t).slen = bstrtmp_len + 1 - bstrtmp_idx; \ + (t).mlen = -__LINE__; \ +} + +/* Write protection macros */ +#define bwriteprotect(t) { if ((t).mlen >= 0) (t).mlen = -1; } +#define bwriteallow(t) { if ((t).mlen == -1) (t).mlen = (t).slen + ((t).slen == 0); } +#define biswriteprotected(t) ((t).mlen <= 0) + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/darray.c b/src/darray.c @@ -0,0 +1,198 @@ +/* SPDX-License-Identifier: BSD-3-Clause */ +/* + * Copyright © 2010, Zed A. Shaw. + * Copyright © 2020 rsiddharth <s@ricketyspace.net> + */ + +#include <darray.h> +#include <darray_algos.h> +#include <assert.h> + +DArray *DArray_create(size_t element_size, size_t initial_max) +{ + DArray *array = malloc(sizeof(DArray)); + check_mem(array); + array->max = initial_max; + check(array->max > 0, "You must set initial_max > 0."); + + array->contents = calloc(initial_max, sizeof(void *)); + check_mem(array->contents); + + array->end = 0; + array->element_size = element_size; + array->expand_rate = DEFAULT_EXPAND_RATE; + + return array; + + error: + if (array) + free(array); + return NULL; +} + +void DArray_clear(DArray *array) +{ + check(array != NULL, "array cannot be NULL"); + + int i = 0; + if (array->element_size > 0) { + for (i = 0; i < array->max; i++) { + if (array->contents[i] != NULL) { + free(array->contents[i]); + } + } + } + + error: + return; +} + +static inline int DArray_resize(DArray *array, size_t newsize) +{ + check(array != NULL, "array cannot be NULL"); + check((int) newsize >= array->end, "newsize must be >= end."); + + array->max = newsize; + check(array->max > 0, "The newsize must be > 0."); + + void *contents = realloc(array->contents, + array->max * sizeof(void *)); + // Check contents and assume realloc doesn't harm the original on error. + + check_mem(contents); + + array->contents = contents; + + return 0; + error: + return -1; +} + +int DArray_expand(DArray *array) +{ + size_t old_max = array->max; + check(DArray_resize(array, array->max + array->expand_rate) == 0, + "Failed to expand array to new size: %d", + array->max + (int) array->expand_rate); + + memset(array->contents + old_max, 0, (array->expand_rate) * sizeof(void *)); + + return 0; + + error: + return -1; +} + +int DArray_contract(DArray *array) +{ + check(array != NULL, "array cannot be NULL"); + + int new_size = array->end < (int) array->expand_rate ? + (int) array->expand_rate : array->end; + + return DArray_resize(array, new_size + 1); + error: + return -1; +} + +void DArray_destroy(DArray *array) +{ + if (array) { + if (array->contents) + free(array->contents); + free(array); + } +} + +void DArray_clear_destroy(DArray *array) +{ + DArray_clear(array); + DArray_destroy(array); +} + +int DArray_push(DArray *array, void *el) +{ + check(array != NULL, "array cannot be NULL"); + + array->contents[array->end] = el; + array->end++; + + if (DArray_end(array) >= DArray_max(array)) { + return DArray_expand(array); + } else { + return 0; + } + + error: + return -1; +} + +void *DArray_pop(DArray *array) +{ + check(array != NULL, "array cannot be NULL"); + check(array->end - 1 >= 0, "Attempt to pop from empty array."); + + void *el = DArray_remove(array, array->end - 1); + array->end--; + + if (DArray_end(array) > (int)array->expand_rate + && DArray_end(array) % array->expand_rate) { + DArray_contract(array); + } + + return el; + error: + return NULL; +} + +int DArray_sort_add(DArray *array, void *el, DArray_compare cmp) +{ + int rc; + rc = DArray_push(array, el); + check(rc == 0, "Error pushing element."); + + // sort the array. + rc = DArray_heapsort(array, cmp); + check(rc == 0, "Error sorting array."); + + return 0; + error: + return -1; +} + +DArray *DArray_shallow_copy(DArray *array) +{ + DArray *copy = DArray_create(array->element_size, array->max); + check(copy != NULL, "Error creating DArray copy."); + + int i = 0; + for (i = 0; i < array->max; i++) { + copy->contents[i] = array->contents[i]; + } + + return copy; + error: + return NULL; +} + +int DArray_find(DArray *array, void *el, DArray_compare cmp) +{ + int low = 0; + int high = DArray_end(array) - 1; + void *c = NULL; + + while (low <= high) { + int middle = low + (high - low) / 2; + c = DArray_get(array, middle); + + if (cmp(&el, &c) < 0) { + high = middle - 1; + } else if (cmp(&el, &c) > 0) { + low = middle + 1; + } else { + return middle; + } + } + + return -1; +} diff --git a/src/darray.h b/src/darray.h @@ -0,0 +1,126 @@ +/* SPDX-License-Identifier: BSD-3-Clause */ +/* + * Copyright © 2010, Zed A. Shaw. + * Copyright © 2020 rsiddharth <s@ricketyspace.net> + */ + +#ifndef _DArray_h +#define _DArray_h +#include <stdlib.h> +#include <assert.h> +#include <dbg.h> + +typedef struct DArray { + int end; + int max; + size_t element_size; + size_t expand_rate; + void **contents; +} DArray; + +typedef int (*DArray_compare) (const void *a, const void *b); + +DArray *DArray_create(size_t element_size, size_t initial_max); + +void DArray_destroy(DArray *array); + +void DArray_clear(DArray *array); + +int DArray_expand(DArray *array); + +int DArray_contract(DArray *array); + +int DArray_push(DArray *array, void *el); + +void *DArray_pop(DArray *array); + +int DArray_sort_add(DArray *array, void *el, DArray_compare cmp); + +int DArray_find(DArray *array, void *el, DArray_compare cmp); + +void DArray_clear_destroy(DArray *array); + +/** + * Creates a new DArray using `DArray_create` and copies the + * `contents` from array to the newly created DArray. + * + * Returns newly created DArray. + */ +DArray *DArray_shallow_copy(DArray *array); + +#define DArray_last(A) ((A)->contents[(A)->end - 1]) +#define DArray_first(A) ((A)->contents[0]) +#define DArray_end(A) ((A)->end) +#define DArray_count(A) DArray_end(A) +#define DArray_max(A) ((A)->max) + +#define DEFAULT_EXPAND_RATE 300 + +static inline int DArray_set(DArray *array, int i, void *el) +{ + check(array != NULL, "array cannot be NULL"); + check(i >= 0, "i cannot be lesser than 0"); + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-overflow" + check(i < array->max, "darray attempt to set past max"); +#pragma GCC diagnostic pop + + if (i > array->end) + array->end = i; + + array->contents[i] = el; + return i; + error: + return -1; +} + +static inline void *DArray_get(DArray *array, int i) +{ + check(array != NULL, "array cannot be NULL"); + check(i >= 0, "i cannot be lesser than 0"); + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-overflow" + check(i < array->max, "darray attempt to get past max"); +#pragma GCC diagnostic pop + + return array->contents[i]; + error: + return NULL; +} + +static inline void *DArray_remove(DArray *array, int i) +{ + check(array != NULL, "array cannot be NULL"); + check(i >= 0, "i cannot be lesser than 0"); + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-overflow" + check(i < array->max, "darray attempt to get past max"); +#pragma GCC diagnostic pop + + void *el = array->contents[i]; + + array->contents[i] = NULL; + + return el; + error: + return NULL; +} + +static inline void *DArray_new(DArray *array) +{ + check(array != NULL, "array cannot be NULL"); + check(array->element_size > 0, + "Can't use DArray_new on 0 size darrays."); + + return calloc(1, array->element_size); + + error: + return NULL; +} + +#define DArray_free(E) free((E)) + +#endif diff --git a/src/darray_algos.c b/src/darray_algos.c @@ -0,0 +1,234 @@ +/* SPDX-License-Identifier: BSD-3-Clause */ +/* + * Copyright © 2010, Zed A. Shaw. + * Copyright © 2020 rsiddharth <s@ricketyspace.net> + */ + +#include <darray_algos.h> + +int DArray_qsort(DArray *array, DArray_compare cmp) +{ + qsort(array->contents, DArray_count(array), sizeof(void *), cmp); + return 0; +} + +int DArray_heapsort(DArray *array, DArray_compare cmp) +{ + return heapsort(array->contents, DArray_count(array), + sizeof(void *), cmp); +} + +int DArray_mergesort(DArray *array, DArray_compare cmp) +{ + return mergesort(array->contents, DArray_count(array), + sizeof(void *), cmp); +} + +// Fucked Quick Sort. +int DArray_fucked_qsort_partition(DArray *array, DArray_compare cmp, + int low, int high) +{ + int i = 0, j = 0, cmp_rc; + void *pivot = NULL, *tmp = NULL; + + pivot = array->contents[high]; + i = low - 1; + + for (j = low; j < high; j++) { + cmp_rc = cmp(&array->contents[j], &pivot); + if (cmp_rc < 0) { + i = i + 1; + + // swap + tmp = array->contents[j]; + array->contents[j] = array->contents[i]; + array->contents[i] = tmp; + } + } + + cmp_rc = cmp(&array->contents[high], &array->contents[i + 1]); + if (cmp_rc < 0) { + tmp = array->contents[high]; + array->contents[high] = array->contents[i + 1]; + array->contents[i + 1] = tmp; + } + + return i + 1; +} + +int DArray_fucked_qsort_recurse(DArray *array, DArray_compare cmp, + int low, int high) +{ + int rc = 0, p = 0; + if (low < high) { + p = DArray_fucked_qsort_partition(array, cmp, low, high); + check(p >= 0, "Failed to partition [%d-%d]", low, high); + + rc = DArray_fucked_qsort_recurse(array, cmp, low, p - 1); + check(rc == 0, "Failed to quick sort sub array [%d-%d]", low, p-1); + + rc = DArray_fucked_qsort_recurse(array, cmp, p + 1, high); + check(rc == 0, "Failed to quick sort sub array [%d-%d]", p+1, high); + } + + return 0; + error: + return -1; +} + +int DArray_fucked_qsort(DArray *array, DArray_compare cmp) +{ + int rc; + rc = DArray_fucked_qsort_recurse(array, cmp, 0, DArray_end(array) - 1); + check(rc == 0, "Error sorting array."); + + return 0; + error: + return -1; +} + +// Fucked Heap Sort. +#define DArray_fucked_heapsort_iparent(i) ((floor(i - 1) / 2)) +#define DArray_fucked_heapsort_ileft_child(i) ((2*i + 1)) +#define DArray_fucked_heapsort_iright_child(i) ((2*i + 2)) + +static inline void DArray_fucked_heapsort_swap(DArray *array, int a, int b) +{ + void *tmp = array->contents[a]; + array->contents[a] = array->contents[b]; + array->contents[b] = tmp; +} + +int DArray_fucked_heapsort_sift_down(DArray *array, DArray_compare cmp, + int start, int end) +{ + + int root = start; + int child = 0; + int swap = 0; + + while (DArray_fucked_heapsort_ileft_child(root) <= end) { + child = DArray_fucked_heapsort_ileft_child(root); + swap = root; + + if (cmp(&array->contents[root], &array->contents[child]) < 0) { + swap = child; + } + if (((child + 1) <= end) + && (cmp(&array->contents[swap], &array->contents[child + 1]) < 0)) { + swap = child + 1; + } + if (swap == root) { + break; + } + + DArray_fucked_heapsort_swap(array, root, swap); + root = swap; + } + + return 0; +} + +int DArray_fucked_heapsort_heapify(DArray *array, DArray_compare cmp) +{ + int count = DArray_count(array); + int start = (int) DArray_fucked_heapsort_iparent(count - 1); + int rc = 0; + + + while (start >= 0) { + rc = DArray_fucked_heapsort_sift_down(array, cmp, start, count - 1); + check(rc == 0, "Error sifting down at %d %d", start, count - 1); + + start = start - 1; + } + + return 0; + error: + return -1; +} + +int DArray_fucked_heapsort(DArray *array, DArray_compare cmp) +{ + int rc = 0, end = 0; + + // First heapify array. + rc = DArray_fucked_heapsort_heapify(array, cmp); + check(rc == 0, "Error heapifying"); + + end = DArray_count(array) - 1; + while (end > 0) { + DArray_fucked_heapsort_swap(array, end, 0); + + end = end - 1; + rc = DArray_fucked_heapsort_sift_down(array, cmp, 0, end); + check(rc == 0, "Error sifting down at %d %d", 0, end); + } + + return 0; + error: + return -1; +} + +// Fucked Merge Sort. +void DArray_fucked_topdown_merge(DArray *a, DArray *b, + int begin, int middle, + int end, DArray_compare cmp) +{ + int i = 0, j = 0, k = 0; + + i = begin; + j = middle; + + for (k = begin; k < end; k++) { + if (i < middle && + (j >= end || cmp(&a->contents[i], &a->contents[j]) < 0)) { + DArray_set(b, k, DArray_get(a, i)); + i = i + 1; + } else { + DArray_set(b, k, DArray_get(a, j)); + j = j + 1; + } + } + + return; +} + +void DArray_fucked_topdown_split_merge(DArray *b, DArray *a, + int begin, int end, + DArray_compare cmp) +{ + if ((end - begin) < 2) { + return; + } + int middle = (end + begin) / 2; + + DArray_fucked_topdown_split_merge(a, b, begin, middle, cmp); + DArray_fucked_topdown_split_merge(a, b, middle, end, cmp); + + DArray_fucked_topdown_merge(b, a, begin, middle, end, cmp); + + return; +} + +int DArray_fucked_mergesort(DArray *array, DArray_compare cmp) +{ + DArray *copy = DArray_shallow_copy(array); + check(copy != NULL, "Error shallow copying array"); + + DArray *a = NULL, *b = NULL; + int begin = 0, end = 0; + + a = array; + b = copy; + begin = 0; + end = DArray_end(a); + DArray_fucked_topdown_split_merge(b, a, begin, end, cmp); + + // Clean up copy + DArray_destroy(copy); + + return 0; + error: + return -1; +} diff --git a/src/darray_algos.h b/src/darray_algos.h @@ -0,0 +1,26 @@ +/* SPDX-License-Identifier: BSD-3-Clause */ +/* + * Copyright © 2010, Zed A. Shaw. + * Copyright © 2020 rsiddharth <s@ricketyspace.net> + */ + +#ifndef darray_algos_h +#define darray_algos_h + +#include <math.h> +#include <stdlib.h> +#include <darray.h> + +int DArray_qsort(DArray *array, DArray_compare cmp); + +int DArray_heapsort(DArray *array, DArray_compare cmp); + +int DArray_mergesort(DArray *array, DArray_compare cmp); + +int DArray_fucked_qsort(DArray *array, DArray_compare cmp); + +int DArray_fucked_heapsort(DArray *array, DArray_compare cmp); + +int DArray_fucked_mergesort(DArray *array, DArray_compare cmp); + +#endif diff --git a/src/db.c b/src/db.c @@ -0,0 +1,138 @@ +/* SPDX-License-Identifier: BSD-3-Clause */ +/* + * Copyright © 2020 rsiddharth <s@ricketyspace.net> + */ + +#include <db.h> + +static const char *DB_FILE = "nserver.db"; + +datum *mk_datum(char *data) +{ + datum *d = NULL; + + check(data != NULL, "data invalid"); + + d = calloc(1, sizeof(datum)); + check(d != NULL, "datum mem alloc failed"); + + d->dptr = data; + d->dsize = strlen(data); + + return d; + error: + if (d) { + free(d); + } + return NULL; +} + +GDBM_FILE db_open(int flags) +{ + return gdbm_open(DB_FILE, 0,flags, S_IRUSR|S_IWUSR, NULL); +} + +int db_init() +{ + // Create DB if it's not already created. + GDBM_FILE gf = db_open(GDBM_WRCREAT); + check(gf != NULL, "unable to init db"); + + // Close the DB. + int rc = gdbm_close(gf); + check(rc == 0, "error closing db after init"); + + return 0; + error: + return -1; +} + +int db_store(char *key, char *value) +{ + datum *k_datum = NULL, *v_datum = NULL; + GDBM_FILE gf = NULL; + + check(key != NULL && strlen(key) > 0, "key invalid"); + check(value != NULL && strlen(value) > 0, "data invalid"); + + // make key value datum + k_datum = mk_datum(key); + check(k_datum != NULL, "key datum init failed"); + + v_datum = mk_datum(value); + check(v_datum != NULL, "value datum init failed"); + + // init db. + int rc = db_init(); + check(rc == 0, "db init failed"); + + // open the gdbm data in write mode + gf = db_open(GDBM_WRITER|GDBM_SYNC); + check(gf != NULL, "unable to open db in write mode"); + + // write key -> data to db. + rc = gdbm_store(gf, *k_datum, *v_datum, GDBM_REPLACE); + check(rc == 0, "gdbm store failed"); + + // close db + rc = gdbm_close(gf); + check(rc == 0, "gdbm close failed"); + + // cleanup. + free(k_datum); + free(v_datum); + + return 0; + error: + if (k_datum) { + free(k_datum); + } + if (v_datum) { + free(v_datum); + } + if (gf) { + gdbm_close(gf); + } + return -1; +} + +char *db_load(char *key) +{ + datum *k_datum = NULL; + GDBM_FILE gf = NULL; + + check(key != NULL && strlen(key) > 0, "key invalid"); + + // make key datum + k_datum = mk_datum(key); + check(k_datum != NULL, "key datum init failed"); + + // init db. + int rc = db_init(); + check(rc == 0, "db init failed"); + + // open the gdbm data in read mode + gf = db_open(GDBM_READER|GDBM_SYNC); + check(gf != NULL, "unable to open db in read mode"); + + // try to fetch value for key. + datum v_datum = gdbm_fetch(gf, *k_datum); + check(v_datum.dptr != NULL, "key not found"); + + // close db + rc = gdbm_close(gf); + check(rc == 0, "gdbm close failed"); + + // clean up. + free(k_datum); + + return v_datum.dptr; + error: + if (k_datum) { + free(k_datum); + } + if (gf) { + gdbm_close(gf); + } + return NULL; +} diff --git a/src/db.h b/src/db.h @@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: BSD-3-Clause */ +/* + * Copyright © 2020 rsiddharth <s@ricketyspace.net> + */ + +#ifndef _db_h +#define _db_h + +#include <gdbm.h> +#include <dbg.h> +#include <stdlib.h> +#include <string.h> +#include <sys/stat.h> + +int db_init(); +int db_store(char *key, char *value); +char *db_load(char *key); + +#endif + diff --git a/src/dbg.h b/src/dbg.h @@ -0,0 +1,48 @@ +/* SPDX-License-Identifier: BSD-3-Clause */ +/* + * Copyright © 2010, Zed A. Shaw. + */ + +#ifndef __dbg_h__ +#define __dbg_h__ + +#include <stdio.h>