tou.h

Go to the documentation of this file.

 
#ifndef __TOU_H_
#define __TOU_H_
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdbool.h>
 
/* == Debug options and helpers == */
#define TOU_GET_VERSION() (20240819L)
 
#ifndef TOU_DBG
#define TOU_DBG 0
#endif
 
#ifndef TOU_DEBUG
#define TOU_DEBUG(...) if (TOU_DBG) { __VA_ARGS__; } else (void)0
#endif
 
#ifndef TOU_DEBUG_PREFIX
#define TOU_DEBUG_PREFIX "[:] "
#endif
 
#ifndef TOU_PRINTD
#define TOU_PRINTD(format, ...) if (TOU_DBG) { fprintf(stdout, TOU_DEBUG_PREFIX format, ##__VA_ARGS__); } else (void)0
#endif
 
#ifdef _WIN32
#include <io.h>
#define _TOU_DEVNULL_FILE "NUL:"
#else
#include <unistd.h>
#include <fcntl.h> // O_WRONLY
#define _TOU_DEVNULL_FILE "/dev/null"
#endif
/* == Various definitions == */
#ifndef nullptr
#define nullptr ((void*)0)
#endif
 
#ifndef TOU_DEFAULT_BLOCKSIZE
#define TOU_DEFAULT_BLOCKSIZE 4096
#endif
 
#define TOU_JSON_DATA_VER "1.0"
 
#define TOU_XML_DATA_VER "1.0"
 
#ifndef TOU_STR
#define TOU_STR(s) #s
#endif
#ifndef TOU_MSTR
#define TOU_MSTR(s) TOU_STR(s)
#endif
 
#ifndef TOU_IS_BLANK
#define TOU_IS_BLANK(c) ((c)==' ' || (c)=='\n' || (c)=='\r' || (c)=='\t')
#endif
 
#ifndef TOU_ARRSIZE
#define TOU_ARRSIZE(x) (sizeof(x) / sizeof(x[0])) // /sizeof(__typeof__(x[0])))
#endif
 
#ifndef TOU_RANDINT
#define TOU_RANDINT(mx, mn) ((int)(((float)rand()/RAND_MAX) * ((mx)-(mn)) + (mn)))
#endif
 
enum tou_iter_action {
    TOU_BREAK    = 0,
    TOU_CONTINUE = 1,
};
 
 
/* Func ptrs */
 
typedef void* (*tou_func)(void*);
 
typedef void* (*tou_func2)(void*, void*);
 
typedef void* (*tou_func3)(void*, void*, void*);
 
 
/* == Linked list definitions == */
typedef struct tou_llist
{
    struct tou_llist* prev;     
    struct tou_llist* next;     
    void* dat1;                 
#ifndef TOU_LLIST_SINGLE_ELEM
    void* dat2;                 
#endif
    char destroy_dat1/* : 1*/;  
#ifndef TOU_LLIST_SINGLE_ELEM
    char destroy_dat2/* : 1*/;  
#endif
} tou_llist_t;
 
typedef struct tou_llist tou_llist_elem;
 
 
// ==============================================================
// ||                        FUNC DECLS                        ||
// ==============================================================
 
/* == String functions == */
/*
 * strlcpy() and strcat() functions were acquired from
 * Todd Miller under the following license:
 *
 * Copyright (c) 1998, 2015 Todd C. Miller <millert@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 * 
 * Also see: https://www.millert.dev/papers/strlcpy
 */
 
size_t tou_strlcpy(char* dst, const char* src, size_t size);
 
size_t tou_strlcat(char* dst, const char* src, size_t size);
 
size_t tou_strlen(const char* str);
 
char* tou_strdup(const char* src);
 
char* tou_strndup(const char* src, size_t size);
 
char* tou_strchr(const char* src, int ch);
 
char* tou_strrchr(const char* src, int ch);
 
char* tou_trim_string(char** str);
 
char* tou_trim_front(char** str);
 
char* tou_trim_back(char** str);
 
void tou_trim_string_pure(char* str, char** start, char** end);
 
char* tou_trim_front_pure(char* str);
 
char* tou_trim_back_pure(char* str);
 
char* tou_slower(char* str);
 
char* tou_supper(char* str);
 
char* tou_replace_ch(char* ss, char oldch, char newch);
 
char* tou_sfind(const char* str, const char* kwd);
 
char* tou_sfind_n(const char* str, const char* kwd, size_t maxlen);
 
char* tou_sfind_multiple(const char* str, const char** kwds, int n_kwds, int* found_idx);
 
char* tou_sfind_multiple_n(const char* str, const char** kwds, int n_kwds, int* found_idx, size_t maxlen);
 
void tou_sfind_iter_multiple(const char* src, const char* kwds[], int n_kwds, tou_func3 cb, void* userdata);
 
void tou_sfind_iter_multiple_n(const char* src, const char* kwds[], int n_kwds, tou_func3 cb, void* userdata, size_t maxlen);
 
tou_llist_t* tou_split(char* str, const char* delim);
 
char* tou_sappend(char* dst, char* src);
 
char* tou_sprepend(char* dst, char* src);
 
char* tou_sreplace(char* str, char* repl_str, char* with_str);
 
char* tou_sreplace_n(char* str, char* repl_str, char* with_str, size_t* len_ptr);
 
#ifndef tou_sisempty
#define tou_sisempty(elem, dat) \
    ((elem) == NULL /* wanted to do without this one but i can already see segfaults happening without it */ || \
     (elem)->dat == NULL || \
     tou_strlen(tou_trim_front_pure((elem)->dat)) == 0)
#endif
 
 
/* == File operations == */
size_t tou_read_fp_in_blocks(FILE* fp, size_t blocksize, tou_func3 cb, void* userdata);
 
typedef struct {
    char* buffer; 
    size_t size; 
} tou_block_store_struct;
 
void* tou_block_store_cb(void* blockdata, void* len, void* userdata);
 
char* tou_read_file(const char* filename, size_t* read_len);
 
char* tou_read_fp(FILE* fp, size_t* read_len);
 
 
/* == System/IO control == */
int tou_disable_stdout();
 
void tou_enable_stdout(int saved_fd);
 
#ifndef TOU_SILENCE
#define TOU_SILENCE( ... ) \
    _tou_g_saved_stdout = tou_disable_stdout(); \
    __VA_ARGS__ ; \
    tou_enable_stdout(_tou_g_saved_stdout);
#endif
 
int _tou_g_saved_stdout;
 
 
/* == Linked list == */
#ifndef TOU_LLIST_DAT_ADDR
#define TOU_LLIST_DAT_ADDR(list, param) ((tou_llist_t**)(&((*(list))->param)))
#endif
#ifndef tou_llist_new
#define tou_llist_new(...) ((TOU_DBG ? fprintf(stdout,TOU_DEBUG_PREFIX"Creating new llist :: NULL\n") : (void)0) , NULL)
#endif
 
/* */
// typedef tou_llist_t* tou_llist_elem;
/* */
// #define TOU_LLIST_UNPACK(elem) (*(elem))->dat1,(*(elem))->dat2
 
tou_llist_t* tou_llist_append
(
    tou_llist_t** elem,
    void* dat1,
#ifndef TOU_LLIST_SINGLE_ELEM
    void* dat2,
#endif
    char dat1_is_dynalloc
#ifndef TOU_LLIST_SINGLE_ELEM
    , char dat2_is_dynalloc
#endif
);
 
tou_llist_t* tou_llist_appendone(tou_llist_t** elem, void* dat1, char dat1_is_dynalloc);
 
tou_llist_t* tou_llist_prepend
(
    tou_llist_t** elem,
    void* dat1,
#ifndef TOU_LLIST_SINGLE_ELEM
    void* dat2,
#endif
    char dat1_is_dynalloc
#ifndef TOU_LLIST_SINGLE_ELEM
    , char dat2_is_dynalloc
#endif
);
 
tou_llist_t* tou_llist_prependone(tou_llist_t** elem, void* dat1, char dat1_is_dynalloc);
 
void tou_llist_destroy(tou_llist_t* list);
 
tou_llist_t* tou_llist_remove(tou_llist_t* elem);
 
tou_llist_t* tou_llist_pop(tou_llist_t* elem);
 
void tou_llist_free_element(tou_llist_t* elem);
 
tou_llist_t* tou_llist_get_head(tou_llist_t* list);
 
tou_llist_t* tou_llist_get_tail(tou_llist_t* list);
 
tou_llist_t* tou_llist_get_newest(tou_llist_t* list);
 
tou_llist_t* tou_llist_get_oldest(tou_llist_t* list);
 
