str.h

Go to the documentation of this file.

/*
 * 🧵 str — str.h
 * Copyright (c) 2025–2026 Fawn <rubiefawn@proton.me>
 *
 * 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.
 */

#pragma once
#include <stddef.h>
#if __STDC_VERSION__ < 202311L
    #include <stdbool.h>
#endif

typedef struct str {
    char *data; 
    size_t len; 
} str;

#define str_literal(SZ_LITERAL) (str){ (SZ_LITERAL), sizeof(SZ_LITERAL) - 1 }

str str_from_cstr(char *sz);

str str_slice_cstr(char *sz, size_t len);

str str_strip_whitespace_pre(str it);

str str_strip_whitespace_post(str it);

str str_strip_whitespace(str it);

str str_strip_prefix_str(str it, str prefix);

str str_strip_prefix_cstr(str it, const char *prefix);

str str_strip_prefix_if(str it, bool (*predicate)(char));

#define str_strip_prefix(IT, PREFIX) _Generic((PREFIX),\
    const str            : str_strip_prefix_str,\
          str            : str_strip_prefix_str,\
    const char*          : str_strip_prefix_cstr,\
          char*          : str_strip_prefix_cstr,\
    bool (*)(char c)     : str_strip_prefix_if\
)((IT), (PREFIX))

str str_strip_postfix_str(str it, str postfix);

str str_strip_postfix_cstr(str it, const char *postfix);

str str_strip_postfix_if(str it, bool (*predicate)(char));

#define str_strip_postfix(IT, POSTFIX) _Generic((POSTFIX),\
    const str            : str_strip_postfix_str,\
          str            : str_strip_postfix_str,\
    const char*          : str_strip_postfix_cstr,\
          char*          : str_strip_postfix_cstr,\
    bool (*)(char c)     : str_strip_postfix_if\
)((IT), (POSTFIX))

int str_cmp_str(str a, str b);

int str_cmp_cstr(str a, const char *b);

int cstr_cmp_str(const char *a, str b);

#define cstr_cmp_cstr strcmp

#define str_cmp(LHS, RHS) _Generic((LHS),\
    const str: _Generic((RHS),\
        const str  : str_cmp_str,\
              str  : str_cmp_str,\
        const char*: str_cmp_cstr,\
              char*: str_cmp_cstr\
    ),\
    str: _Generic((RHS),\
        const str  : str_cmp_str,\
              str  : str_cmp_str,\
        const char*: str_cmp_cstr,\
              char*: str_cmp_cstr\
    ),\
    const char*: _Generic((RHS),\
        const str  : cstr_cmp_str,\
              str  : cstr_cmp_str,\
        const char*: strcmp,\
              char*: strcmp\
    ),\
    char*: _Generic((RHS),\
        const str  : cstr_cmp_str,\
              str  : cstr_cmp_str,\
        const char*: strcmp,\
              char*: strcmp\
    )\
)((LHS), (RHS))

bool str_eq_str(str a, str b);

bool str_eq_cstr(str a, const char *b);

bool cstr_eq_str(const char *a, str b);

bool cstr_eq_cstr(const char *a, const char *b);

#define str_eq(LHS, RHS) _Generic((LHS),\
    const str: _Generic((RHS),\
        const str  : str_eq_str,\
              str  : str_eq_str,\
        const char*: str_eq_cstr,\
              char*: str_eq_cstr\
    ),\
    str: _Generic((RHS),\
        const str  : str_eq_str,\
              str  : str_eq_str,\
        const char*: str_eq_cstr,\
              char*: str_eq_cstr\
    ),\
    const char*: _Generic((RHS),\
        const str  : cstr_eq_str,\
              str  : cstr_eq_str,\
        const char*: cstr_eq_cstr,\
              char*: cstr_eq_cstr\
    ),\
    char*: _Generic((RHS),\
        const str  : cstr_eq_str,\
              str  : cstr_eq_str,\
        const char*: cstr_eq_cstr,\
              char*: cstr_eq_cstr\
    )\
)((LHS), (RHS))

