colr.h (0.4.0)

Go to the documentation of this file.

#ifndef COLR_H
#define COLR_H

#define COLR_VERSION "0.4.0"

/* Tell gcc to ignore clang pragmas, for linting. */
#pragma GCC diagnostic ignored "-Wunknown-pragmas"

#ifndef DOXYGEN_SKIP

#if (__STDC_VERSION__ >= 201112L)
    #if defined(__GNUC__) && !defined(__clang__)
        #if (__GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9))
            #define IS_C11
        #endif
    #else
        #define IS_C11
    #endif
#endif
#endif // DOXYGEN_SKIP

// Without _Generic, ColrC is useless.
#ifndef IS_C11
    #error "ColrC cannot compile without C11+ generic selections (_Generic)."
#endif

// ColrC uses GNU extensions.
#if defined(__GNUC__)
    #if !defined(_GNU_SOURCE)
        /*
            This enables gnu extensions.
            ColrC will not compile at all without this.
            Current GNU dependencies:
                Optional:
                    Statement-Expressions in fore_str_static/back_str_static
                    register_printf_specifier from printf.h.
                Required:
                     stdio.h: asprintf()
                    locale.h: uselocale(), LC_GLOBAL_LOCALE
                    string.h: strndup(), strdup(), strcmp(), strcasecmp(), strnlen()
                      math.h: sin(), M_PI
        */
        #define _GNU_SOURCE
    #elif _GNU_SOURCE < 1
        // This is for testing. If _GNU_SOURCE=0 is set, it will be undefined,
        // and I can watch all of the warnings and errors that pop up.
        #undef _GNU_SOURCE
        #pragma GCC warning "Trying to compile without _GNU_SOURCE, this will not work."
    #endif
    #pragma clang diagnostic push
    #pragma clang diagnostic ignored "-Wmacro-redefined"

    #define COLR_GNU
    #pragma clang diagnostic pop // -Wmacro-redefined
#else
    #pragma GCC warning "ColrC uses GNU extensions that your system doesn't support."
    #if defined(COLR_GNU)
        #pragma GCC warning "ColrC GNU extensions are enabled (COLR_GNU) for a non-GNU system."
    #else
        #pragma GCC warning "No glibc and COLR_GNU=0, some features will be disabled."
    #endif
#endif

#include <assert.h>
// assert() uses a statement-expression when compiling with __GNUC__ defined.
// This is here to silence clang linters.
#pragma clang diagnostic ignored "-Wgnu-statement-expression"

#include <ctype.h> // islower, iscntrl, isdigit, etc.
/*  Must include `-lm` in compiler args or Makefile LIBS!
    This is for the `sin()` function used in `rainbow_step()`.
*/
#include <math.h>
#include <limits.h> // Used for asprintf return checking.
#include <locale.h> // Not used in colr.c, but necessary for users of rainbow stuff.
#ifdef COLR_GNU
    #include <printf.h> // For register_printf_specifier.
#endif
#include <regex.h> // For colr_str_replace_re and friends.
#include <stdarg.h> // Variadic functions and `va_list`.
#include <stdbool.h>
#include <stdint.h> // marker integers for colr structs
#include <stdio.h> // snprintf, fileno, etc.
#include <stdlib.h> // calloc, free, malloc, etc.
#include <string.h> // strcat
#include <sys/ioctl.h> //  For `struct winsize` and the `ioctl()` call to use it.
#include <unistd.h> // isatty
#include <wchar.h>
/* This is only enabled for development. */
#if defined(DEBUG) && defined(COLR_DEBUG)
    #include "dbug.h"
#endif
/* Tell gcc to ignore unused macros. */
#pragma GCC diagnostic ignored "-Wunused-macros"

#define CODE_RESET_ALL "\x1b[0m"
#define CODE_RESET_BACK "\x1b[49m"
#define CODE_RESET_FORE "\x1b[39m"
#define WCODE_RESET_BACK L"\x1b[49m"
#define WCODE_RESET_FORE L"\x1b[39m"
#define WCODE_RESET_ALL L"\x1b[0m"
#define NC CODE_RESET_ALL
#define NCNL CODE_RESET_ALL "\n"
#define WNC WCODE_RESET_ALL
#define WNCNL WCODE_RESET_ALL L"\n"

#define CODE_RESET_LEN 5

#define CODE_LEN_MIN 5

#define CODE_LEN 14

#define CODEX_LEN_MIN 10
#define CODEX_LEN 12

#define STYLE_LEN_MIN 5
#define STYLE_LEN 6

#define COLOR_LEN 30

#define CODE_RGB_LEN_MIN 14
#define CODE_RGB_LEN 20

#define COLOR_RGB_LEN 26

#define CODE_ANY_LEN 46

#define COLORARG_MARKER UINT32_MAX

#define COLORLASTARG_MARKER (UINT32_MAX - 20)

#define COLORJUSTIFY_MARKER (UINT32_MAX - 30)

#define COLORRESULT_MARKER (UINT32_MAX - 40)

#define COLORTEXT_MARKER (UINT32_MAX - 50)

#define COLOR_INVALID (-2)
#define COLOR_INVALID_RANGE (-3)

#define COLR_HASH_SEED 5381

#ifndef COLR_FMT
    #define COLR_FMT "R"
#endif
#pragma info "Set COLR_FMT=" COLR_FMT

#define COLR_FMT_CHAR COLR_FMT[0]
#define COLR_FMT_MOD_ESC "/"
#define COLR_FMT_MOD_ESC_CHAR COLR_FMT_MOD_ESC[0]

extern int colr_printf_esc_mod;

#define EXT_INVALID COLOR_INVALID

#define EXT_INVALID_RANGE COLOR_INVALID_RANGE

#define alloc_basic() calloc(CODE_LEN, sizeof(char))

#define alloc_extended() calloc(CODEX_LEN, sizeof(char))


#define alloc_rgb() calloc(CODE_RGB_LEN, sizeof(char))

#define alloc_style() calloc(STYLE_LEN, sizeof(char))


#define asprintf_or_return(retval, ...) if_not_asprintf(__VA_ARGS__) return retval


#define back(x) ColorArg_to_ptr(back_arg(x))

#define back_arg(x) \
    _Generic( \
        (x), \
        char* : ColorArg_from_str, \
        RGB: ColorArg_from_RGB, \
        BasicValue: ColorArg_from_BasicValue, \
        ExtendedValue: ColorArg_from_ExtendedValue, \
        StyleValue: ColorArg_from_StyleValue \
    )(BACK, x)

#define back_str(x) ColorArg_to_esc(back_arg(x))

#ifdef COLR_GNU

#define back_str_static(x) \
    __extension__ ({ \
        __typeof(x) _bss_val = x; \
        ColorArg _bss_carg = back_arg(_bss_val); \
        size_t _bss_len = ColorArg_length(_bss_carg); \
        char* _bss_codes = alloca(_bss_len); \
        ColorArg_to_esc_s(_bss_codes, _bss_carg); \
        _bss_codes; \
    })
    /*  A Variable Length Array will not work here.
        The space for `_bss_codes` would be deallocated before this statement
        expression returns. Using `alloca` ensures that it will live at least
        as long as the calling function.
        See:
            https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html#index-_002a_005f_005fbuiltin_005falloca
    */