tou_llist_t* tou_llist_get_newer(tou_llist_t* elem);
 
tou_llist_t* tou_llist_get_older(tou_llist_t* elem);
 
tou_llist_t* tou_llist_next_newer(tou_llist_t** elem);
 
tou_llist_t* tou_llist_next_older(tou_llist_t** elem);
 
char tou_llist_is_head(tou_llist_t* elem);
 
char tou_llist_is_tail(tou_llist_t* elem);
 
void tou_llist_iter(tou_llist_t* list, tou_func cb);
 
tou_llist_t* tou_llist_find_exact
(
    tou_llist_t* list,
    void* dat1
#ifndef TOU_LLIST_SINGLE_ELEM
    , void* dat2
#endif
);
 
tou_llist_t* tou_llist_find_exactone(tou_llist_t* list, void* dat1);
 
tou_llist_t* tou_llist_find_key(tou_llist_t* list, void* dat1);
 
tou_llist_t* tou_llist_find_func(tou_llist_t* list, tou_func2 cb, void* userdata);
 
size_t tou_llist_len(tou_llist_t* list);
 
void** tou_llist_gather_dat1(tou_llist_t* list, size_t* len);
 
#ifndef TOU_LLIST_SINGLE_ELEM
void** tou_llist_gather_dat2(tou_llist_t* list, size_t* len);
#endif
 
#define tou_llist_gather tou_llist_gather_dat1
 
#ifndef tou_llist_print
#ifndef TOU_LLIST_SINGLE_ELEM
 
    #define tou_llist_print(llist, dat1_spec, dat2_spec, ...)                      \
    {                                                                              \
        tou_llist_t* copy = tou_llist_get_newest(llist);                           \
        printf("List contents: (%d)\n", tou_llist_len(copy));                      \
        while (copy) {                                                             \
            printf("  |\n  "dat1_spec" :: "dat2_spec"\n", copy->dat1, copy->dat2); \
            copy = tou_llist_get_older(copy);                                      \
        }                                                                          \
    } (void)0
 
#else
 
    #define tou_llist_print(llist, dat1_spec, ...)            \
    {                                                         \
        tou_llist_t* copy = tou_llist_get_newest(llist);      \
        printf("List contents: (%d)\n", tou_llist_len(copy)); \
        while (copy) {                                        \
            printf("  |\n  "dat1_spec"\n", copy->dat1);       \
            copy = tou_llist_get_older(copy);                 \
        }                                                     \
    } (void)0
 
#endif
#endif
 
#ifndef tou_llist_print_tail
#ifndef TOU_LLIST_SINGLE_ELEM
 
    #define tou_llist_print_tail(llist, dat1_spec, dat2_spec, ...)                 \
    {                                                                              \
        tou_llist_t* copy = tou_llist_get_oldest(llist);                           \
        printf("List contents: (%d)\n", tou_llist_len(copy));                      \
        while (copy) {                                                             \
            printf("  |\n  "dat1_spec" :: "dat2_spec"\n", copy->dat1, copy->dat2); \
            copy = tou_llist_get_newer(copy);                                      \
        }                                                                          \
    } (void)0
 
#else
 
    #define tou_llist_print_tail(llist, dat1_spec, ...)       \
    {                                                         \
        tou_llist_t* copy = tou_llist_get_oldest(llist);      \
        printf("List contents: (%d)\n", tou_llist_len(copy)); \
        while (copy) {                                        \
            printf("  |\n  "dat1_spec"\n", copy->dat1);       \
            copy = tou_llist_get_newer(copy);                 \
        }                                                     \
    } (void)0
 
#endif
#endif
 
 
/* == Stack == */
typedef tou_llist_t tou_stack;
 
tou_llist_t* tou_stack_new();
 
void tou_stack_destroy(tou_llist_t* stack);
 
size_t tou_stack_len(tou_llist_t* stack);
 
void tou_stack_push(tou_llist_t** stack, void* elem);
 
void* tou_stack_pop(tou_llist_t** stack);
 
 
/* == Queue == */
typedef tou_llist_t tou_queue;
 
tou_llist_t* tou_queue_new();
 
void tou_queue_destroy(tou_llist_t* queue);
 
size_t tou_queue_len(tou_llist_t* queue);
 
void tou_queue_push(tou_llist_t** queue, void* elem);
 
void* tou_queue_pop(tou_llist_t** queue);
 
 
/* == INI parser == */
#ifdef TOU_LLIST_SINGLE_ELEM
#warning TOU_LLIST_SINGLE_ELEM DEFINED, TOU_INI DISABLED.
#else
 
 
tou_llist_t* tou_ini_parse_fp(FILE* fp);
 
tou_llist_t* tou_ini_parse_buffer(char* buf);
 
int tou_ini_parse_line(tou_llist_t** inicontents, char* line);
 
void tou_ini_destroy(tou_llist_t* inicontents);
 
void tou_ini_print(tou_llist_t* inicontents);
 
tou_llist_t* tou_ini_get_section(tou_llist_t* inicontents, const char* section_name);
 
tou_llist_t* tou_ini_get_property(tou_llist_t* inicontents, const char* section_name, const char* key);
 
void* tou_ini_get(tou_llist_t* inicontents, const char* section_name, const char* key);
 
void* tou_ini_set(tou_llist_t** inicontents, const char* section_name, const char* key, char* new_value);
 
tou_llist_t* tou_ini_section(tou_llist_t* inicontents, const char* section_name);
 
void* tou_ini_property(tou_llist_t* section, const char* property_name);
 
int tou_ini_save_fp(tou_llist_t* inicontents, FILE* fp);
 
int tou_ini_save_fp_json(tou_llist_t* inicontents, FILE* fp);
 
int tou_ini_save_fp_xml(tou_llist_t* inicontents, FILE* fp);
 
#endif
 
 
/* == Parsers == */
#ifdef TOU_LLIST_SINGLE_ELEM
#warning TOU_LLIST_SINGLE_ELEM DEFINED, PARSERS & CONVERTERS DISABLED.
#else
 
tou_llist_t* tou_paramparse(char* str, const char* param_sep, const char* keyval_sep);
 
tou_llist_t* tou_paramparse_n(char* str, const char* param_sep, const char* keyval_sep, size_t maxlen);
 
void tou_paramprint(tou_llist_t* params);
 
#endif
 
 
#endif // __TOU_H_
 
 
// ==============================================================
// ||                       IMPLEMENTATION                     ||
// ==============================================================
 
 
#ifdef TOU_IMPLEMENTATION
#if defined(TOU_IMPLEMENTATION_DONE)
#pragma error "TOU_IMPLEMENTATION already defined somewhere!"
#else
 
