Initial API to create new GGUF files.

Also added a few libraries that will be needed soon.
The CLI was renamed with the final name of gguf-tools.

Makefile

@@ -1,7 +1,8 @@
-all: gguf-show
+all: gguf-tools
 
-gguf-show: gguf-show.c gguflib.c gguflib.h
+gguf-tools: gguf-tools.c gguflib.c gguflib.h sds.c sds.h sdsalloc.h
-	$(CC) gguf-show.c gguflib.c -g -ggdb -Wall -W -pedantic -O2 -o gguf-show
+	$(CC) gguf-tools.c gguflib.c sds.c \
+		-g -ggdb -Wall -W -pedantic -O2 -o gguf-tools
 
 clean:
-	rm -rf gguf-show
+	rm -rf gguf-tools

gguf-show.c

@@ -1,42 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include "gguflib.h"
-
-int main(int argc, char **argv) {
-    if (argc != 2) {
-        printf("Usage: %s <filename>\n",argv[0]);
-        exit(1);
-    }
-    gguf_ctx *ctx = gguf_init(argv[1]);
-    if (ctx == NULL) {
-        perror("Opening GGUF file");
-        exit(1);
-    }
-
-    /* Show general information about the neural network. */
-    printf("%s (ver %d): %llu key-value pairs, %llu tensors\n",
-        argv[1],
-        (int)ctx->header->version,
-        (unsigned long long)ctx->header->metadata_kv_count,
-        (unsigned long long)ctx->header->tensor_count);
-
-    /* Show all the key-value pairs. */
-    gguf_key key;
-    while (gguf_get_key(ctx,&key)) {
-        printf("%.*s: [%s] ", (int)key.namelen, key.name, gguf_get_value_type_name(key.type));
-        gguf_print_value(ctx,key.type,key.val,0);
-        printf("\n");
-    }
-
-    gguf_tensor tensor;
-    while (gguf_get_tensor(ctx,&tensor)) {
-        printf("%s tensor %.*s @%llu, %llu weights, %llu bytes\n",
-            gguf_get_tensor_type_name(tensor.type),
-            (int)tensor.namelen,
-            tensor.name,
-            tensor.offset,
-            tensor.num_weights,
-            tensor.bsize);
-    }
-    return 0;
-}

gguf-tools.c