size_t str_eq_str_any(str it, size_t count, ...);

size_t str_eq_strs_any(str it, size_t count, const str others[static count]);

size_t str_eq_cstr_any(str it, size_t count, ...);

size_t str_eq_cstrs_any(str it, size_t count, const char *others[static count]);

size_t cstr_eq_str_any(const char *it, size_t count, ...);

size_t cstr_eq_strs_any(const char *it, size_t count, const str others[static count]);

size_t cstr_eq_cstr_any(const char *it, size_t count, ...);

size_t cstr_eq_cstrs_any(const char *it, size_t count, const char *others[static count]);

#if __STDC_VERSION__ >= 202311L
    #define str_eq_any(LHS, COUNT, RHS, ...) _Generic((LHS),\
        const str: _Generic((RHS),\
            const str   : str_eq_str_any,\
                  str   : str_eq_str_any,\
            const str*  : str_eq_strs_any,\
                  str*  : str_eq_strs_any,\
            const char* : str_eq_cstr_any,\
                  char* : str_eq_cstr_any,\
            const char**: str_eq_cstrs_any,\
                  char**: str_eq_cstrs_any\
        ),\
        str: _Generic((RHS),\
            const str   : str_eq_str_any,\
                  str   : str_eq_str_any,\
            const str*  : str_eq_strs_any,\
                  str*  : str_eq_strs_any,\
            const char* : str_eq_cstr_any,\
                  char* : str_eq_cstr_any,\
            const char**: str_eq_cstrs_any,\
                  char**: str_eq_cstrs_any\
        ),\
        const char*: _Generic((RHS),\
            const str   : cstr_eq_str_any,\
                  str   : cstr_eq_str_any,\
            const str*  : cstr_eq_strs_any,\
                  str*  : cstr_eq_strs_any,\
            const char* : cstr_eq_cstr_any,\
                  char* : cstr_eq_cstr_any,\
            const char**: cstr_eq_cstrs_any,\
                  char**: cstr_eq_cstrs_any\
        ),\
        char*: _Generic((RHS),\
            const str   : cstr_eq_str_any,\
                  str   : cstr_eq_str_any,\
            const str*  : cstr_eq_strs_any,\
                  str*  : cstr_eq_strs_any,\
            const char* : cstr_eq_cstr_any,\
                  char* : cstr_eq_cstr_any,\
            const char**: cstr_eq_cstrs_any,\
                  char**: cstr_eq_cstrs_any\
        )\
    )((LHS), (COUNT), (RHS) __VA_OPT__(, __VA_ARGS__))