#define TOU_IMPLEMENTATION_DONE
 
 
 
 
/*  */
size_t tou_strlcpy(char* dst, const char* src, size_t size)
{
    size_t src_len;
 
    src_len = strlen (src);
    if (size > 0)
    {
        size_t dst_len = size - 1;
        if (src_len < dst_len)
            dst_len = src_len;
        memcpy (dst, src, dst_len);
        dst[dst_len] = '\0';
    }
    return src_len;
}
 
 
/*  */
size_t tou_strlcat(char* dst, const char* src, size_t size)
{
    size_t src_len, dst_len;
 
    src_len = strlen (src);
    dst_len = strlen (dst);
    if (size > 0 && dst_len < size) 
    {
        size_t copy_cnt = size - dst_len - 1;
        if (src_len < copy_cnt)
            copy_cnt = src_len;
        memcpy (dst + dst_len, src, copy_cnt);
        dst[dst_len + copy_cnt] = '\0';
    }
    return src_len + dst_len;
}
 
 
/*  */
size_t tou_strlen(const char* str)
{
    if (!str) return 0;
    return strlen(str);
}
 
 
/*  */
char* tou_strdup(const char* src)
{
    size_t src_len = strlen(src);
    char* copy;
    if ((copy = malloc(src_len + 1)) == NULL)
        return NULL;
    // tou_strlcpy(copy, src, src_len + 1);
    memcpy(copy, src, src_len + 1);
    return copy;
}
 
 
/*  */
char* tou_strndup(const char* src, size_t size)
{
    size_t src_len = strlen(src);
    char* copy = NULL;
 
    if (size > 0) {
        size_t copy_len = size;
        if (src_len < copy_len)
            copy_len = src_len;
        if ((copy = malloc(copy_len + 1)) == NULL)
            return NULL;
        // tou_strlcpy(copy, src, copy_len + 1);
        memcpy(copy, src, copy_len + 1);
    }
    return copy;
}
 
 
/*  */
char* tou_strchr(const char* src, int ch)
{
    while (*src) {
        if (*src == (char)ch)
            return (char*)src;
        src++;
    }
 
    if (ch == '\0') // '\0' can also be searched for
        return (char*)src;
    else
        return NULL;
}
 
 
/*  */
char* tou_strrchr(const char* src, int ch)
{
    char* pos = NULL;
 
    while (*src) {
        if (*src == (char)ch)
            pos = (char*)src;
        src++;
    }
 
    if (ch == '\0') // '\0' can also be searched for
        return (char*)src;
    else
        return pos;
}
 
 
/*  */
char* tou_trim_string(char** str)
{
    tou_trim_back(str);
    return tou_trim_front(str);
}
 
 
/*  */
char* tou_trim_front(char** str)
{
    if (str == NULL || *str == NULL)
        return NULL;
    
    char* ptr = *str;
    while (*ptr != '\0' && TOU_IS_BLANK(*ptr))
        ptr++;
    *str = ptr;
    return ptr;
}
 
 
/*  */
char* tou_trim_back(char** str)
{
    if (str == NULL || *str == NULL)
        return NULL;
 
    char* ptr = (*str + strlen(*str) - 1);
    while (ptr >= *str && TOU_IS_BLANK(*ptr)) {
        *ptr = '\0';
        ptr--;
    }
    ptr++;
    return ptr;
}
 
 
/*  */
void tou_trim_string_pure(char* str, char** start, char** end)
{
    char* back = tou_trim_back_pure(str);
    char* front = tou_trim_front_pure(str);
 
    *end = back;
    *start = front;
}
 
 
/*  */
char* tou_trim_front_pure(char* str)
{
    if (str == NULL)
        return NULL;
 
    while (*str != '\0' && TOU_IS_BLANK(*str))
        str++;
    return str;
}
 
 
/*  */
char* tou_trim_back_pure(char* str)
{
    if (str == NULL)
        return NULL;
 
    char* ptr = (str + strlen(str) - 1);
    while (ptr >= str && TOU_IS_BLANK(*ptr)) {
        ptr--;
    }
    ptr++; // Inc to point at the first trimmed/NUL byte
    return ptr;
}
 
 
/*  */
char* tou_slower(char* str)
{
    if (!str)
        return NULL;
 
    char* ptr = str;
    while (*ptr++ = tolower(*ptr)) ;
    return str;
}
 