#endif // COLR_GNU

#define basic(x) ((BasicValue)(x))

#define bool_colr_enum(x) (x < 0 ? false: true)

#define color_arg(type, x) \
    _Generic( \
        (x), \
        char*: ColorArg_from_str(type, x), \
        BasicValue: ColorArg_from_value(type, TYPE_BASIC, &x), \
        ExtendedValue: ColorArg_from_value(type, TYPE_EXTENDED, &x), \
        StyleValue: ColorArg_from_value(type, TYPE_STYLE, &x), \
        RGB: ColorArg_from_value(type, TYPE_RGB, &x) \
    )

#define color_name_is_invalid(x) ColorType_is_invalid(ColorType_from_str(x))

#define color_name_is_valid(x) ColorType_is_valid(ColorType_from_str(x))

#define color_val(x) \
    _Generic( \
        (x), \
        BasicValue: ColorValue_from_value(TYPE_BASIC, &x), \
        ExtendedValue: ColorValue_from_value(TYPE_EXTENDED, &x), \
        StyleValue: ColorValue_from_value(TYPE_STYLE, &x), \
        RGB: ColorValue_from_value(TYPE_RGB, &x) \
    )


#define ColorText_center(text, justwidth, ...) ColorText_set_just( \
        Colr(text, __VA_ARGS__), \
        (ColorJustify){.method=JUST_CENTER, .width=justwidth, .padchar=' '} \
    )

#define ColorText_center_char(text, justwidth, c, ...) ColorText_set_just( \
        Colr(text, __VA_ARGS__), \
        (ColorJustify){.method=JUST_CENTER, .width=justwidth, .padchar=c} \
    )

#define ColorText_ljust(text, justwidth, ...) ColorText_set_just( \
        Colr(text, __VA_ARGS__), \
        (ColorJustify){.method=JUST_LEFT, .width=justwidth, .padchar=' '} \
    )

#define ColorText_ljust_char(text, justwidth, c, ...) ColorText_set_just( \
        Colr(text, __VA_ARGS__), \
        (ColorJustify){.method=JUST_LEFT, .width=justwidth, .padchar=c} \
    )

#define ColorText_rjust(text, justwidth, ...) ColorText_set_just( \
        Colr(text, __VA_ARGS__), \
        (ColorJustify){.method=JUST_RIGHT, .width=justwidth, .padchar=' '} \
    )

#define ColorText_rjust_char(text, justwidth, c, ...) ColorText_set_just( \
        Colr(text, __VA_ARGS__), \
        (ColorJustify){.method=JUST_RIGHT, .width=justwidth, .padchar=c} \
    )

#define ColorValue_has(cval, val) \
    _Generic( \
        (val), \
        BasicValue: ColorValue_has_BasicValue, \
        ExtendedValue: ColorValue_has_ExtendedValue, \
        StyleValue: ColorValue_has_StyleValue, \
        RGB: ColorValue_has_RGB \
    )(cval, val)

#define Colr(text, ...) ColorText_to_ptr(ColorText_from_values(text, __VA_ARGS__, _ColrLastArg))

#define Colra(text, ...) ColorText_from_values(text, __VA_ARGS__, _ColrLastArg)

#define Colr_cat(...) ColorResult_to_ptr(ColorResult_new(colr_cat(__VA_ARGS__)))

#define Colr_center(x, width) \
    _Generic( \
        (x), \
        char*: Colr_center_char, \
        const char*: Colr_center_char, \
        ColorResult*: Colr_center_char, \
        ColorText*: Colr_center_char \
        )(x, width, ' ')

#define Colr_fmt(fmt, value, ...) \
    ColorResult_Colr( \
        Colr_fmt_str(fmt, value), \
        __VA_ARGS__, \
        _ColrLastArg \
    )

#define Colr_join(joiner, ...) ColrResult(colr_join(joiner, __VA_ARGS__))

#define Colr_ljust(x, width) \
    _Generic( \
        (x), \
        char*: Colr_ljust_char, \
        const char*: Colr_ljust_char, \
        ColorResult*: Colr_ljust_char, \
        ColorText*: Colr_ljust_char \
        )(x, width, ' ')

#define Colr_rjust(x, width) \
    _Generic( \
        (x), \
        char*: Colr_rjust_char, \
        const char*: Colr_rjust_char, \
        ColorResult*: Colr_rjust_char, \
        ColorText*: Colr_rjust_char \
        )(x, width, ' ')

#define ColrResult(s) ColorResult_to_ptr(ColorResult_new(s))

#define ColrColorResult(cres, ...) ColorResult_Colr(cres, __VA_ARGS__, _ColrLastArg)

#define colr(text, ...) colr_cat(Colr(text, __VA_ARGS__))

#define colr_cat(...) _colr_join("", __VA_ARGS__, _ColrLastArg)

#define colr_center(x, width) colr_center_char(x, width, ' ')

#define colr_center_char(x, width, padchar) ColorResult_rip_str( \
    _Generic( \
        (x), \
        char*: Colr_center_char, \
        const char*: Colr_center_char, \
        ColorResult*: Colr_center_char, \
        ColorText*: Colr_center_char \
    )(x, width, padchar))

#define colr_alloc_len(x) \
    _Generic( \
        (x), \
        RGB: CODE_RGB_LEN, \
        BasicValue: CODE_LEN, \
        ExtendedValue: CODEX_LEN, \
        StyleValue: STYLE_LEN \
    )

#define colr_eq(a, b) \
    _Generic( \
        (a), \
        ArgType: ArgType_eq, \
        BasicValue: BasicValue_eq, \
        ColorArg: ColorArg_eq, \
        ColorJustify: ColorJustify_eq, \
        ColorResult: ColorResult_eq, \
        ColorType: ColorType_eq, \
        ColorValue: ColorValue_eq, \
        ExtendedValue: ExtendedValue_eq, \
        RGB: RGB_eq, \
        StyleValue: StyleValue_eq \
    )(a, b)

#define colr_example(x) \
    _Generic( \
        (x), \
        ColorArg: ColorArg_example, \
        ColorValue: ColorValue_example \
    )(x)

#define colr_fprint(file, ...) \
    do { \
        char* _c_p_s = colr_cat(__VA_ARGS__); \
        if (!_c_p_s) break; \
        fprintf(file, "%s", _c_p_s); \
        colr_free(_c_p_s); \
    } while (0)

#define colr_free(x) \
    _Generic( \
        (x), \
        ColorArg*: ColorArg_free, \
        ColorArg**: ColorArgs_array_free, \
        ColorResult*: ColorResult_free, \
        ColorText*: ColorText_free, \
        regmatch_t**: colr_free_re_matches, \
        default: _colr_free \
    )(x)

#define colr_is_empty(x) \
    _Generic( \
        (x), \
        char*: colr_str_is_empty, \
        const char*: colr_str_is_empty, \
        ColorArg: ColorArg_is_empty, \
        ColorJustify: ColorJustify_is_empty, \
        ColorText: ColorText_is_empty, \
        ColorValue: ColorValue_is_empty \
    )(x)