@@ -0,0 +1,169 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include "gguflib.h"
+
+/* ========================== Utility functions  ============================ */
+
+/* Glob-style pattern matching. Return 1 on match, 0 otherwise. */
+int strmatch(const char *pattern, int patternLen,
+             const char *string, int stringLen, int nocase)
+{
+    while(patternLen && stringLen) {
+        switch(pattern[0]) {
+        case '*':
+            while (patternLen && pattern[1] == '*') {
+                pattern++;
+                patternLen--;
+            }
+            if (patternLen == 1)
+                return 1; /* match */
+            while(stringLen) {
+                if (strmatch(pattern+1, patternLen-1,
+                             string, stringLen, nocase))
+                    return 1; /* match */
+                string++;
+                stringLen--;
+            }
+            return 0; /* no match */
+            break;
+        case '?':
+            string++;
+            stringLen--;
+            break;
+        case '[':
+        {
+            int not, match;
+
+            pattern++;
+            patternLen--;
+            not = pattern[0] == '^';
+            if (not) {
+                pattern++;
+                patternLen--;
+            }
+            match = 0;
+            while(1) {
+                if (pattern[0] == '\\' && patternLen >= 2) {
+                    pattern++;
+                    patternLen--;
+                    if (pattern[0] == string[0])
+                        match = 1;
+                } else if (pattern[0] == ']') {
+                    break;
+                } else if (patternLen == 0) {
+                    pattern--;
+                    patternLen++;
+                    break;
+                } else if (patternLen >= 3 && pattern[1] == '-') {
+                    int start = pattern[0];
+                    int end = pattern[2];
+                    int c = string[0];
+                    if (start > end) {
+                        int t = start;
+                        start = end;
+                        end = t;
+                    }
+                    if (nocase) {
+                        start = tolower(start);
+                        end = tolower(end);
+                        c = tolower(c);
+                    }
+                    pattern += 2;
+                    patternLen -= 2;
+                    if (c >= start && c <= end)
+                        match = 1;
+                } else {
+                    if (!nocase) {
+                        if (pattern[0] == string[0])
+                            match = 1;
+                    } else {
+                        if (tolower((int)pattern[0]) == tolower((int)string[0]))
+                            match = 1;
+                    }
+                }
+                pattern++;
+                patternLen--;
+            }
+            if (not)
+                match = !match;
+            if (!match)
+                return 0; /* no match */
+            string++;
+            stringLen--;
+            break;
+        }
+        case '\\':
+            if (patternLen >= 2) {
+                pattern++;
+                patternLen--;
+            }
+            /* fall through */
+        default:
+            if (!nocase) {
+                if (pattern[0] != string[0])
+                    return 0; /* no match */
+            } else {
+                if (tolower((int)pattern[0]) != tolower((int)string[0]))
+                    return 0; /* no match */
+            }
+            string++;
+            stringLen--;
+            break;
+        }
+        pattern++;
+        patternLen--;
+        if (stringLen == 0) {
+            while(*pattern == '*') {
+                pattern++;
+                patternLen--;
+            }
+            break;
+        }
+    }
+    if (patternLen == 0 && stringLen == 0)
+        return 1;
+    return 0;
+}
+
+/* ======================= Main and CLI options parsing ===================== */
+
+int main(int argc, char **argv) {
+    if (argc != 2) {
+        printf("Usage: %s <filename>\n",argv[0]);
+        exit(1);
+    }
+    gguf_ctx *ctx = gguf_init(argv[1]);
+    if (ctx == NULL) {
+        perror("Opening GGUF file");
+        exit(1);
+    }
+
+    /* Show general information about the neural network. */
+    printf("%s (ver %d): %llu key-value pairs, %llu tensors\n",
+        argv[1],
+        (int)ctx->header->version,
+        (unsigned long long)ctx->header->metadata_kv_count,
+        (unsigned long long)ctx->header->tensor_count);
+
+    /* Show all the key-value pairs. */
+    gguf_key key;
+    while (gguf_get_key(ctx,&key)) {
+        printf("%.*s: [%s] ", (int)key.namelen, key.name, gguf_get_value_type_name(key.type));
+        gguf_print_value(ctx,key.type,key.val,0);
+        printf("\n");
+    }
+
+    /* Show all the tensors. */
+    gguf_tensor tensor;
+    while (gguf_get_tensor(ctx,&tensor)) {
+        printf("%s tensor %.*s @%llu, %llu weights, %llu bytes\n",
+            gguf_get_tensor_type_name(tensor.type),
+            (int)tensor.namelen,
+            tensor.name,
+            tensor.offset,
+            tensor.num_weights,
+            tensor.bsize);
+    }
+    return 0;
+}

gguflib.c