/*  */
char* tou_supper(char* str)
{
    if (!str)
        return NULL;
 
    char* ptr = str;
    while (*ptr++ = toupper(*ptr)) ;
    return str;
}
 
 
/*  */
char* tou_replace_ch(char* ss, char oldch, char newch)
{
    TOU_PRINTD("[replace_ch] replacing ('%c'->'%c') \"%s\" => ", oldch, newch, ss);
    char* ptr = tou_strchr(ss, oldch);
    while (ptr) {
        *ptr = newch;
        ptr = tou_strchr(ptr + 1, oldch);
    }
    TOU_PRINTD("\"%s\"\n", ss);
    return ss;
}
 
 
/*  */
char* tou_sfind(const char* src, const char* kwd)
{
    return tou_sfind_n(src, kwd, strlen(src));
}
 
 
/*  */
char* tou_sfind_n(const char* src, const char* kwd, size_t maxlen)
{
    if (src == NULL)
        return NULL;
 
    const char* ret_ptr = NULL;
    const int kwd_len = strlen(kwd);
    const char* kwd_ptr = kwd;
 
    if (kwd_len > maxlen)
        return NULL;
    
    while (maxlen + 1 > 0 ){//&& *src) {
        if (*kwd_ptr == '\0') {
            // only time it should be is when kwd is found
            ret_ptr = src - kwd_len;
            break;
        }
 
        if (*src == '\0')
            break;
 
        if (*kwd_ptr == *src) {
            kwd_ptr++;
        } else {
            kwd_ptr = kwd;
        }
 
        src++;
        maxlen--;
    }
 
    return (char*)ret_ptr;
}
 
 
/*  */
char* tou_sfind_multiple(const char* str, const char** kwds, int n_kwds, int* found_idx)
{
    return tou_sfind_multiple_n(str, kwds, n_kwds, found_idx, ((size_t)-1) - 1);
}
 
 
/*  */
char* tou_sfind_multiple_n(const char* str, const char** kwds, int n_kwds, int* found_idx, size_t maxlen)
{
    if (str == NULL || kwds == NULL || n_kwds < 1)
        return NULL;
 
    if (maxlen < 1) {
        if (found_idx) *found_idx = -1;
        return NULL;
    }
 
    int kwd_len[n_kwds];
    const char* kwd_ptr[n_kwds];
    const char* ret_ptr = NULL;
 
    // Kwds which are NULL will not stop function but will be
    // ignored later in search loop and their kwd_len will be set to 0
    for (int i = 0; i < n_kwds; i++) {
        kwd_ptr[i] = kwds[i];
        kwd_len[i] = tou_strlen(kwds[i]);
    }
 
    while (maxlen + 1 > 0 && *str) {
        for (int i = 0; i < n_kwds; i++) {
 
            if (kwd_ptr[i] == NULL) // Skip NULL keywords
                continue;
            if (*(kwd_ptr[i]) == '\0') {
                // only time it should be is when that kwd is found
                ret_ptr = str - kwd_len[i];
                if (found_idx)
                    *found_idx = i;
                goto jmp_sfind_multiple_n_break; // break;
            }
 
            if (*(kwd_ptr[i]) == *str) {
                kwd_ptr[i]++; // this character matched next char in this kwd
            } else {
                kwd_ptr[i] = kwds[i]; // reset this kwd tracker
            }
 
        }
 
        str++;
        maxlen--;
    }
 
jmp_sfind_multiple_n_break:
    // Do the check one more time in case matching string is found
    // at the end of `str` (*str will break before the check has a chance)
    for (int i = 0; i < n_kwds; i++) {
        if (*(kwd_ptr[i]) == '\0') {
            ret_ptr = str - kwd_len[i];
            if (found_idx)
                *found_idx = i;
            break;
        }
    }
    return (char*)ret_ptr;
}
 
 
/*  */
void tou_sfind_iter_multiple(const char* src, const char* kwds[], int n_kwds, tou_func3 cb, void* userdata)
{
    tou_sfind_iter_multiple_n(src, kwds, n_kwds, cb, userdata, ((size_t)-1) - 1);
}
 
 
/*  */
void tou_sfind_iter_multiple_n(const char* src, const char* kwds[], int n_kwds, tou_func3 cb, void* userdata, size_t maxlen)
{
    char* found = NULL;
    int found_idx = -1;
    const char* text_ptr = src;
    size_t remaining = maxlen - 0;
 
    while ((found = tou_sfind_multiple_n(text_ptr, kwds, n_kwds, &found_idx, remaining)) != NULL) {
        // TOU_PRINTD("[iter_find_multiple_n] calling user func with (\"%s\", \"%s\", %p)\n", text_ptr, kwds[found_idx], userdata);
 
        // Call user func
        if (cb((void*)found, (void*)kwds[found_idx], userdata) == TOU_BREAK) {
            TOU_PRINTD("[iter_find_multiple_n] breaking early\n");
            return;
        }
        // Iter continue
        text_ptr = found + tou_strlen(kwds[found_idx]);
        remaining -= (text_ptr - src);
    }
}
 
 
/*  */
tou_llist_t* tou_split(char* str, const char* delim)
{
    if (!str || !delim)
        return NULL;
 
    TOU_PRINTD("[tou_split] STR_LEN :: %zu\n", tou_strlen(str));
 
    size_t delim_len = tou_strlen(delim);
    tou_llist_t* list = NULL;
    char* pos_start = str;
    char* pos_delim = tou_sfind(str, delim);
    
    while (pos_delim) {
        // TODO: swap with tou_str[n]dup() ?
        char* buf = malloc(pos_delim-pos_start + 1);
        tou_strlcpy(buf, pos_start, pos_delim-pos_start + 1);
        TOU_PRINTD("[tou_split] BUF: %s\n", buf);
        tou_llist_appendone(&list, buf, 1);
 
        // Find next occurence
        pos_start = pos_delim + delim_len;
        pos_delim = tou_sfind(pos_start, delim);
    }
 
    size_t len = tou_strlen(pos_start);
    TOU_PRINTD("[tou_split] FINAL LEN :: %zu\n", len);
    if (len > 0) {
        // Append last part till the end
        // TODO: swap with tou_strndup() ?
        char* buf = malloc(len + 1);
        tou_strlcpy(buf, pos_start, len + 1);
        TOU_PRINTD("[tou_split] BUF: %s\n", buf);
        tou_llist_appendone(&list, buf, 1);
    }
 
    return list;//tou_llist_get_tail(list);
}
 
 
/*  */
char* tou_sappend(char* dst, char* src)
{
    size_t dst_len = tou_strlen(dst);
    size_t src_len = tou_strlen(src);
 
    size_t new_size = dst_len + src_len + 1;
    dst = realloc(dst, new_size);
    tou_strlcpy(dst + dst_len, src, new_size);
 
    return dst;
}
 
 
/*  */
char* tou_sprepend(char* dst, char* src)
{
    size_t dst_len = tou_strlen(dst);
    size_t src_len = tou_strlen(src);
 
    char* new_mem = malloc(dst_len + src_len + 1);
 
    memcpy(new_mem,           src, src_len);
    memcpy(new_mem + src_len, dst, dst_len + 1); // copy \0 too
 
    return new_mem;
}
 
 
/*  */
char* tou_sreplace(char* str, char* repl_str, char* with_str)
{
    return tou_sreplace_n(str, repl_str, with_str, NULL);
}
 
 
/*  */
char* tou_sreplace_n(char* str, char* repl_str, char* with_str, size_t* len_ptr)
{
    if (!str || !repl_str) {
        TOU_PRINTD("[tou_sreplace_n] string or replace string NULL\n");
        return NULL;
    }
 
    size_t true_len = tou_strlen(str);
    size_t repl_len = tou_strlen(repl_str);
    size_t with_len = tou_strlen(with_str);
    
    size_t len = 0;
    if (len_ptr != NULL) {
        len = *len_ptr;
    }
    if (len == 0 || len > true_len)
        len = true_len;
 
    char tmp_replaced_ch = '\0';
    if (len < true_len) {
        tmp_replaced_ch = str[len];
        str[len] = '\0';
    }
 
    char* search_ptr = str;
    char* dst = NULL;
    char* tmp_dst; // used when realloc'ing dst & when iterating last part
    size_t current_size = 0;
    const int with_alloc_mult = 4; // prealloc for more than one and shrink in the end?
    
    size_t copydiff = 0;
    char* next_with = NULL;
 
    while ((next_with = tou_sfind(search_ptr, repl_str)) != NULL)
    {
        copydiff = next_with - search_ptr;
 
        if ((tmp_dst = realloc(dst, current_size + copydiff + with_len*with_alloc_mult + 1)) == NULL) {
            TOU_PRINTD("[tou_sreplace_n] realloc failed (%zu bytes)\n", current_size + copydiff + with_len*with_alloc_mult + 1);
            if (dst != NULL) // Would be NULL if this was the first replace
                *(dst + current_size) = '\0'; // needed?
            break;
        }
        dst = tmp_dst;
 
        memcpy(dst + current_size,            search_ptr, copydiff);
        memcpy(dst + current_size + copydiff, with_str,   with_len);
        // *(dst + current_size + copydiff + with_len) = '\0';
        
        current_size += copydiff + with_len;
        search_ptr   += copydiff + repl_len;
    }
 
    // Calc size of last one + remainder of source
    size_t rest = tou_strlen(search_ptr); // last part + non-searched remainder since replaced char was returned to place
    if ((tmp_dst = realloc(dst, current_size + rest + 1)) == NULL) {
        TOU_PRINTD("[tou_sreplace_n] last part realloc failed (%zu)\n", current_size + rest + 1);
        return dst;
    }
    dst = tmp_dst;
 
    // Copy the remaining unmodified part from search_ptr to (tmp_)dst
    tmp_dst = dst + current_size;
    while (*search_ptr)
        *(tmp_dst++) = *(search_ptr++);
    *tmp_dst = '\0';
    current_size += rest;
 
    // Restore replaced char if it was needed
    if (tmp_replaced_ch != '\0')
        str[len] = tmp_replaced_ch;
 
    // Resize to fit if larger (?)
    tmp_dst = realloc(dst, current_size + 1);
    if (tmp_dst) {
        // realloc succeded
        if (len_ptr) {
            *len_ptr = current_size;
        }
        return tmp_dst;
    }
 
    // realloc failed
    if (len_ptr) {
        *len_ptr = tou_strlen(dst);
    }
    return dst;
}
 
 
 
 
/*  */
size_t tou_read_fp_in_blocks(FILE* fp, size_t blocksize, tou_func3 cb, void* userdata)
{
    // Clamp blocksize to TOU_DEFAULT_BLOCKSIZE if not in following range:
    if (blocksize < 1 || blocksize > 0xFFFFFF) {
        blocksize = TOU_DEFAULT_BLOCKSIZE;
        TOU_PRINTD("[tou_read_fp_in_blocks] clamping blocksize to "TOU_MSTR(TOU_DEFAULT_BLOCKSIZE)"\n");
    }
 
    size_t curr_bufsize = 0;
    char blockbuf[blocksize];
    size_t bytes_read = 0;
 
    while (1) {
        // Clear buf
        memset(blockbuf, 0, blocksize);
 
        // Load data into buf
        size_t cnt = fread(blockbuf, 1, blocksize, fp);
        if (cnt <= 0)
            break;
 
        // Store real read length
        bytes_read += cnt;
 
        // Do the useful things
        if (cb) {
            if (cb(blockbuf, (void*) cnt, userdata) == TOU_BREAK) {
                // User stopped iteration
                TOU_PRINTD("[tou_read_fp_in_blocks] iteration aborted.\n");
                break;
            }
        }
    }
 
    return bytes_read;
}
 
 
/*  */
void* tou_block_store_cb(void* blockdata, void* len, void* userdata)
{
    char* block = (char*) blockdata;
    size_t size = (size_t) len;
    tou_block_store_struct* data = (tou_block_store_struct*) userdata;
 
    TOU_PRINTD("\n[tou_block_store_cb] Block\n=====\n%.*s (...first %d bytes)\n===== (%zu)\n", (size>64)?64:size, block, (size>64)?64:size, size);
 
    if (size > 0) {
        char* new_buffer = realloc(data->buffer, data->size + size + 1); // accomodate \0
        if (!new_buffer){ 
            TOU_PRINTD("[tou_block_store_cb] cannot realloc memory\n");
            // return (void*) TOU_BREAK;
        } else {
            memcpy(new_buffer + data->size, block, size);
            *(new_buffer + data->size + size) = '\0';
            data->buffer = new_buffer;
            data->size += size;
            TOU_PRINTD("[tou_block_store_cb] appended block {size=%zu}\n", data->size);
        }
    }
    
    return (void*)TOU_CONTINUE;
}
 