#define colr_is_invalid(x) \
    _Generic( \
        (x), \
        BasicValue: BasicValue_is_invalid, \
        ExtendedValue: ExtendedValue_is_invalid, \
        StyleValue: StyleValue_is_invalid, \
        ColorArg: ColorArg_is_invalid, \
        ColorType: ColorType_is_invalid, \
        ColorValue: ColorValue_is_invalid \
    )(x)

#define colr_is_valid(x) \
    _Generic( \
        (x), \
        BasicValue: BasicValue_is_valid, \
        ExtendedValue: ExtendedValue_is_valid, \
        StyleValue: StyleValue_is_valid, \
        ColorArg: ColorArg_is_valid, \
        ColorType: ColorType_is_valid, \
        ColorValue: ColorValue_is_valid \
    )(x)

#define colr_is_valid_mblen(x) ((x) && ((x) != (size_t)-1) && ((x) != (size_t)-2))

#define colr_istr_either(s1, s2, s3) \
    ( \
        ((s1) && (s2) && (s3)) ? \
            (colr_istr_eq((s1), (s2)) || colr_istr_eq((s1), (s3))) : \
            false \
    )

#define colr_istr_eq(s1, s2) \
    ( \
        ((s1) && (s2)) ? \
            !strcasecmp((s1), (s2)) : \
            false \
    )

#define colr_join(joiner, ...) _colr_join(joiner, __VA_ARGS__, _ColrLastArg)

#define colr_length(x) \
    _Generic( \
        (x), \
        ColorArg: ColorArg_length, \
        ColorResult: ColorResult_length, \
        ColorText: ColorText_length, \
        ColorValue: ColorValue_length, \
        void*: _colr_ptr_length \
    )(x)

#define colr_ljust(x, width) colr_ljust_char(x, width, ' ')

#define colr_ljust_char(x, width, padchar) ColorResult_rip_str( \
    _Generic( \
        (x), \
        char*: Colr_ljust_char, \
        const char*: Colr_ljust_char, \
        ColorResult*: Colr_ljust_char, \
        ColorText*: Colr_ljust_char \
    )(x, width, padchar))

#define colr_rjust(x, width) colr_rjust_char(x, width, ' ')

#define colr_rjust_char(x, width, padchar) ColorResult_rip_str( \
    _Generic( \
        (x), \
        char*: Colr_rjust_char, \
        const char*: Colr_rjust_char, \
        ColorResult*: Colr_rjust_char, \
        ColorText*: Colr_rjust_char \
    )(x, width, padchar))

#ifndef DOXYGEN_SKIP
// These are just some stringification macros.
// The first one is the typical stringify macro.
#define _colr_macro_str(x) #x
#define colr_macro_str(x) _colr_macro_str(x)
// This one stringifies the entire argument list as one string.
#define _colr_macro_str_all(...) #__VA_ARGS__
#define colr_macro_str_all(...) _colr_macro_str_all(__VA_ARGS__)
// This is the standard concatenation macro.
#define _colr_macro_concat(a, b) a ## b
#define colr_macro_concat(a, b) _colr_macro_concat(a, b)
#endif

#define colr_max(a, b) (a > b ? a : b)

#define colr_print(...) \
    do { \
        char* _c_p_s = colr_cat(__VA_ARGS__); \
        if (!_c_p_s) break; \
        printf("%s", _c_p_s); \
        colr_free(_c_p_s); \
    } while (0)


#ifdef COLR_GNU

#define colr_printf_macro(func, ...) \
    __extension__({ \
        _Pragma("GCC diagnostic push"); \
        _Pragma("GCC diagnostic ignored \"-Wformat=\""); \
        _Pragma("GCC diagnostic ignored \"-Wformat-extra-args\""); \
        _Pragma("clang diagnostic push"); \
        _Pragma("clang diagnostic ignored \"-Wformat-invalid-specifier\""); \
        colr_printf_register(); \
        int _c_p_m_ret = func(__VA_ARGS__); \
        _Pragma("clang diagnostic pop"); \
        _Pragma("GCC diagnostic pop"); \
        _c_p_m_ret; \
    })

#define colr_printf(...) colr_printf_macro(printf, __VA_ARGS__)

#define colr_fprintf(...) colr_printf_macro(fprintf, __VA_ARGS__)

#define colr_sprintf(...) colr_printf_macro(sprintf, __VA_ARGS__)

#define colr_snprintf(...) colr_printf_macro(snprintf, __VA_ARGS__)

#define colr_asprintf(...) colr_printf_macro(asprintf, __VA_ARGS__)
#endif // COLR_GNU

#define colr_puts(...) \
    do { \
        char* _c_p_s = colr_cat(__VA_ARGS__); \
        if (!_c_p_s) break; \
        puts(_c_p_s); \
        colr_free(_c_p_s); \
    } while (0)

#define colr_replace(s, target, repl) \
    _Generic( \
        (repl), \
        char*: _Generic( \
            (target), \
                char* : colr_str_replace, \
                regex_t* : colr_str_replace_re_pat, \
                regmatch_t*: colr_str_replace_re_match, \
                regmatch_t**: colr_str_replace_re_matches \
            ), \
        ColorArg*: _Generic( \
            (target), \
                char* : colr_str_replace_ColorArg, \
                regex_t* : colr_str_replace_re_pat_ColorArg, \
                regmatch_t*: colr_str_replace_re_match_ColorArg, \
                regmatch_t**: colr_str_replace_re_matches_ColorArg \
            ), \
        ColorResult*: _Generic( \
            (target), \
                char* : colr_str_replace_ColorResult, \
                regex_t* : colr_str_replace_re_pat_ColorResult, \
                regmatch_t*: colr_str_replace_re_match_ColorResult, \
                regmatch_t**: colr_str_replace_re_matches_ColorResult \
            ), \
        ColorText*: _Generic( \
            (target), \
                char* : colr_str_replace_ColorText, \
                regex_t* : colr_str_replace_re_pat_ColorText, \
                regmatch_t*: colr_str_replace_re_match_ColorText, \
                regmatch_t**: colr_str_replace_re_matches_ColorText \
            ) \
    )(s, target, repl)

#define colr_replace_all(s, target, repl) \
    _Generic( \
        (repl), \
        char*: _Generic( \
            (target), \
                char* : colr_str_replace_all, \
                regex_t* : colr_str_replace_re_pat_all, \
                regmatch_t** : colr_str_replace_re_matches \
            ), \
        ColorArg*: _Generic( \
            (target), \
                char* : colr_str_replace_all_ColorArg, \
                regex_t* : colr_str_replace_re_pat_all_ColorArg, \
                regmatch_t** : colr_str_replace_re_matches_ColorArg \
            ), \
        ColorResult*: _Generic( \
            (target), \
                char* : colr_str_replace_all_ColorResult, \
                regex_t* : colr_str_replace_re_pat_all_ColorResult, \
                regmatch_t** : colr_str_replace_re_matches_ColorResult \
            ), \
        ColorText*: _Generic( \
            (target), \
                char* : colr_str_replace_all_ColorText, \
                regex_t* : colr_str_replace_re_pat_all_ColorText, \
                regmatch_t** : colr_str_replace_re_matches_ColorText \
            ) \
    )(s, target, repl)