#elif defined(__GNUC__)
    #define str_eq_any(LHS, COUNT, RHS, ...) _Generic((LHS),\
        const str: _Generic((RHS),\
            const str   : str_eq_str_any,\
                  str   : str_eq_str_any,\
            const str*  : str_eq_strs_any,\
                  str*  : str_eq_strs_any,\
            const char* : str_eq_cstr_any,\
                  char* : str_eq_cstr_any,\
            const char**: str_eq_cstrs_any,\
                  char**: str_eq_cstrs_any\
        ),\
        str: _Generic((RHS),\
            const str   : str_eq_str_any,\
                  str   : str_eq_str_any,\
            const str*  : str_eq_strs_any,\
                  str*  : str_eq_strs_any,\
            const char* : str_eq_cstr_any,\
                  char* : str_eq_cstr_any,\
            const char**: str_eq_cstrs_any,\
                  char**: str_eq_cstrs_any\
        ),\
        const char*: _Generic((RHS),\
            const str   : cstr_eq_str_any,\
                  str   : cstr_eq_str_any,\
            const str*  : cstr_eq_strs_any,\
                  str*  : cstr_eq_strs_any,\
            const char* : cstr_eq_cstr_any,\
                  char* : cstr_eq_cstr_any,\
            const char**: cstr_eq_cstrs_any,\
                  char**: cstr_eq_cstrs_any\
        ),\
        char*: _Generic((RHS),\
            const str   : cstr_eq_str_any,\
                  str   : cstr_eq_str_any,\
            const str*  : cstr_eq_strs_any,\
                  str*  : cstr_eq_strs_any,\
            const char* : cstr_eq_cstr_any,\
                  char* : cstr_eq_cstr_any,\
            const char**: cstr_eq_cstrs_any,\
                  char**: cstr_eq_cstrs_any\
        )\
    )((LHS), (COUNT), (RHS), ##__VA_ARGS__)
#else
    #warning Neither C23's __VA_OPT__ nor GNU's ##__VA_ARGS__ are available, str_eq_any() will be unavailable
#endif

size_t str_satisfies_any(str it, size_t count, ...);

size_t str_satisfies_anys(str it, size_t count, bool (*predicates[static count])(str));

size_t cstr_satisfies_any(const char *it, size_t count, ...);

size_t cstr_satisfies_anys(const char *it, size_t count, bool (*predicates[static count])(const char*));

bool str_satisfies_all(str it, size_t count, ...);

bool str_satisfies_alls(str it, size_t count, bool (*predicates[static count])(str));

bool cstr_satisfies_all(const char *it, size_t count, ...);

bool cstr_satisfies_alls(const char *it, size_t count, bool (*predicates[static count])(const char*));

bool str_chars_satisfies(str it, bool (*predicate)(char));

bool cstr_chars_satisfies(const char *it, bool (*predicate)(char));

size_t str_has_prefix_str(str it, str prefix);

size_t str_has_prefix_cstr(str it, const char *prefix);

size_t cstr_has_prefix_str(const char *it, str prefix);

size_t cstr_has_prefix_cstr(const char *it, const char *prefix);

size_t str_has_postfix_str(str it, str postfix);

size_t str_has_postfix_cstr(str it, const char *postfix);

size_t cstr_has_postfix_str(const char *it, str postfix);

size_t cstr_has_postfix_cstr(const char *it, const char *postfix);

#define str_has_prefix(LHS, RHS) _Generic((LHS),\
    const str: _Generic((RHS),\
        const str  : str_has_prefix_str,\
              str  : str_has_prefix_str,\
        const char*: str_has_prefix_cstr,\
              char*: str_has_prefix_cstr\
    ),\
    str: _Generic((RHS),\
        const str  : str_has_prefix_str,\
              str  : str_has_prefix_str,\
        const char*: str_has_prefix_cstr,\
              char*: str_has_prefix_cstr\
    ),\
    const char*: _Generic((RHS),\
        const str  : cstr_has_prefix_str,\
              str  : cstr_has_prefix_str,\
        const char*: cstr_has_prefix_cstr,\
              char*: cstr_has_prefix_cstr\
    ),\
    char*: _Generic((RHS),\
        const str  : cstr_has_prefix_str,\
              str  : cstr_has_prefix_str,\
        const char*: cstr_has_prefix_cstr,\
              char*: cstr_has_prefix_cstr\
    )\
)((LHS), (RHS))

#define str_has_postfix(LHS, RHS) _Generic((LHS),\
    const str: _Generic((RHS),\
        const str  : str_has_postfix_str,\
              str  : str_has_postfix_str,\
        const char*: str_has_postfix_cstr,\
              char*: str_has_postfix_cstr\
    ),\
    str: _Generic((RHS),\
        const str  : str_has_postfix_str,\
              str  : str_has_postfix_str,\
        const char*: str_has_postfix_cstr,\
              char*: str_has_postfix_cstr\
    ),\
    const char*: _Generic((RHS),\
        const str  : cstr_has_postfix_str,\
              str  : cstr_has_postfix_str,\
        const char*: cstr_has_postfix_cstr,\
              char*: cstr_has_postfix_cstr\
    ),\
    char*: _Generic((RHS),\
        const str  : cstr_has_postfix_str,\
              str  : cstr_has_postfix_str,\
        const char*: cstr_has_postfix_cstr,\
              char*: cstr_has_postfix_cstr\
    )\
)((LHS), (RHS))