/*  */
char* tou_read_file(const char* filename, size_t* read_len)
{
    FILE* fp;
    if (!filename || strlen(filename) == 0 || strcmp("stdin", filename) == 0) { // stdin
        fp = stdin;
    } else if ((fp = fopen(filename, "rb")) == NULL) { // file
        TOU_PRINTD("[read_file] cannot open '%s' (as \"rb\")\n", filename);
        return NULL;
    }
 
    TOU_PRINTD("[read_file] reading from: %s\n", (fp==stdin) ? "STDIN" : filename);
    char* read = tou_read_fp(fp, read_len);
 
    if (fp != stdin) {
        fclose(fp);
        TOU_PRINTD("[read_file] closed.\n");
    }
 
    return read;
}
 
 
/*  */
char* tou_read_fp(FILE* fp, size_t* read_len)
{
    if (fp == NULL)
        return NULL;
 
    TOU_PRINTD("[read_fp] reading from: FILE* %p\n", fp);
 
    // char* read = tou_read_fp_in_blocks(fp, read_len, -1, NULL, NULL); // default block size, without function
    // tou_read_fp_in_blocks -> (FILE* fp, size_t* read_len, size_t blocksize, tou_func3 cb, void* userdata)
    tou_block_store_struct tmp = {NULL, 0};
    tou_read_fp_in_blocks(fp, TOU_DEFAULT_BLOCKSIZE, tou_block_store_cb, &tmp);
    
    TOU_PRINTD("[read_fp] finished reading.\n");
 
    if (read_len)
        *read_len = tmp.size;
 
    return tmp.buffer;
}
 
 
/*  */
int tou_disable_stdout()
{
    TOU_PRINTD("[Disabling stdout.]\n");
    
    fflush(stdout);
    int stdout_fd;
 
#ifdef _WIN32
    // #pragma message "bindobs"
    stdout_fd = _dup(1);
    FILE* fp_nul = fopen(_TOU_DEVNULL_FILE, "w");
    _dup2(_fileno(fp_nul), 1);
    fclose(fp_nul);
 
#elif __linux__
    // #pragma message "bibux"
    stdout_fd = dup(1);
    int new = open(_TOU_DEVNULL_FILE, O_WRONLY);
    dup2(new, 1);
    close(new);
#endif
    
    return stdout_fd;
}
 
 
/*  */
void tou_enable_stdout(int saved_fd)
{
    fflush(stdout);
 
#ifdef _WIN32
    // #pragma message "bindobs"
    _dup2(saved_fd, 1);
    _flushall();
 
#elif __linux__
    // #pragma message "bibux"
    dup2(saved_fd, 1);
    close(saved_fd);
#endif
 
    TOU_PRINTD("[Enabled stdout.]\n");
}
 
 
 
 
/*  */
tou_llist_t* tou_llist_append
(
    tou_llist_t** node_ref,
    void* dat1,
#ifndef TOU_LLIST_SINGLE_ELEM
    void* dat2,
#endif
    char dat1_is_dynalloc
#ifndef TOU_LLIST_SINGLE_ELEM
    , char dat2_is_dynalloc
#endif
) {
    if (node_ref == NULL)
        return NULL;
 
    // Spawn new node
    tou_llist_t* new_node = malloc(sizeof(*new_node));
 
    new_node->prev = NULL;
    new_node->next = NULL;
    
    new_node->dat1 = dat1;
    new_node->destroy_dat1 = dat1_is_dynalloc;
#ifndef TOU_LLIST_SINGLE_ELEM
    new_node->dat2 = dat2;
    new_node->destroy_dat2 = dat2_is_dynalloc;
#endif
 
    // Given node is empty list
    if (*node_ref == NULL) {
        *node_ref = new_node; // Update passed reference to point to the new node
        // printf("[::] LIST IS EMPTY, RETURNING NEW_NODE\n");
        return new_node;
    }
    // Given node/list already has something and this node is head
    tou_llist_t* prev_node = (*node_ref);
    if (prev_node->next == NULL) {
        prev_node->next = new_node; // Update passed node's .next
        new_node->prev = prev_node; // Update new node's .prev
        *node_ref = new_node; // Update passed reference to point to the new node
        // printf("[::] LIST GIVEN IS HEAD, RETURNING NEW_NODE\n");
        return new_node;
    }
 
    // The given node is now somewhere inbetween (after head)
 
    // Setup new node links
    tou_llist_t* previous_next = prev_node->next; // Save previously-next node
    new_node->prev = prev_node; // Update new node's .prev to point to the passed node
    new_node->next = previous_next; // Update new node's .next to
                                    // point to the previously-next node
 
    // Setup previous (current) node links
    prev_node->next = new_node; // Update previously-next node to point to newly created node
    if (previous_next != NULL)
        previous_next->prev = new_node; // If previously-next actually exists,
                                        // make its .prev point to newly created node
 
    // printf("[::] LIST IS IN THE MIDDLE, RETURNING ;  %s\n", (*node_ref)->dat1);
    return new_node;
}
 
 
/*  */
tou_llist_t* tou_llist_appendone(tou_llist_t** elem, void* dat1, char dat1_is_dynalloc)
{
#ifndef TOU_LLIST_SINGLE_ELEM
    return tou_llist_append(elem, dat1, NULL, dat1_is_dynalloc, 0);
#else
    return tou_llist_append(elem, dat1, dat1_is_dynalloc);
#endif
}
 
 
/*  */
tou_llist_t* tou_llist_prepend
(
    tou_llist_t** node_ref,
    void* dat1,
#ifndef TOU_LLIST_SINGLE_ELEM
    void* dat2,
#endif
    char dat1_is_dynalloc,
#ifndef TOU_LLIST_SINGLE_ELEM
    char dat2_is_dynalloc
#endif
) {
    if (node_ref == NULL)
        return NULL;
 
    // Spawn new node
    tou_llist_t* new_node = malloc(sizeof(*new_node));
 
    new_node->prev = NULL;
    new_node->next = NULL;
 
    new_node->dat1 = dat1;
    new_node->destroy_dat1 = dat1_is_dynalloc;
#ifndef TOU_LLIST_SINGLE_ELEM
    new_node->dat2 = dat2;
    new_node->destroy_dat2 = dat2_is_dynalloc;
#endif
 
    // Given node is empty list
    // handle empty list same as append (head <=> tail)
    if (*node_ref == NULL) {
        *node_ref = new_node; // Update passed reference to point to the new node
        return new_node;
    }
 
    // Given node/list already has something and this node is tail
    tou_llist_t* prev_node = (*node_ref);
    if (prev_node->prev == NULL) {
        prev_node->prev = new_node; // Update passed node's .prev
        new_node->next = prev_node; // Update new node's .next
        return new_node;
    }
 
    // The given node is now somewhere inbetween (after tail)
 
    // Setup new node links
    tou_llist_t* previous_prev = prev_node->prev; // Save previously-prev node
    new_node->next = prev_node; // Update new node's .next to point to the passed node
    new_node->prev = previous_prev; // Update new node's .prev to
                                    // point to the previously-prev node
 
    // Setup previous (current) node links
    prev_node->prev = new_node; // Update previously-prev node to point to newly created node
    if (previous_prev != NULL)
        previous_prev->next = new_node; // If previously-prev actually exists,
                                        // make its .next point to newly created node
    return new_node;
}
 
 
/*  */
tou_llist_t* tou_llist_prependone(tou_llist_t** elem, void* dat1, char dat1_is_dynalloc)
{
#ifndef TOU_LLIST_SINGLE_ELEM
    return tou_llist_prepend(elem, dat1, NULL, dat1_is_dynalloc, 0);
#else
    return tou_llist_prepend(elem, dat1, dat1_is_dynalloc);
#endif
}
 
 
/*  */
void tou_llist_destroy(tou_llist_t* list)
{
    if (!list) return;
 
    if (list->next == NULL) { // this is head.
        tou_llist_t *prev, *curr = list;
 
        while (curr != NULL) {
            prev = curr->prev;
            if (curr->destroy_dat1) free(curr->dat1);
#ifndef TOU_LLIST_SINGLE_ELEM
            if (curr->destroy_dat2) free(curr->dat2);
#endif
            curr->prev = NULL;
            free(curr);
            curr = prev;
        }
 
    } else { // this is tail (or inbetween)
        tou_llist_t *next, *curr = list;
        
        while (curr != NULL) {
            next = curr->next;
            if (curr->destroy_dat1) free(curr->dat1);
#ifndef TOU_LLIST_SINGLE_ELEM
            if (curr->destroy_dat2) free(curr->dat2);
#endif
            curr->next = NULL;
            free(curr);
            curr = next;
        }
    }
}
 
 
/*  */
tou_llist_t* tou_llist_remove(tou_llist_t* elem)
{   
    tou_llist_t *next = elem->next, *prev = elem->prev;
    tou_llist_pop(elem);
    tou_llist_free_element(elem);
 
    if (next == NULL) // This element was head
        return prev; // prev will be the new head
    else
        return next; // if assigned, next will be the new head
}
 
 
/*  */
tou_llist_t* tou_llist_pop(tou_llist_t* elem)
{
    if (!elem) return NULL;
 
    if (elem->prev) {
        elem->prev->next = elem->next;
    }
    if (elem->next) {
        elem->next->prev = elem->prev;
    }
 
    return elem;
}
 
 
/*  */
void tou_llist_free_element(tou_llist_t* elem)
{
    if (!elem) return;
 
    if (elem->destroy_dat1) free(elem->dat1);
#ifndef TOU_LLIST_SINGLE_ELEM
    if (elem->destroy_dat2) free(elem->dat2);
#endif
 
    free(elem);
}
 
 
/*  */
tou_llist_t* tou_llist_get_head(tou_llist_t* list)
{
    if (!list) return NULL;
 
    while (list->next)
        list = list->next;
    
    return list;
}
 
 
/*  */
tou_llist_t* tou_llist_get_tail(tou_llist_t* list)
{
    if (!list) return NULL;
 
    while (list->prev)
        list = list->prev;
 
    return list;
}
 
 
/*  */
tou_llist_t* tou_llist_get_newest(tou_llist_t* list)
{
    return tou_llist_get_head(list);
}
 
 
/*  */
tou_llist_t* tou_llist_get_oldest(tou_llist_t* list)
{
    return tou_llist_get_tail(list);
}
 
 
/*  */
tou_llist_t* tou_llist_get_newer(tou_llist_t* elem)
{
    if (elem == NULL) return NULL;
    return elem->next;
}
 
 
/*  */
tou_llist_t* tou_llist_get_older(tou_llist_t* elem)
{
    if (elem == NULL) return NULL;
    return elem->prev;
}
 
 
/*  */
tou_llist_t* tou_llist_next_newer(tou_llist_t** elem)
{
    if (elem == NULL) return NULL;
    return *elem = tou_llist_get_newer(*elem);
}
 
 
/*  */
tou_llist_t* tou_llist_next_older(tou_llist_t** elem)
{
    if (elem == NULL) return NULL;
    return *elem = tou_llist_get_older(*elem);
}
 
 
/*  */
char tou_llist_is_head(tou_llist_t* elem)
{
    return elem == NULL || elem->next == NULL;
}
 
 
/*  */
char tou_llist_is_tail(tou_llist_t* elem)
{
    return elem == NULL || elem->prev == NULL;
}
 
 
/*  */
void tou_llist_iter(tou_llist_t* list, tou_func cb)
{
    if (list == NULL || cb == NULL)
        return;
 
    if (list->next == NULL) { // this is head.
        while (list) {
            if (cb(list) == 0)
                break;
            list = list->prev;
        }
 
    } else { // this is tail (or inbetween)
        while (list) {
            if (cb(list) == 0)
                break;
            list = list->next;
        }
    }
}
 
 
/*  */
tou_llist_t* tou_llist_find_exact
(
    tou_llist_t* list,
    void* dat1
#ifndef TOU_LLIST_SINGLE_ELEM
    , void* dat2
#endif
) {
    if (list == NULL)
        return NULL;
    /* TOU_PRINTD("[find_exact] %p, %p, %p\n", list, dat1, dat2); */
 
    while (list) {
        if (list->dat1 == dat1)
            return list;
#ifndef TOU_LLIST_SINGLE_ELEM
        if (list->dat2 == dat2)
            return list;
#endif
        list = list->prev;
    }
 
    return NULL;
}
 