#define colr_replace_re(s, target, repl, flags) \
    _Generic( \
        (repl), \
        char*: colr_str_replace_re, \
        ColorArg*: colr_str_replace_re_ColorArg, \
        ColorResult*: colr_str_replace_re_ColorResult, \
        ColorText*: colr_str_replace_re_ColorText \
    )(s, target, repl, flags)

#define colr_replace_re_all(s, target, repl, flags) \
    _Generic( \
        (repl), \
        char*: colr_str_replace_re_all, \
        ColorArg*: colr_str_replace_re_all_ColorArg, \
        ColorResult*: colr_str_replace_re_all_ColorResult, \
        ColorText*: colr_str_replace_re_all_ColorText \
    )(s, target, repl, flags)

#define colr_repr(x) \
    _Generic( \
        (x), \
        ColorArg: ColorArg_repr, \
        ColorArg**: ColorArgs_array_repr, \
        ColorJustify: ColorJustify_repr, \
        ColorJustifyMethod: ColorJustifyMethod_repr, \
        ColorResult: ColorResult_repr, \
        ColorText: ColorText_repr, \
        ColorValue: ColorValue_repr, \
        ArgType: ArgType_repr, \
        ColorType: ColorType_repr, \
        BasicValue: BasicValue_repr, \
        ExtendedValue: ExtendedValue_repr, \
        RGB: RGB_repr, \
        StyleValue: StyleValue_repr, \
        TermSize: TermSize_repr, \
        const char*: colr_str_repr, \
        char*: colr_str_repr, \
        const char: colr_char_repr, \
        char: colr_char_repr, \
        void*: _colr_ptr_repr \
    )(x)


#define colr_str_eq(s1, s2) ( \
        ((s1) && (s2)) ? !strcmp((s1), (s2)) : false \
    )

#define colr_str_either(s1, s2, s3) (colr_str_eq(s1, s2) || colr_str_eq(s1, s3))

#define colr_to_str(x) \
    _Generic( \
        (x), \
        ArgType: ArgType_to_str, \
        BasicValue: BasicValue_to_str, \
        ColorArg: ColorArg_to_esc, \
        ColorResult: ColorResult_to_str, \
        ColorText: ColorText_to_str, \
        ColorType: ColorType_to_str, \
        ExtendedValue: ExtendedValue_to_str, \
        StyleValue: StyleValue_to_str, \
        RGB: RGB_to_str, \
        void*: _colr_ptr_to_str \
    )(x)

#ifndef DOXYGEN_SKIP
#if defined(DEBUG) && defined(DBUG_H) && defined(dbug)

    #define dbug_repr(lbl, x) \
        do { \
            char* _dbug_repr_s = colr_repr(x); \
            dbug("%s: %s\n", lbl, _dbug_repr_s); \
            free(_dbug_repr_s); \
        } while(0)
#else
    #if !defined(dbug)

        #define dbug(...) ((void)0)
    #endif

    #define dbug_repr(lbl, x) ((void)0)
#endif
#endif // DOXYGEN_SKIP

#define ext(x) ((ExtendedValue)x)

#define ext_hex(s) ext_hex_or(s, ext(0))

#define ext_hex_or(s, default_value) ExtendedValue_from_hex_default(s, default_value)

#define ext_rgb(r, g, b) ExtendedValue_from_RGB((RGB){.red=r, .green=g, .blue=b})

#define ext_RGB(rgbval) ExtendedValue_from_RGB(rgbval)

#define fore(x) ColorArg_to_ptr(fore_arg(x))

#define fore_arg(x) \
    _Generic( \
        (x), \
        char* : ColorArg_from_str, \
        RGB: ColorArg_from_RGB, \
        BasicValue: ColorArg_from_BasicValue, \
        ExtendedValue: ColorArg_from_ExtendedValue, \
        StyleValue: ColorArg_from_StyleValue \
    )(FORE, x)

#define fore_str(x) ColorArg_to_esc(fore_arg(x))

#ifdef COLR_GNU

#define fore_str_static(x) \
    __extension__ ({ \
        __typeof(x) _fss_val = x; \
        ColorArg _fss_carg = fore_arg(_fss_val); \
        size_t _fss_len = ColorArg_length(_fss_carg); \
        char* _fss_codes = alloca(_fss_len); \
        ColorArg_to_esc_s(_fss_codes, _fss_carg); \
        _fss_codes; \
    })
    /*  A Variable Length Array will not work here.
        The space for `_fss_codes` would be deallocated before this statement
        expression returns. Using `alloca` ensures that it will live at least
        as long as the calling function.
        See:
            https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html#index-_002a_005f_005fbuiltin_005falloca
    */
#endif // COLR_GNU


#define hex(s) hex_or(s, rgb(0, 0, 0))

#define hex_or(s, default_rgb) RGB_from_hex_default(s, default_rgb)

#define if_not_asprintf(...) if (asprintf(__VA_ARGS__) < 1)

#define rgb(r, g, b) ((RGB){.red=r, .green=g, .blue=b})

#define style(x) ColorArg_to_ptr(style_arg(x))

#define style_arg(x) \
    _Generic( \
        (x), \
        char* : ColorArg_from_str, \
        StyleValue: ColorArg_from_StyleValue \
    )(STYLE, x)

#define style_str(x) ColorArg_to_esc(style_arg(x))

#define style_str_static(x) \
    (x == RESET_ALL ? "\x1b[0m" : \
    (x == BOLD ? "\x1b[1m" : \
    (x == BRIGHT ? "\x1b[1m" : \
    (x == DIM ? "\x1b[2m" : \
    (x == ITALIC ? "\x1b[3m" : \
    (x == UNDERLINE ? "\x1b[4m" : \
    (x == FLASH ? "\x1b[5m" : \
    (x == HIGHLIGHT ? "\x1b[7m" : \
    (x == STRIKETHRU ? "\x1b[9m" : \
    (x == NORMAL ? "\x1b[22m" : \
    (x == FRAME ? "\x1b[51m" : \
    (x == ENCIRCLE ? "\x1b[52m" : \
    (x == OVERLINE ? "\x1b[53m" : "\x1b[" colr_macro_str(x) "m" \
    )))))))))))))

#define while_colr_va_arg(ap, vartype, x) while (x = va_arg(ap, vartype), !_colr_is_last_arg(x))


typedef enum BasicValue {
    BASIC_INVALID_RANGE = COLOR_INVALID_RANGE,
    BASIC_INVALID = COLOR_INVALID,
    BASIC_NONE = -1,
    // The actual escape code value for fore colors is BasicValue + 30 == (30-39).
    // The actual escape code value for back colors is BasicValue + 40 == (40-49).
    BLACK = 0,
    RED = 1,
    GREEN = 2,
    YELLOW = 3,
    BLUE = 4,
    MAGENTA = 5,
    CYAN = 6,
    WHITE = 7,
    UNUSED = 8,
    RESET = 9,
    // The following colors are basic "bright" colors.
    // The actual escape code value for fore colors is BasicValue + 80 == (90-97).
    // The actual escape code value for back colors is BasicValue + 90 == (100-107).
    LIGHTBLACK = 10,
    LIGHTRED = 11,
    LIGHTGREEN = 12,
    LIGHTYELLOW = 13,
    LIGHTBLUE = 14,
    LIGHTMAGENTA = 15,
    LIGHTCYAN = 16,
    LIGHTWHITE = 17,
} BasicValue;