@@ -92,8 +92,8 @@ uint64_t gguf_value_len(uint32_t type, union gguf_value *val) {
 /* =============================== GGUF file API ============================ */
 
 /* Open a GGUF file and return a parsing context. */
-gguf_ctx *gguf_init(char *filename) {
+gguf_ctx *gguf_init(const char *filename) {
-    int fd = open(filename,O_RDWR);
+    int fd = open(filename,O_RDWR|O_APPEND);
     if (fd == -1) return NULL;
 
     /* Mapping successful. We can create our context object. */
@@ -232,7 +232,7 @@ int gguf_get_tensor(gguf_ctx *ctx, gguf_tensor *tensor) {
 
     ctx->left_tensors--;
     struct gguf_string *str = (struct gguf_string*) (ctx->data+ctx->off);
-    ctx->off += 8+str->len; // Skip prefixed len + string + type.
+    ctx->off += 8+str->len; // Skip prefixed len + string.
     tensor->namelen = str->len;
     tensor->name = str->string;
     uint32_t *num_dim = (uint32_t*) (ctx->data+ctx->off);
@@ -388,3 +388,70 @@ void gguf_print_value(gguf_ctx *ctx, uint32_t type, union gguf_value *val, int f
     gguf_do_with_value(ctx,type,val,&po,0,0,gguf_print_value_callback);
 }
 
+/* ============================= GGUF writing API  ========================== */
+
+/* Create an empty GGUF file with no key-value pairs nor tensors.
+ * The file can be extended by using the APIs to add tensors and
+ * keys.
+ *
+ * On success the context with the file already loaded is returned,
+ * otherwise NULL is returned. */
+gguf_ctx *guff_create(const char *filename) {
+    struct gguf_header hdr;
+    memcpy(&hdr.magic,"GGUF",4);
+    hdr.version = 3;
+    hdr.tensor_count = 0;
+    hdr.metadata_kv_count = 0;
+
+    FILE *fp = fopen(filename,"wx");
+    if (fp == NULL) return NULL;
+    if (fwrite(&hdr,1,sizeof(hdr),fp) != sizeof(hdr)) {
+        fclose(fp);
+        return NULL;
+    }
+    fclose(fp);
+
+    return gguf_init(filename);
+}
+
+/* Low level API to append some key-value data to the GGUF file identified
+ * by the context 'ctx'. It's up to the caller to provide a well-formatted
+ * value of the specified type in 'val'. The len is the raw bytes length of
+ * the specified value. Higher level APIs use this one to create fields with
+ * different numerical values, strings, ...
+ *
+ * On success the function returns 1. Otherwise 0.
+ * The function fails and returns 0 with errno set to EINVAL if the
+ * tensors count in the header is non-zero: we can't append key-value
+ * data after the first tensor was emitted. */
+int gguf_append_kv(gguf_ctx *ctx, const char *keyname, uint64_t keylen, uint32_t type, void *val, uint64_t len) {
+    if (ctx->header->tensor_count != 0) {
+        errno = EINVAL;
+        return 0;
+    }
+    if (write(ctx->fd,&keylen,sizeof(keylen)) != sizeof(keylen)) return 0;
+    if (write(ctx->fd,keyname,keylen) != (ssize_t)keylen) return 0;
+    if (write(ctx->fd,&type,sizeof(type)) != sizeof(type)) return 0;
+    if (write(ctx->fd,val,len) != (ssize_t)len) return 0;
+    gguf_remap(ctx);
+    ctx->header->metadata_kv_count++;
+    return 1;
+}
+
+/* Append tensor metadata (but not the actual tensor weights data) to the
+ * GGUF file identified by 'ctx'. */
+int gguf_append_tensor(gguf_ctx *ctx, const char *tensorname, uint64_t namelen, uint32_t num_dim, uint64_t *dim, uint32_t type, uint64_t offset)
+{
+    if (write(ctx->fd,&namelen,sizeof(namelen)) != sizeof(namelen)) return 0;
+    if (write(ctx->fd,tensorname,namelen) != (ssize_t)namelen) return 0;
+    if (write(ctx->fd,&num_dim,sizeof(num_dim)) != sizeof(num_dim)) return 0;
+    for (uint32_t j = 0; j < num_dim; j++) {
+        if (write(ctx->fd,&dim[j],sizeof(uint64_t)) != sizeof(uint64_t))
+            return 0;
+    }
+    if (write(ctx->fd,&type,sizeof(type)) != sizeof(type)) return 0;
+    if (write(ctx->fd,&offset,sizeof(offset)) != sizeof(offset)) return 0;
+    gguf_remap(ctx);
+    ctx->header->tensor_count++;
+    return 1;
+}

gguflib.h

@@ -158,7 +158,7 @@ typedef struct {
 
 /* =============================== Prototypes =============================== */
 
-gguf_ctx *gguf_init(char *filename);
+gguf_ctx *gguf_init(const char *filename);
 int gguf_remap(gguf_ctx *ctx);
 void gguf_rewind(gguf_ctx *ctx);
 void gguf_end(gguf_ctx *ctx);

sds.h

@@ -0,0 +1,274 @@
+/* SDSLib 2.0 -- A C dynamic strings library
+ *
+ * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot com>
+ * Copyright (c) 2015, Oran Agra
+ * Copyright (c) 2015, Redis Labs, Inc
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis 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 OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __SDS_H
+#define __SDS_H
+
+#define SDS_MAX_PREALLOC (1024*1024)
+extern const char *SDS_NOINIT;
+
+#include <sys/types.h>
+#include <stdarg.h>
+#include <stdint.h>
+
+typedef char *sds;
+
+/* Note: sdshdr5 is never used, we just access the flags byte directly.
+ * However is here to document the layout of type 5 SDS strings. */
+struct __attribute__ ((__packed__)) sdshdr5 {
+    unsigned char flags; /* 3 lsb of type, and 5 msb of string length */
+    char buf[];
+};
+struct __attribute__ ((__packed__)) sdshdr8 {
+    uint8_t len; /* used */
+    uint8_t alloc; /* excluding the header and null terminator */
+    unsigned char flags; /* 3 lsb of type, 5 unused bits */
+    char buf[];
+};
+struct __attribute__ ((__packed__)) sdshdr16 {
+    uint16_t len; /* used */
+    uint16_t alloc; /* excluding the header and null terminator */
+    unsigned char flags; /* 3 lsb of type, 5 unused bits */
+    char buf[];
+};
+struct __attribute__ ((__packed__)) sdshdr32 {
+    uint32_t len; /* used */
+    uint32_t alloc; /* excluding the header and null terminator */
+    unsigned char flags; /* 3 lsb of type, 5 unused bits */
+    char buf[];
+};
+struct __attribute__ ((__packed__)) sdshdr64 {
+    uint64_t len; /* used */
+    uint64_t alloc; /* excluding the header and null terminator */
+    unsigned char flags; /* 3 lsb of type, 5 unused bits */
+    char buf[];
+};
+
+#define SDS_TYPE_5  0
+#define SDS_TYPE_8  1
+#define SDS_TYPE_16 2
+#define SDS_TYPE_32 3
+#define SDS_TYPE_64 4
+#define SDS_TYPE_MASK 7
+#define SDS_TYPE_BITS 3
+#define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (void*)((s)-(sizeof(struct sdshdr##T)));
+#define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))
+#define SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS)
+
+static inline size_t sdslen(const sds s) {
+    unsigned char flags = s[-1];
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5:
+            return SDS_TYPE_5_LEN(flags);
+        case SDS_TYPE_8:
+            return SDS_HDR(8,s)->len;
+        case SDS_TYPE_16:
+            return SDS_HDR(16,s)->len;
+        case SDS_TYPE_32:
+            return SDS_HDR(32,s)->len;
+        case SDS_TYPE_64:
+            return SDS_HDR(64,s)->len;
+    }
+    return 0;
+}
+
+static inline size_t sdsavail(const sds s) {
+    unsigned char flags = s[-1];
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5: {
+            return 0;
+        }
+        case SDS_TYPE_8: {
+            SDS_HDR_VAR(8,s);
+            return sh->alloc - sh->len;
+        }
+        case SDS_TYPE_16: {
+            SDS_HDR_VAR(16,s);
+            return sh->alloc - sh->len;
+        }
+        case SDS_TYPE_32: {
+            SDS_HDR_VAR(32,s);
+            return sh->alloc - sh->len;
+        }
+        case SDS_TYPE_64: {
+            SDS_HDR_VAR(64,s);
+            return sh->alloc - sh->len;
+        }
+    }
+    return 0;
+}
+
+static inline void sdssetlen(sds s, size_t newlen) {
+    unsigned char flags = s[-1];
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5:
+            {
+                unsigned char *fp = ((unsigned char*)s)-1;
+                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
+            }
+            break;
+        case SDS_TYPE_8:
+            SDS_HDR(8,s)->len = newlen;
+            break;
+        case SDS_TYPE_16:
+            SDS_HDR(16,s)->len = newlen;
+            break;
+        case SDS_TYPE_32:
+            SDS_HDR(32,s)->len = newlen;
+            break;
+        case SDS_TYPE_64:
+            SDS_HDR(64,s)->len = newlen;
+            break;
+    }
+}
+
+static inline void sdsinclen(sds s, size_t inc) {
+    unsigned char flags = s[-1];
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5:
+            {
+                unsigned char *fp = ((unsigned char*)s)-1;
+                unsigned char newlen = SDS_TYPE_5_LEN(flags)+inc;
+                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
+            }
+            break;
+        case SDS_TYPE_8:
+            SDS_HDR(8,s)->len += inc;
+            break;
+        case SDS_TYPE_16:
+            SDS_HDR(16,s)->len += inc;
+            break;
+        case SDS_TYPE_32:
+            SDS_HDR(32,s)->len += inc;
+            break;
+        case SDS_TYPE_64:
+            SDS_HDR(64,s)->len += inc;
+            break;
+    }
+}
+
+/* sdsalloc() = sdsavail() + sdslen() */
+static inline size_t sdsalloc(const sds s) {
+    unsigned char flags = s[-1];
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5:
+            return SDS_TYPE_5_LEN(flags);
+        case SDS_TYPE_8:
+            return SDS_HDR(8,s)->alloc;
+        case SDS_TYPE_16:
+            return SDS_HDR(16,s)->alloc;
+        case SDS_TYPE_32:
+            return SDS_HDR(32,s)->alloc;
+        case SDS_TYPE_64:
+            return SDS_HDR(64,s)->alloc;
+    }
+    return 0;
+}
+
+static inline void sdssetalloc(sds s, size_t newlen) {
+    unsigned char flags = s[-1];
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5:
+            /* Nothing to do, this type has no total allocation info. */
+            break;
+        case SDS_TYPE_8:
+            SDS_HDR(8,s)->alloc = newlen;
+            break;
+        case SDS_TYPE_16:
+            SDS_HDR(16,s)->alloc = newlen;
+            break;
+        case SDS_TYPE_32:
+            SDS_HDR(32,s)->alloc = newlen;
+            break;
+        case SDS_TYPE_64:
+            SDS_HDR(64,s)->alloc = newlen;
+            break;
+    }
+}
+
+sds sdsnewlen(const void *init, size_t initlen);
+sds sdsnew(const char *init);
+sds sdsempty(void);
+sds sdsdup(const sds s);
+void sdsfree(sds s);
+sds sdsgrowzero(sds s, size_t len);
+sds sdscatlen(sds s, const void *t, size_t len);
+sds sdscat(sds s, const char *t);
+sds sdscatsds(sds s, const sds t);
+sds sdscpylen(sds s, const char *t, size_t len);
+sds sdscpy(sds s, const char *t);
+
+sds sdscatvprintf(sds s, const char *fmt, va_list ap);
+#ifdef __GNUC__
+sds sdscatprintf(sds s, const char *fmt, ...)
+    __attribute__((format(printf, 2, 3)));
+#else
+sds sdscatprintf(sds s, const char *fmt, ...);
+#endif
+
+sds sdscatfmt(sds s, char const *fmt, ...);
+sds sdstrim(sds s, const char *cset);
+void sdsrange(sds s, ssize_t start, ssize_t end);
+void sdsupdatelen(sds s);
+void sdsclear(sds s);
+int sdscmp(const sds s1, const sds s2);
+sds *sdssplitlen(const char *s, ssize_t len, const char *sep, int seplen, int *count);
+void sdsfreesplitres(sds *tokens, int count);
+void sdstolower(sds s);
+void sdstoupper(sds s);
+sds sdsfromlonglong(long long value);
+sds sdscatrepr(sds s, const char *p, size_t len);
+sds *sdssplitargs(const char *line, int *argc);
+sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen);
+sds sdsjoin(char **argv, int argc, char *sep);
+sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen);
+
+/* Low level functions exposed to the user API */
+sds sdsMakeRoomFor(sds s, size_t addlen);
+void sdsIncrLen(sds s, ssize_t incr);
+sds sdsRemoveFreeSpace(sds s);
+size_t sdsAllocSize(sds s);
+void *sdsAllocPtr(sds s);
+
+/* Export the allocator used by SDS to the program using SDS.
+ * Sometimes the program SDS is linked to, may use a different set of
+ * allocators, but may want to allocate or free things that SDS will
+ * respectively free or allocate. */
+void *sds_malloc(size_t size);
+void *sds_realloc(void *ptr, size_t size);
+void sds_free(void *ptr);
+
+#ifdef REDIS_TEST
+int sdsTest(int argc, char *argv[]);
+#endif
+
+#endif

sdsalloc.h

@@ -0,0 +1,46 @@
+/* SDSLib 2.0 -- A C dynamic strings library
+ *
+ * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot com>
+ * Copyright (c) 2015, Redis Labs, Inc
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis 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 OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* SDS allocator selection.
+ *
+ * This file is used in order to change the SDS allocator at compile time.
+ * Just define the following defines to what you want to use. Also add
+ * the include of your alternate allocator if needed (not needed in order
+ * to use the default libc allocator). */
+
+#ifndef __SDS_ALLOC_H__
+#define __SDS_ALLOC_H__
+
+#define s_malloc malloc
+#define s_realloc realloc
+#define s_free free
+
+#endif