/*  */
tou_llist_t* tou_llist_find_exactone(tou_llist_t* list, void* dat1)
{
#ifndef TOU_LLIST_SINGLE_ELEM
    if (list == NULL)
        return NULL;
 
    while (list) {
        if (list->dat1 == dat1)
            return list;
        list = list->prev;
    }
 
    return NULL;
#else
 
    return tou_llist_find_exact(list, dat1);
 
#endif
}
 
 
/*  */
tou_llist_t* tou_llist_find_key(tou_llist_t* list, void* dat1)
{
    if (list == NULL)
        return NULL;
 
    while (list) {
        if (strcmp(list->dat1, dat1) == 0) {
            return list;
        }
        list = list->prev;
    }
 
    TOU_PRINTD("[llist_find_key] returning NULL\n");
    return NULL;
}
 
 
/*  */
tou_llist_t* tou_llist_find_func(tou_llist_t* list, tou_func2 cb, void* userdata)
{
    if (list == NULL || cb == NULL)
        return NULL;
 
    while (list) {
        if ((size_t) cb(list, userdata) == TOU_BREAK)
            return list;
        list = list->prev;
    }
 
    return NULL;
}
 
 
/*  */
size_t tou_llist_len(tou_llist_t* list)
{
    if (list == NULL)
        return 0;
 
    size_t len = 0;
 
    if (list->next == NULL) { // this is head.
        while (list) {
            len++;
            list = list->prev;
        }
 
    } else { // this is tail (or inbetween)
        while (list) {
            len++;
            list = list->next;
        }
    }
 
    return len;
}
 
 
/*  */
void** tou_llist_gather_dat1(tou_llist_t* list, size_t* len)
{
    if (list == NULL) {
        TOU_PRINTD("[llist_gather_dat1] received null parameter\n");
        return NULL;
    }
 
    if (len != NULL)
        *len = 0;
 
    size_t _len = tou_llist_len(list);
    if (_len < 1) {
        TOU_PRINTD("[llist_gather_dat1] list has 0 length\n");
        return NULL;
    }
 
    void** gathered;
    if ((gathered = malloc(_len * sizeof(void*))) == NULL) {
        TOU_PRINTD("[llist_gather_dat1] dynamic allocation failed\n");
        return NULL;
    }
 
    for (size_t i = 0; i < _len; i++) {
        gathered[i] = list->dat1;
        list = list->prev;
    }
 
    if (len != NULL)
        *len = _len;
    return gathered;
}
 
 
/*  */
#ifndef TOU_LLIST_SINGLE_ELEM
void** tou_llist_gather_dat2(tou_llist_t* list, size_t* len)
{
    if (list == NULL) {
        TOU_PRINTD("[llist_gather_dat2] received null parameter\n");
        return NULL;
    }
 
    if (len != NULL)
        *len = 0;
 
    size_t _len = tou_llist_len(list);
    if (_len < 1) {
        TOU_PRINTD("[llist_gather_dat2] list has 0 length\n");
        return NULL;
    }
 
    void** gathered;
    if ((gathered = malloc(_len * sizeof(void*))) == NULL) {
        TOU_PRINTD("[llist_gather_dat2] dynamic allocation failed\n");
        return NULL;
    }
 
    for (size_t i = 0; i < _len; i++) {
        gathered[i] = list->dat2;
        list = list->prev;
    }
 
    if (len != NULL)
        *len = _len;
    return gathered;
}
#endif
 
 
 
 
/*  */
tou_llist_t* tou_stack_new()
{
    return tou_llist_new();
}
 
 
/*  */
void tou_stack_destroy(tou_llist_t* stack)
{
    return tou_llist_destroy(stack);
}
 
 
/*  */
size_t tou_stack_len(tou_llist_t* stack)
{
    return tou_llist_len(stack);
}
 
 
/*  */
void tou_stack_push(tou_llist_t** stack, void* elem)
{
    if (stack == NULL)
        return;
    tou_llist_t* top = tou_llist_get_newest(*stack);
    tou_llist_appendone(&top, (void*)elem, 0);
    *stack = top;
    return;
}
 
 
/*  */
void* tou_stack_pop(tou_llist_t** stack)
{
    if (stack == NULL || *stack == NULL)
        return NULL;
 
    tou_llist_t* top = tou_llist_get_newest(*stack);
    if (!top)
        return NULL;
 
    tou_llist_t* saved = tou_llist_get_older(top);
    void* val = tou_llist_pop(top);
    if (val) val = ((tou_llist_t*) val)->dat1;
 
    tou_llist_free_element(top);
    *stack = saved;
 
    return val;
}
 
 
 
 
/*  */
tou_llist_t* tou_queue_new()
{
    return tou_llist_new();
}
 
/*  */
void tou_queue_destroy(tou_llist_t* queue)
{
    return tou_llist_destroy(queue);
}
 
/*  */
size_t tou_queue_len(tou_llist_t* queue)
{
    return tou_llist_len(queue);
}
 
/*  */
void tou_queue_push(tou_llist_t** queue, void* elem)
{
    if (queue == NULL)
        return;
    tou_llist_t* bottom = tou_llist_get_oldest(*queue);
    tou_llist_t* new_elem = tou_llist_prependone(&bottom, (void*)elem, 0);
    if (*queue == NULL)
        *queue = new_elem;
    return;
}
 
/*  */
void* tou_queue_pop(tou_llist_t** queue)
{
    if (queue == NULL)
        return NULL;
    tou_llist_t* top = tou_llist_get_newest(*queue);
    if (top == NULL)
        return NULL;
 
    tou_llist_t* saved = tou_llist_get_older(top);
    void* val = tou_llist_pop(top);
    if (val) val = ((tou_llist_t*) val)->dat1;
 
    tou_llist_free_element(top);
    *queue = saved;
    return val;
}
 
 
 
 
#ifndef TOU_LLIST_SINGLE_ELEM
 