#ifndef DOXYGEN_SKIP
// This makes enum values more friendly to _Generic, by explicitly casting
// from `int` to the enum type.
#define BASIC_INVALID basic(BASIC_INVALID)
#define BASIC_NONE basic(BASIC_NONE)
#define BLACK basic(BLACK)
#define RED basic(RED)
#define GREEN basic(GREEN)
#define YELLOW basic(YELLOW)
#define BLUE basic(BLUE)
#define MAGENTA basic(MAGENTA)
#define CYAN basic(CYAN)
#define WHITE basic(WHITE)
#define UNUSED basic(UNUSED)
#define RESET basic(RESET)
#define LIGHTBLACK basic(LIGHTBLACK)
#define LIGHTRED basic(LIGHTRED)
#define LIGHTGREEN basic(LIGHTGREEN)
#define LIGHTYELLOW basic(LIGHTYELLOW)
#define LIGHTBLUE basic(LIGHTBLUE)
#define LIGHTMAGENTA basic(LIGHTMAGENTA)
#define LIGHTCYAN basic(LIGHTCYAN)
#define LIGHTWHITE basic(LIGHTWHITE)

#define XRESET ((ExtendedValue)0)
#define XRED ((ExtendedValue)1)
#define XGREEN ((ExtendedValue)2)
#define XYELLOW ((ExtendedValue)3)
#define XBLUE ((ExtendedValue)4)
#define XMAGENTA ((ExtendedValue)5)
#define XCYAN ((ExtendedValue)6)
#define XWHITE ((ExtendedValue)7)
#define XLIGHTBLACK ((ExtendedValue)8)
#define XLIGHTRED ((ExtendedValue)9)
#define XLIGHTGREEN ((ExtendedValue)10)
#define XLIGHTYELLOW ((ExtendedValue)11)
#define XLIGHTBLUE ((ExtendedValue)12)
#define XLIGHTMAGENTA ((ExtendedValue)13)
#define XLIGHTCYAN ((ExtendedValue)14)
#define XLIGHTWHITE ((ExtendedValue)15)
#define XBLACK ((ExtendedValue)16)
#endif // DOXYGEN_SKIP

typedef unsigned char ExtendedValue;

typedef struct RGB {
    unsigned char red;
    unsigned char green;
    unsigned char blue;
} RGB;

typedef enum StyleValue {
    STYLE_INVALID_RANGE = COLOR_INVALID_RANGE,
    STYLE_INVALID = COLOR_INVALID,
    STYLE_NONE = -1,
    RESET_ALL = 0,
    BRIGHT = 1,
    DIM = 2,
    ITALIC = 3,
    UNDERLINE = 4,
    FLASH = 5, // DOS has a "rapid flash" for 6 also.
    HIGHLIGHT = 7,
    STRIKETHRU = 9,
    NORMAL = 22,
    // May not be supported.
    FRAME = 51,
    ENCIRCLE = 52,
    OVERLINE = 53, // Supported in Konsole.
} StyleValue;

#define STYLE_MAX_VALUE ((StyleValue)OVERLINE)
#define STYLE_MIN_VALUE ((StyleValue)STYLE_INVALID_RANGE)

#ifndef DOXYGEN_SKIP
// This makes enum values more friendly to _Generic, by explicitly casting
// from `int` to the enum type.
#define STYLE_INVALID_RANGE ((StyleValue)STYLE_INVALID_RANGE)
#define STYLE_INVALID ((StyleValue)STYLE_INVALID)
#define STYLE_NONE ((StyleValue)STYLE_NONE)
#define RESET_ALL ((StyleValue)RESET_ALL)
#define BRIGHT ((StyleValue)BRIGHT)
#define BOLD ((StyleValue)BRIGHT)
#define DIM ((StyleValue)DIM)
#define ITALIC ((StyleValue)ITALIC)
#define UNDERLINE ((StyleValue)UNDERLINE)
#define FLASH ((StyleValue)FLASH)
#define HIGHLIGHT ((StyleValue)HIGHLIGHT)
#define NORMAL ((StyleValue)NORMAL)
#define FRAME ((StyleValue)FRAME)
#define ENCIRCLE ((StyleValue)ENCIRCLE)
#define OVERLINE ((StyleValue)OVERLINE)
#endif // DOXYGEN_SKIP

typedef enum ArgType {
    ARGTYPE_NONE = -1,
    FORE = 0,
    BACK = 1,
    STYLE = 2,
} ArgType;

#ifndef DOXYGEN_SKIP
// This makes enum values more friendly to _Generic, by explicitly casting
// from `int` to the enum type.
#define ARGTYPE_NONE ((ArgType)ARGTYPE_NONE)
#define FORE ((ArgType)FORE)
#define BACK ((ArgType)BACK)
#define STYLE ((ArgType)STYLE)
#endif
typedef enum ColorJustifyMethod {
    JUST_NONE = -1,
    JUST_LEFT = 0,
    JUST_RIGHT = 1,
    JUST_CENTER = 2,
} ColorJustifyMethod;

#ifndef DOXYGEN_SKIP
// This makes enum values more friendly to _Generic, by explicitly casting
// from `int` to the enum type.
#define JUST_NONE ((ColorJustifyMethod)JUST_NONE)
#define JUST_LEFT ((ColorJustifyMethod)JUST_LEFT)
#define JUST_RIGHT ((ColorJustifyMethod)JUST_RIGHT)
#define JUST_CENTER ((ColorJustifyMethod)JUST_CENTER)
#endif
typedef enum ColorType {
    TYPE_NONE = -6,
    TYPE_INVALID_STYLE = -5,
    TYPE_INVALID_RGB_RANGE = -4,
    TYPE_INVALID_EXT_RANGE = COLOR_INVALID_RANGE,
    TYPE_INVALID = COLOR_INVALID,
    TYPE_BASIC = 0,
    TYPE_EXTENDED = 1,
    TYPE_RGB = 2,
    TYPE_STYLE = 3,
} ColorType;

#ifndef DOXYGEN_SKIP
// This makes enum values more friendly to _Generic, by explicitly casting
// from `int` to the enum type.
#define TYPE_NONE ((ColorType)TYPE_NONE)
#define TYPE_INVALID_STYLE ((ColorType)TYPE_INVALID_STYLE)
#define TYPE_INVALID_RGB_RANGE ((ColorType)TYPE_INVALID_RGB_RANGE)
#define TYPE_INVALID_EXT_RANGE ((ColorType)TYPE_INVALID_EXT_RANGE)
#define TYPE_INVALID ((ColorType)TYPE_INVALID)
#define TYPE_BASIC ((ColorType)TYPE_BASIC)
#define TYPE_EXTENDED ((ColorType)TYPE_EXTENDED)
#define TYPE_RGB ((ColorType)TYPE_RGB)
#define TYPE_STYLE ((ColorType)TYPE_STYLE)
#endif

typedef struct BasicInfo {
    char* name;
    BasicValue value;
} BasicInfo;
typedef struct ExtendedInfo {
    char* name;
    ExtendedValue value;
} ExtendedInfo;
typedef struct StyleInfo {
    char* name;
    StyleValue value;
} StyleInfo;

typedef struct ColorJustify {
    uint32_t marker;
    ColorJustifyMethod method;
    int width;
    char padchar;
} ColorJustify;

typedef union ColorStructMarker {
    uint32_t marker;
    struct {
        uint8_t b1;
        uint8_t b2;
        uint8_t b3;
        uint8_t b4;
    } bytes;
} ColorStructMarker;
typedef struct ColorValue {
    ColorType type;
    BasicValue basic;
    ExtendedValue ext;
    RGB rgb;
    StyleValue style;
} ColorValue;

typedef struct ColorNameData {
    char* name;
    ExtendedValue ext;
    RGB rgb;
} ColorNameData;

typedef struct ColorArg {
    uint32_t marker;
    ArgType type;
    ColorValue value;
} ColorArg;

typedef struct ColorResult {
    uint32_t marker;
    char* result;
    size_t length;
} ColorResult;

typedef struct ColorText {
    uint32_t marker;
    char* text;
    // Pointers are used for compatibility with the fore(), back(), and style() macros.
    ColorArg *fore;
    ColorArg *back;
    ColorArg *style;
    ColorJustify just;
} ColorText;

typedef struct TermSize {
    unsigned short rows;
    unsigned short columns;
} TermSize;

#ifndef DOXYGEN_SKIP
extern const BasicInfo basic_names[];
extern const size_t basic_names_len;
extern const ExtendedInfo extended_names[];
extern const size_t extended_names_len;
extern const StyleInfo style_names[];
extern const size_t style_names_len;

extern const RGB ext2rgb_map[];
extern const size_t ext2rgb_map_len;

extern const ColorNameData colr_name_data[];
extern const size_t colr_name_data_len;

typedef unsigned long ColrHash;
#define COLR_HASH_FMT "%lu"

struct _ColrLastArg_s {
    uint32_t marker;
    unsigned short value;
};

static const struct _ColrLastArg_s _ColrLastArgValue = {
    .marker=COLORLASTARG_MARKER,
    .value=1337
};
// clang linter says it's unused, but it's used in the _colr* functions, and others.
#pragma clang diagnostic ignored "-Wunused-const-variable"
static const struct _ColrLastArg_s* const _ColrLastArg = &_ColrLastArgValue;
#endif // DOXYGEN_SKIP

#ifdef DOXYGEN_SKIP
    // This is strictly for Doxygen, because it doesn't know what __attribute__ is,
    // even if you tell it with `PREDEFINED = __attribute__(x)=`
    ColorResult* Colr_fmt_str(const char* fmt, ...);