/*  */
tou_llist_t* tou_ini_parse_fp(FILE* fp)
{
    if (fp == NULL) {
        TOU_PRINTD("ini_parse_fp received empty fp\n");
        return NULL;
    }
 
    tou_llist_t* inicontents = tou_llist_new();
    char line_buf[256+1];
    char* line = line_buf;
    size_t line_no = 0;
 
    while (fgets(line, 256+1, fp)) {
        line_no++;
 
        int status = tou_ini_parse_line(&inicontents, line);
        if (status == TOU_BREAK) {
            TOU_PRINTD("Invalid line encountered while parsing (line %zu): %s\n", line_no, line);
            tou_ini_destroy(inicontents);
            return NULL;
        }
    }
 
    return inicontents;
}
 
 
/*  */
tou_llist_t* tou_ini_parse_buffer(char* buf)
{
    if (buf == NULL) {
        TOU_PRINTD("ini_parse_buf received empty buffer\n");
        return NULL;
    }
 
    tou_llist_t* inicontents = tou_llist_new();
    size_t line_no = 0;
 
    char* pos;
    const char* nls[] = {"\r\n", "\n"};
    int found_idx;
 
    while ((pos = tou_sfind_multiple(buf, nls, 2, &found_idx)) != NULL)
    {
        line_no++;
        *pos = '\0';
 
        int status = tou_ini_parse_line(&inicontents, buf);
        if (status == TOU_BREAK) {
            TOU_PRINTD("Invalid line encountered while parsing (line %zu): %s\n", line_no, buf);
            tou_ini_destroy(inicontents);
            return NULL;
        }
 
        buf = pos + strlen(nls[found_idx]);
    }
 
    // Last line
    if (tou_strlen(buf) > 0) {
        line_no++;
        if (tou_ini_parse_line(&inicontents, buf) == TOU_BREAK) {
            TOU_PRINTD("Invalid line encountered while parsing (line %zu): %s\n", line_no, buf);
            tou_ini_destroy(inicontents);
            return NULL;
        }
    }
 
    return inicontents;
}
 
 
/*  */
int tou_ini_parse_line(tou_llist_t** inicontents, char* line)
{
    // Ignore null lines but break if inicontents is null
    if (inicontents == NULL)
        return TOU_BREAK;
    if (line == NULL)
        return TOU_CONTINUE;
 
    // Cut off front whitespace
    tou_trim_front(&line);
    if (*line == '\0')
        return TOU_CONTINUE;
 
    // Check if comment line
    switch(*line) {
        case ';':
        case '#':
            return TOU_CONTINUE;
    }
 
    // Check if section declaration
    if (*line == '[') {
 
        tou_trim_back(&line);
        size_t line_len = strlen(line);
        
        // Cut off front bracket
        line++;
        line_len--;
 
        // If other bracket doesn't exist ignore it and still parse as valid syntax
        if (line[line_len - 1] == ']') {
            line[line_len - 1] = '\0';
            line_len--;
        }
 
        // Append section
        tou_llist_append(inicontents,
            tou_strdup(line), NULL,
            1, 0);
 
        TOU_PRINTD("Appended section: %s\n", (*inicontents)->dat1);
        return TOU_CONTINUE;
    }
 
    // Alright then, check if line matches a property line type; otherwise it's an invalid line
    
    // Test if either delimiter exists in line
    char* prop = tou_sfind(line, " = ");
    int prop_len = 3;
 
    if (prop == NULL) {
        prop = tou_sfind(line, "=");
        prop_len = 1;
 
        // Invalid line
        if (prop == NULL) {
            int len = strlen(line);
            if (line[len - 1] == '\n')
                line[len - 1] = '\0';
            return TOU_BREAK;
        }
    }
 
    // Property encountered before any section declaration
    if (*inicontents == NULL) {
        return TOU_BREAK;
    }
 
    // Duplicate key and value and append to list
    *prop = '\0';
    char* key = line;
    char* val = prop + prop_len;
 
    if (TOU_IS_BLANK(*val)) // Remove leading (only first one) whitespace
        val++;
    tou_trim_back(&key);
    tou_trim_back(&val);
 
    TOU_PRINTD("  Key: %s, Val: %s\n", key, val);
    tou_llist_append((tou_llist_t**)( &((*inicontents)->dat2) ),    // append to "current section" element
        tou_strdup(key), tou_strdup(val),                           // copy key, copy val
        1, 1);                                                      // auto dealloc both key&val
 
    return TOU_CONTINUE;
}
 
 
/*  */
void tou_ini_destroy(tou_llist_t* inicontents)
{
    tou_llist_t* section = inicontents;
    while (section) {
        tou_llist_destroy(section->dat2); // Destroy each props sublist
        TOU_PRINTD("Destroying section: %s\n", section->dat1);
        section = section->prev;
    }
    tou_llist_destroy(inicontents); // Destroy whole structure
    TOU_PRINTD("Destroyed INI structure.\n");
}
 
 
/*  */
void tou_ini_print(tou_llist_t* inicontents)
{
    if (inicontents == NULL) {
        TOU_PRINTD("ini_print received empty struct\n");
        return;
    }
 
    tou_llist_t* section = inicontents;
    tou_llist_t* props;
    fprintf(stdout, "<.INI STRUCTURE>\n");
    fprintf(stdout, " |\n");
 
    while (section) {
        props = section->dat2;
        char next_section_ch = (section->prev == NULL) ? ' ' : '|';
        fprintf(stdout, " +-> [SECTION] \"%s\"\n", (char*)section->dat1);
        while (props) {
            fprintf(stdout, " %c     |\n", next_section_ch);
            fprintf(stdout, " %c     +-> [PROP] \"%s\": \"%s\"\n",
                next_section_ch, (char*)props->dat1, (char*)props->dat2);
            props = props->prev;
        }
        fprintf(stdout, " %c\n", next_section_ch);
        section = section->prev;
    }
}
 
 
/*  */
tou_llist_t* tou_ini_get_section(tou_llist_t* inicontents, const char* section_name)
{
    if (inicontents == NULL || section_name == NULL) {
        TOU_PRINTD("ini_get_section received empty params\n");
        return NULL;
    }
 
    tou_llist_t* sect = tou_llist_find_key(inicontents, (void*)section_name);
    if (sect == NULL) {
        TOU_PRINTD("ini_get_section unable to find given section\n");
        return NULL;
    }
 
    return sect;
}
 
 
/*  */
tou_llist_t* tou_ini_get_property(tou_llist_t* inicontents, const char* section_name, const char* key)
{
    if (inicontents == NULL || section_name == NULL || key == NULL) {
        TOU_PRINTD("ini_get_property received empty params\n");
        return NULL;
    }
 
    tou_llist_t* sect = tou_llist_find_key(inicontents, (void*) section_name);
    if (sect == NULL) {
        TOU_PRINTD("ini_get_property unable to find given section\n");
        return NULL;
    }
    // TOU_PRINTD("TOU_INI_GET_PROPERTY found SECTION %s\n", sect->dat1);
 
    tou_llist_t* prop = tou_llist_find_key(sect->dat2, (void*)key );
    if (prop == NULL) {
        TOU_PRINTD("ini_get_property unable to find given key\n");
    }
 
    return prop;
}
 
 
/*  */
tou_llist_t* tou_ini_section(tou_llist_t* inicontents, const char* section_name)
{
    tou_llist_t* sect = tou_ini_get_section(inicontents, (void*)section_name);
    if (sect == NULL)
        return NULL;
    return sect->dat2;
}
 
 
/*  */
void* tou_ini_property(tou_llist_t* section, const char* property_name)
{
    tou_llist_t* prop = tou_llist_find_key(section, (void*)property_name);
    if (prop == NULL)
        return NULL;
    return prop->dat2;
}
 
 
/*  */
void* tou_ini_get(tou_llist_t* inicontents, const char* section_name, const char* key)
{
    tou_llist_t* prop = tou_ini_get_property(inicontents, section_name, key);
    TOU_PRINTD("ini_get  prop: %p\n", prop);
 
    if (prop)
        return prop->dat2;
    return NULL;
}
 
 
/*  */
void* tou_ini_set(tou_llist_t** inicontents, const char* section_name, const char* key, char* new_value)
{
    if (inicontents == NULL || *inicontents == NULL || section_name == NULL || key == NULL || new_value == NULL) {
        TOU_PRINTD("[ini_set] received empty params\n");
        return NULL;
    }
 
    tou_llist_t* sect = tou_llist_find_key(*inicontents, (void*)section_name);
    if (sect == NULL) {
        TOU_PRINTD("[ini_set] section not found, allocating new...\n");
        // TODO: tou_ini_new_section ?
        sect = tou_llist_append(inicontents, tou_strdup(section_name), NULL, 1, 0);
    }
    
    tou_llist_t* prop = tou_llist_find_key(sect->dat2, (void*)key);
 
    if (prop == NULL) {
        // Allocate new property...
        TOU_PRINTD("[ini_set] property not found\n");
 
        prop = tou_llist_append(
            (tou_llist_t**)(&sect->dat2),
            tou_strdup(key), tou_strdup(new_value),
            1, 1);
 
        TOU_PRINTD("[ini_set] %s, %s\n", prop->dat1, prop->dat2);
        return prop->dat2;
 
    } else {
        // ...or set/realloc the existing one
        TOU_PRINTD("[ini_set] property found\n");
 
        char* old_value = prop->dat2;
        size_t old_len = strlen(old_value);
        size_t new_len = strlen(new_value);
        
        if (new_len > old_len)
            old_value = realloc(old_value, new_len + 1);
 
        tou_strlcpy(old_value, new_value, new_len + 1);
        prop->dat2 = old_value;
 
        return prop->dat2;
    }
}
 
 
/*  */
int tou_ini_save_fp(tou_llist_t* inicontents, FILE* fp)
{
    if (inicontents == NULL || fp == NULL) {
        TOU_PRINTD("[ini_save_fp] received empty params\n");
        return -1;
    }
    
    tou_llist_t* section = inicontents;
    while (section) {
        if (section->dat1 == NULL) {
            TOU_PRINTD("[ini_save_fp] Invalid section name encountered\n");
            return -3;
        }
        // Print section name
        fprintf(fp, "[%s]", (char*)section->dat1);
        if (ferror(fp)) {
            TOU_PRINTD("[ini_save_fp] Error writing to stream\n");
            return -2;
        }
        
        tou_llist_t* prop = section->dat2;
        while (prop) {
            if (prop->dat1 == NULL || prop->dat2 == NULL) {
                TOU_PRINTD("[ini_save_fp] Invalid property data encountered\n");
                return -4;
            }
            fprintf(fp, "\n%s = %s", (char*)prop->dat1, (char*)prop->dat2);
            prop = prop->prev;
        }
 
        fprintf(fp, "\n");
        section = section->prev;
    }
 
    return 0;
}
 
 
/*  */
int tou_ini_save_fp_json(tou_llist_t* inicontents, FILE* fp)
{
    if (inicontents == NULL || fp == NULL) {
        TOU_PRINTD("[ini_save_fp_json] received empty params\n");
        return -1;
    }
    
    // Print initial json struct and metadata
    fprintf(fp, "{\n\t\"ver\": " TOU_MSTR(TOU_JSON_DATA_VER) ",\n\t\"sections\": {");
    if (ferror(fp)) {
        TOU_PRINTD("[ini_save_fp_json] Error writing to stream\n");
        return -2;
    }
 
    tou_llist_t* section = inicontents;
    // size_t nsections = 0;
    while (section) {
        if (section->dat1 == NULL) {
            TOU_PRINTD("[ini_save_fp_json] Invalid section name encountered\n");
            return -3;
        }
        // Print section name
        fprintf(fp, "\n\t\t\"%s\": {", section->dat1);
        
        tou_llist_t* prop = section->dat2;
        // size_t nprops = 0;
        while (prop) {
            if (prop->dat1 == NULL || prop->dat2 == NULL) {
                TOU_PRINTD("[ini_save_fp_json] Invalid property data encountered\n");
                return -4;
            }
 
            // Print property
            fprintf(fp, "%s\n\t\t\t\"%s\": \"%s\"", (prop==section->dat2 ? "":","), prop->dat1, prop->dat2);
            // nprops++;
            prop = prop->prev;
        }
 
        fprintf(fp, "\n\t\t}%s", (section->prev==NULL ? "":","));
        // nsections++;
        section = section->prev;
    }
 
    // fprintf(fp, "\n\t},\n\t\"section_count\": %zu\n}\n", nsections);
    fprintf(fp, "\n\t}\n}");
 
    return 0;
}
 