#else
    ColorResult* Colr_fmt_str(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
#endif

ColorResult* Colr_center_char(void* x, int width, char padchar);
ColorResult* Colr_ljust_char(void* x, int width, char padchar);
ColorResult* Colr_rjust_char(void* x, int width, char padchar);

regmatch_t* colr_alloc_regmatch(regmatch_t match);
void colr_append_reset(char* s);

char colr_char_escape_char(const char c);
bool colr_char_in_str(const char* s, const char c);
bool colr_char_is_code_end(const char c);
char* colr_char_repr(char c);
bool colr_char_should_escape(const char c);

bool colr_check_marker(uint32_t marker, void* p);
char* colr_empty_str(void);
void colr_free_argsv(va_list args);
void colr_free_re_matches(regmatch_t** matches);
bool colr_is_colr_ptr(void* p);
size_t colr_mb_len(const char* s, size_t length);

#ifdef COLR_GNU
int colr_printf_handler(FILE *fp, const struct printf_info *info, const void *const *args);
int colr_printf_info(const struct printf_info *info, size_t n, int *argtypes, int *sz);
// The contructor attribute isn't used because not everyone needs this.
void colr_printf_register(void); // __attribute__((constructor))
#endif

regmatch_t** colr_re_matches(const char* s, regex_t* repattern);
bool colr_set_locale(void);
bool colr_supports_rgb(void);
bool colr_supports_rgb_static(void);

bool colr_str_array_contains(char** lst, const char* s);
void colr_str_array_free(char** ps);
size_t colr_str_char_count(const char* s, const char c);
size_t colr_str_char_lcount(const char* s, const char c);
size_t colr_str_chars_lcount(const char* restrict s, const char* restrict chars);
char* colr_str_center(const char* s, int width, const char padchar);
size_t colr_str_code_count(const char* s);
size_t colr_str_code_len(const char* s);
char* colr_str_copy(char* restrict dest, const char* restrict src, size_t length);
bool colr_str_ends_with(const char* restrict s, const char* restrict suffix);
char** colr_str_get_codes(const char* s, bool unique);
bool colr_str_has_ColorArg(const char* s, ColorArg* carg);
bool colr_str_has_codes(const char* s);
ColrHash colr_str_hash(const char* s);
bool colr_str_is_all(const char* s, const char c);
bool colr_str_is_codes(const char* s);
bool colr_str_is_digits(const char* s);
bool colr_str_is_empty(const char* s);
char* colr_str_ljust(const char* s, int width, const char padchar);
void colr_str_lower(char* s);
size_t colr_str_lstrip(char* restrict dest, const char* restrict s, size_t length, const char c);
char* colr_str_lstrip_char(const char* s, const char c);
char* colr_str_lstrip_chars(const char* restrict s, const char* restrict chars);
size_t colr_str_mb_len(const char* s);
size_t colr_str_noncode_len(const char* s);

char* colr_str_replace(const char* restrict s, const char* restrict target, const char* restrict repl);
char* colr_str_replace_all(const char* restrict s, const char* restrict target, const char* restrict repl);
char* colr_str_replace_all_ColorArg(const char* restrict s, const char* restrict target, ColorArg* repl);
char* colr_str_replace_all_ColorResult(const char* restrict s, const char* restrict target, ColorResult* repl);
char* colr_str_replace_all_ColorText(const char* restrict s, const char* restrict target, ColorText* repl);
char* colr_str_replace_cnt(const char* restrict s, const char* restrict target, const char* restrict repl, int count);
char* colr_str_replace_ColorArg(const char* restrict s, const char* restrict target, ColorArg* repl);
char* colr_str_replace_ColorResult(const char* restrict s, const char* restrict target, ColorResult* repl);
char* colr_str_replace_ColorText(const char* restrict s, const char* restrict target, ColorText* repl);
char* colr_str_replace_re(const char* restrict s, const char* restrict pattern, const char* restrict repl, int re_flags);
char* colr_str_replace_re_all(const char* restrict s, const char* restrict pattern, const char* restrict repl, int re_flags);
char* colr_str_replace_re_all_ColorArg(const char* restrict s, const char* restrict pattern, ColorArg* repl, int re_flags);
char* colr_str_replace_re_all_ColorResult(const char* restrict s, const char* restrict pattern, ColorResult* repl, int re_flags);
char* colr_str_replace_re_all_ColorText(const char* restrict s, const char* restrict pattern, ColorText* repl, int re_flags);
char* colr_str_replace_re_ColorArg(const char* restrict s, const char* restrict pattern, ColorArg* repl, int re_flags);
char* colr_str_replace_re_ColorResult(const char* restrict s, const char* restrict pattern, ColorResult* repl, int re_flags);
char* colr_str_replace_re_ColorText(const char* restrict s, const char* restrict pattern, ColorText* repl, int re_flags);
char* colr_str_replace_re_pat(const char* restrict s, regex_t* repattern, const char* restrict repl);
char* colr_str_replace_re_pat_all(const char* restrict s, regex_t* repattern, const char* restrict repl);
char* colr_str_replace_re_pat_all_ColorArg(const char* restrict s, regex_t* repattern, ColorArg* repl);
char* colr_str_replace_re_pat_all_ColorResult(const char* restrict s, regex_t* repattern, ColorResult* repl);
char* colr_str_replace_re_pat_all_ColorText(const char* restrict s, regex_t* repattern, ColorText* repl);
char* colr_str_replace_re_pat_ColorArg(const char* restrict s, regex_t* repattern, ColorArg* repl);
char* colr_str_replace_re_pat_ColorResult(const char* restrict s, regex_t* repattern, ColorResult* repl);
char* colr_str_replace_re_pat_ColorText(const char* restrict s, regex_t* repattern, ColorText* repl);
char* colr_str_replace_re_match(const char* restrict s, regmatch_t* match, const char* restrict repl);
char* colr_str_replace_re_match_i(const char* restrict ref, char* target, regmatch_t* match, const char* restrict repl);
char* colr_str_replace_re_match_ColorArg(const char* restrict s, regmatch_t* match, ColorArg* repl);
char* colr_str_replace_re_match_ColorResult(const char* restrict s, regmatch_t* match, ColorResult* repl);
char* colr_str_replace_re_match_ColorText(const char* restrict s, regmatch_t* match, ColorText* repl);
char* colr_str_replace_re_matches(const char* restrict s, regmatch_t** matches, const char* restrict repl);
char* colr_str_replace_re_matches_ColorArg(const char* restrict s, regmatch_t** matches, ColorArg* repl);
char* colr_str_replace_re_matches_ColorResult(const char* restrict s, regmatch_t** matches, ColorResult* repl);
char* colr_str_replace_re_matches_ColorText(const char* restrict s, regmatch_t** matches, ColorText* repl);

char* colr_str_repr(const char* s);
char* colr_str_rjust(const char* s, int width, const char padchar);
bool colr_str_starts_with(const char* restrict s, const char* restrict prefix);
char* colr_str_strip_codes(const char* s);
char* colr_str_to_lower(const char* s);

TermSize colr_term_size(void);
struct winsize colr_win_size(void);
struct winsize colr_win_size_env(void);
void format_bgx(char* out, unsigned char num);
void format_bg(char* out, BasicValue value);
void format_bg_RGB(char* out, RGB rgb);
void format_bg_RGB_term(char* out, RGB rgb);
void format_fgx(char* out, unsigned char num);
void format_fg(char* out, BasicValue value);
void format_fg_RGB(char* out, RGB rgb);
void format_fg_RGB_term(char* out, RGB rgb);
void format_style(char* out, StyleValue style);
typedef void (*RGB_fmter)(char* out, RGB rgb);
typedef char* (*rainbow_creator)(const char* s, double freq, size_t offset, size_t spread);

char* _rainbow(RGB_fmter fmter, const char* s, double freq, size_t offset, size_t spread);
char* rainbow_fg(const char* s, double freq, size_t offset, size_t spread);
char* rainbow_fg_term(const char* s, double freq, size_t offset, size_t spread);
char* rainbow_bg(const char* s, double freq, size_t offset, size_t spread);
char* rainbow_bg_term(const char* s, double freq, size_t offset, size_t spread);
RGB rainbow_step(double freq, size_t offset);

void _colr_free(void* p);

bool _colr_is_last_arg(void* p);
size_t _colr_ptr_length(void* p);
char* _colr_ptr_repr(void* p);
char* _colr_ptr_to_str(void* p);

char* _colr_join(void* joinerp, ...);
size_t _colr_join_size(void* joinerp, va_list args);

size_t _colr_join_array_length(void* ps);
size_t _colr_join_arrayn_size(void* joinerp, void* ps, size_t count);
char* colr_join_array(void* joinerp, void* ps);
char* colr_join_arrayn(void* joinerp, void* ps, size_t count);

bool ArgType_eq(ArgType a, ArgType b);
char* ArgType_repr(ArgType type);
char* ArgType_to_str(ArgType type);

void ColorArgs_array_free(ColorArg** ps);
char* ColorArgs_array_repr(ColorArg** lst);
ColorArg ColorArg_empty(void);
bool ColorArg_eq(ColorArg a, ColorArg b);
char* ColorArg_example(ColorArg carg, bool colorized);
void ColorArg_free(ColorArg* p);
ColorArg ColorArg_from_BasicValue(ArgType type, BasicValue value);
ColorArg ColorArg_from_ExtendedValue(ArgType type, ExtendedValue value);
ColorArg ColorArg_from_RGB(ArgType type, RGB value);
ColorArg ColorArg_from_esc(const char* s);
ColorArg ColorArg_from_str(ArgType type, const char* colorname);
ColorArg ColorArg_from_StyleValue(ArgType type, StyleValue value);
ColorArg ColorArg_from_value(ArgType type, ColorType colrtype, void* p);
bool ColorArg_is_empty(ColorArg carg);
bool ColorArg_is_invalid(ColorArg carg);
bool ColorArg_is_ptr(void* p);
bool ColorArg_is_valid(ColorArg carg);
size_t ColorArg_length(ColorArg carg);
char* ColorArg_repr(ColorArg carg);
ColorArg* ColorArg_to_ptr(ColorArg carg);
char* ColorArg_to_esc(ColorArg carg);
bool ColorArg_to_esc_s(char* dest, ColorArg carg);

ColorArg** ColorArgs_from_str(const char* s, bool unique);

ColorJustify ColorJustify_empty(void);
bool ColorJustify_eq(ColorJustify a, ColorJustify b);
bool ColorJustify_is_empty(ColorJustify cjust);
ColorJustify ColorJustify_new(ColorJustifyMethod method, int width, char padchar);
char* ColorJustify_repr(ColorJustify cjust);
char* ColorJustifyMethod_repr(ColorJustifyMethod meth);

ColorResult* ColorResult_Colr(ColorResult* cres, ...);
ColorResult* ColorResult_center(ColorResult* cres, int width, char padchar);
ColorResult ColorResult_empty(void);
bool ColorResult_eq(ColorResult a, ColorResult b);
void ColorResult_free(ColorResult* p);
ColorResult ColorResult_from_str(const char* s);
ColorResult* ColorResult_from_stra(const char* s);
bool ColorResult_is_empty(ColorResult cres);
bool ColorResult_is_ptr(void* p);
size_t ColorResult_length(ColorResult cres);
ColorResult* ColorResult_ljust(ColorResult* cres, int width, char padchar);
ColorResult ColorResult_new(char* s);
char* ColorResult_repr(ColorResult cres);
char* ColorResult_rip_str(ColorResult* cres);
ColorResult* ColorResult_rjust(ColorResult* cres, int width, char padchar);
ColorResult* ColorResult_to_ptr(ColorResult cres);
char* ColorResult_to_str(ColorResult cres);

ColorText ColorText_empty(void);
void ColorText_free(ColorText* p);
void ColorText_free_args(ColorText* p);
ColorText ColorText_from_values(char* text, ...);
ColorText ColorText_from_valuesv(char* text, va_list args);
bool ColorText_has_arg(ColorText ctext, ColorArg carg);
bool ColorText_has_args(ColorText ctext);
bool ColorText_is_empty(ColorText ctext);
bool ColorText_is_ptr(void* p);
size_t ColorText_length(ColorText ctext);
char* ColorText_repr(ColorText ctext);
ColorText* ColorText_set_center(ColorText* ctext, int width, char padchar);
ColorText* ColorText_set_ljust(ColorText* ctext, int width, char padchar);
ColorText* ColorText_set_just(ColorText* ctext, ColorJustify cjust);
ColorText* ColorText_set_rjust(ColorText* ctext, int width, char padchar);
void ColorText_set_values(ColorText* ctext, char* text, ...);
ColorText* ColorText_to_ptr(ColorText ctext);
char* ColorText_to_str(ColorText ctext);

bool ColorType_eq(ColorType a, ColorType b);
ColorType ColorType_from_str(const char* arg);
bool ColorType_is_invalid(ColorType type);
bool ColorType_is_valid(ColorType type);
char* ColorType_repr(ColorType type);
char* ColorType_to_str(ColorType type);

ColorValue ColorValue_empty(void);
bool ColorValue_eq(ColorValue a, ColorValue b);
char* ColorValue_example(ColorValue cval);
ColorValue ColorValue_from_esc(const char* s);
ColorValue ColorValue_from_str(const char* s);
ColorValue ColorValue_from_value(ColorType type, void* p);
bool ColorValue_has_BasicValue(ColorValue cval, BasicValue bval);
bool ColorValue_has_ExtendedValue(ColorValue cval, ExtendedValue eval);
bool ColorValue_has_StyleValue(ColorValue cval, StyleValue sval);
bool ColorValue_has_RGB(ColorValue cval, RGB rgb);
bool ColorValue_is_empty(ColorValue cval);
bool ColorValue_is_invalid(ColorValue cval);
bool ColorValue_is_valid(ColorValue cval);
size_t ColorValue_length(ArgType type, ColorValue cval);
char* ColorValue_repr(ColorValue cval);
char* ColorValue_to_esc(ArgType type, ColorValue cval);
bool ColorValue_to_esc_s(char* dest, ArgType type, ColorValue cval);

bool BasicValue_eq(BasicValue a, BasicValue b);
BasicValue BasicValue_from_esc(const char* s);
BasicValue BasicValue_from_str(const char* arg);
bool BasicValue_is_valid(BasicValue bval);
bool BasicValue_is_invalid(BasicValue bval);
int BasicValue_to_ansi(ArgType type, BasicValue bval);
char* BasicValue_to_str(BasicValue bval);
char* BasicValue_repr(BasicValue bval);
bool ExtendedValue_eq(ExtendedValue a, ExtendedValue b);
int ExtendedValue_from_BasicValue(BasicValue bval);
int ExtendedValue_from_esc(const char* s);
int ExtendedValue_from_hex(const char* hexstr);
ExtendedValue ExtendedValue_from_hex_default(const char* hexstr, ExtendedValue default_value);
ExtendedValue ExtendedValue_from_RGB(RGB rgb);
int ExtendedValue_from_str(const char* arg);
bool ExtendedValue_is_invalid(int eval);
bool ExtendedValue_is_valid(int eval);
char* ExtendedValue_repr(int eval);
char* ExtendedValue_to_str(ExtendedValue eval);

bool StyleValue_eq(StyleValue a, StyleValue b);
StyleValue StyleValue_from_esc(const char* s);
StyleValue StyleValue_from_str(const char* arg);
bool StyleValue_is_invalid(StyleValue sval);
bool StyleValue_is_valid(StyleValue sval);
char* StyleValue_repr(StyleValue sval);
char* StyleValue_to_str(StyleValue sval);
unsigned char RGB_average(RGB rgb);
bool RGB_eq(RGB a, RGB b);
RGB RGB_from_BasicValue(BasicValue bval);
RGB RGB_from_ExtendedValue(ExtendedValue eval);
int RGB_from_esc(const char* s, RGB* rgb);
int RGB_from_hex(const char* hexstr, RGB* rgb);
RGB RGB_from_hex_default(const char* hexstr, RGB default_value);
int RGB_from_str(const char* arg, RGB* rgb);
RGB RGB_grayscale(RGB rgb);
RGB RGB_inverted(RGB rgb);
RGB RGB_monochrome(RGB rgb);
char* RGB_to_hex(RGB rgb);
char* RGB_to_str(RGB rgb);
RGB RGB_to_term_RGB(RGB rgb);
char* RGB_repr(RGB rgb);

char* TermSize_repr(TermSize ts);

static_assert(
    (
        ((int)COLOR_INVALID == (int)TYPE_INVALID) &&
        ((int)TYPE_INVALID == (int)BASIC_INVALID) &&
        ((int)BASIC_INVALID == (int)EXT_INVALID) &&
        ((int)EXT_INVALID == (int)STYLE_INVALID)
    ),
    "Return/enum values for all color/style values should match."
);
static_assert(
    (
        COLORARG_MARKER &&
        (COLORLASTARG_MARKER &&
            (COLORLASTARG_MARKER != COLORARG_MARKER)
        ) &&
        (COLORJUSTIFY_MARKER &&
            (COLORJUSTIFY_MARKER != COLORLASTARG_MARKER) &&
            (COLORJUSTIFY_MARKER != COLORARG_MARKER)
        ) &&
        (COLORTEXT_MARKER &&
            (COLORTEXT_MARKER != COLORLASTARG_MARKER) &&
            (COLORTEXT_MARKER != COLORARG_MARKER) &&
            (COLORTEXT_MARKER != COLORJUSTIFY_MARKER)
        ) &&
        (COLORRESULT_MARKER &&
            (COLORRESULT_MARKER != COLORLASTARG_MARKER) &&
            (COLORRESULT_MARKER != COLORARG_MARKER) &&
            (COLORRESULT_MARKER != COLORJUSTIFY_MARKER) &&
            (COLORRESULT_MARKER != COLORTEXT_MARKER)
        )
    ),
    "Markers must be positive and unique for each struct in Colr!"
);

#endif // COLR_H