/*  */
int tou_ini_save_fp_xml(tou_llist_t* inicontents, FILE* fp)
{
    if (inicontents == NULL || fp == NULL) {
        TOU_PRINTD("[ini_save_fp_xml] received empty params\n");
        return -1;
    }
    tou_llist_t* section = inicontents;
    
    // Print initial json struct and metadata
    const char* root_tag = "root";
    fprintf(fp, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
    fprintf(fp, "<%s ver="TOU_MSTR(TOU_XML_DATA_VER)" len=\"%zu\">", root_tag, tou_llist_len(inicontents));
    if (ferror(fp)) {
        TOU_PRINTD("[ini_save_fp_xml] Error writing to stream\n");
        return -2;
    }
 
    while (section) {
        if (section->dat1 == NULL) {
            TOU_PRINTD("[ini_save_fp_xml] Invalid section name encountered\n");
            return -3;
        }
        tou_llist_t* prop = section->dat2;
 
        // Print section name and attr(s)
        char* sect_name_tag = tou_replace_ch(strdup(section->dat1), ' ', '-');
        fprintf(fp, "\n\t<%s len=\"%zu\">", sect_name_tag, tou_llist_len(prop));
        
        while (prop) {
            if (prop->dat1 == NULL || prop->dat2 == NULL) {
                TOU_PRINTD("[ini_save_fp_xml] Invalid property data encountered\n");
                return -4;
            }
            char* prop_name_tag = tou_replace_ch(tou_strdup(prop->dat1), ' ', '-');
 
            // Print property
            fprintf(fp, "\n\t\t<%s>%s</%s>", prop_name_tag, prop->dat2, prop_name_tag);
            prop = prop->prev;
        }
 
        fprintf(fp, "\n\t</%s>", sect_name_tag);
        section = section->prev;
    }
 
    fprintf(fp, "\n</%s>", root_tag);
 
    return 0;
}
 
#endif
 
 
 
#ifndef TOU_LLIST_SINGLE_ELEM
 
/*  */
tou_llist_t* tou_paramparse(char* str, const char* param_sep, const char* keyval_sep)
{
    return tou_paramparse_n(str, param_sep, keyval_sep, 0);
}
 
 
/*  */
tou_llist_t* tou_paramparse_n(char* str, const char* param_sep, const char* keyval_sep, size_t maxlen)
{
    size_t psep_len = strlen(param_sep);
    size_t kvsep_len = strlen(keyval_sep);
 
    if (maxlen == 0)
        maxlen = strlen(str);
 
    // save char to restore it later //
    char saved = str[maxlen];
    str[maxlen] = '\0';
    
    // parse //
    // Initially split by param separator and afterwards parse each param
    tou_llist_t* params = tou_split(str, param_sep);
 
    while (params) {
        if (!params->dat1)
            params = params->prev;
 
        bool dont = false;
        char* trimmed_both = params->dat1;
        tou_trim_string(&trimmed_both); // trim to beginning of the key at the front, and the back of the value
        size_t both_len = strlen(trimmed_both);
 
        if (strlen(trimmed_both) > 0) { // in case split() inserted empty "" element
            // params->dat1 dupe will be done after processing value
            
            // Find value offset from current key ptr
            char* sep = tou_sfind(trimmed_both, keyval_sep);
            if (sep) {
                *sep = '\0'; // cuts off key name in dat1 to be realloc'd later
                char* trimmed_val = sep + kvsep_len;
                tou_trim_front(&trimmed_val);
 
                params->dat2 = tou_strdup(trimmed_val);
                
                if (params->dat2 != NULL)
                    params->destroy_dat2 = 1;
            } else {
                params->dat2 = NULL;
                params->destroy_dat2 = 0;
            }
            
            // There's a '\0' either at the separator or at the end
            // so this trims back of the key
            size_t trimmed_key_len = tou_trim_back(&trimmed_both) - trimmed_both;
            memmove(params->dat1, trimmed_both, trimmed_key_len + 1); // move trimmed key to front
            params->dat1 = realloc(params->dat1, trimmed_key_len + 1); // free(params->dat1)
            params->destroy_dat1 = 1;
 
        } else {
            // remove this empty element
            // TODO: does the updated llist_remove() perform this operation?
            tou_llist_pop(params);
            char prev_was_null = (params->prev == NULL);
            tou_llist_t* relink = (params->prev) ? params->prev : params->next;
            tou_llist_free_element(params);
            params = relink;
 
            if (prev_was_null)
                break;
 
            dont = true; // don't process params->prev as usual since we just adjusted list
        }
        if (!dont) params = params->prev;
    }
 
    // restore char
    str[maxlen] = saved;
 
    return tou_llist_get_head(params);
}
 
 
/*  */
void tou_paramprint(tou_llist_t* params)
{
    params = tou_llist_get_oldest(params);
    printf("Parameters (%d):\n", tou_llist_len(params));
    while (params) {
        printf("  \"%s\" : %p\n", params->dat1, params->dat2);
        tou_llist_next_newer(&params);
    }
    printf("\n");
}
 
#endif
 
 
/* Loading icon
printf("⣿ ⣾⣽⣻⢿⡿⣟⣯⣷\n");
printf("⠿ ⠾⠽⠻⠟⠯⠷\n"); */
 
 
#endif // TOU_IMPLEMENTATION_DONE
#endif // TOU_IMPLEMENTATION