string.h

Go to the documentation of this file.

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef UCX_STRING_H
#define UCX_STRING_H
 
#include "common.h"
#include "allocator.h"
 
#include <string.h>

#define CX_NULLSTR cx_mutstr(NULL)

#define CX_SFMT(s) (int) (s).length, (s).ptr

#define CX_PRIstr ".*s"

CX_EXPORT extern const unsigned cx_strstr_sbo_size;

struct cx_mutstr_s {
    char *ptr;
    size_t length;
};

typedef struct cx_mutstr_s cxmutstr;

struct cx_string_s {
    const char *ptr;
    size_t length;
};

typedef struct cx_string_s cxstring;

struct cx_strtok_ctx_s {
    cxstring str;
    cxstring delim;
    const cxstring *delim_more;
    size_t delim_more_count;
    size_t pos;
    size_t delim_pos;
    size_t next_pos;
    size_t found;
    size_t limit;
};

typedef struct cx_strtok_ctx_s CxStrtokCtx;

CX_NODISCARD CX_CSTR_ARG(1)
CX_INLINE cxmutstr cx_mutstr(char *cstring) {
    cxmutstr str;
    str.ptr = cstring;
    str.length = cstring == NULL ? 0 : strlen(cstring);
    return str;
}

CX_NODISCARD CX_ACCESS_RW(1, 2)
CX_INLINE cxmutstr cx_mutstrn(char *cstring, size_t length) {
    cxmutstr str;
    str.ptr = cstring;
    str.length = length;
    return str;
}

CX_NODISCARD CX_CSTR_ARG(1)
CX_INLINE cxstring cx_str(const char *cstring) {
    cxstring str;
    str.ptr = cstring;
    str.length = cstring == NULL ? 0 : strlen(cstring);
    return str;
}
 

CX_NODISCARD CX_ACCESS_R(1, 2)
CX_INLINE cxstring cx_strn(const char *cstring, size_t length) {
    cxstring str;
    str.ptr = cstring;
    str.length = length;
    return str;
}
 
#ifdef __cplusplus
CX_NODISCARD
CX_CPPDECL cxmutstr cx_strcast_m(cxmutstr str) {
    return str;
}
CX_NODISCARD
CX_CPPDECL cxstring cx_strcast_m(cxstring str) {
    return str;
}
CX_NODISCARD
CX_CPPDECL cxmutstr cx_strcast_m(char *str) {
    return cx_mutstr(str);
}
CX_NODISCARD
CX_CPPDECL cxmutstr cx_strcast_m(unsigned char *str) {
    return cx_mutstr(reinterpret_cast<char*>(str));
}
CX_NODISCARD
CX_CPPDECL cxstring cx_strcast_m(const char *str) {
    return cx_str(str);
}
CX_NODISCARD
CX_CPPDECL cxstring cx_strcast_m(const unsigned char *str) {
    return cx_str(reinterpret_cast<const char*>(str));
}
CX_NODISCARD
CX_CPPDECL cxstring cx_strcast_(cxmutstr str) {
    return cx_strn(str.ptr, str.length);
}
CX_NODISCARD
CX_CPPDECL cxstring cx_strcast_(cxstring str) {
    return str;
}
#define cx_strcast(s) cx_strcast_(cx_strcast_m(s))
#else
CX_NODISCARD
CX_INLINE cxmutstr cx_strcast_cxms(cxmutstr str) {
    return str;
}

CX_NODISCARD
CX_INLINE cxstring cx_strcast_cxs(cxstring str) {
    return str;
}

CX_NODISCARD
CX_INLINE cxmutstr cx_strcast_uc(unsigned char *str) {
    return cx_mutstr((char*)str);
}

CX_NODISCARD
CX_INLINE cxmutstr cx_strcast_c(char *str) {
    return cx_mutstr(str);
}

CX_NODISCARD
CX_INLINE cxstring cx_strcast_ucc(const unsigned char *str) {
    return cx_str((const char*)str);
}

CX_NODISCARD
CX_INLINE cxstring cx_strcast_cc(const char *str) {
    return cx_str(str);
}

#define cx_strcast_m(str) _Generic((str), \
        cxstring: cx_strcast_cxs, \
        cxmutstr: cx_strcast_cxms, \
        const unsigned char*: cx_strcast_ucc, \
        unsigned char *: cx_strcast_uc, \
        const char*: cx_strcast_cc, \
        char *: cx_strcast_c) (str)

CX_INLINE cxstring cx_strcast_1(cxmutstr str) {
    return (cxstring){str.ptr, str.length};
}

CX_INLINE cxstring cx_strcast_2(cxstring str) {
    return str;
}

#define cx_strcast_(str) _Generic((str), \
        cxmutstr: cx_strcast_1, \
        cxstring: cx_strcast_2)(str)

#define cx_strcast(str) cx_strcast_(cx_strcast_m(str))
#endif

CX_INLINE cxmutstr cx_mutstrcast(cxstring str) {
    cxmutstr s;
    s.ptr = (char*)str.ptr;
    s.length = str.length;
    return s;
}

CX_EXTERN
void cx_strfree(cxmutstr *str);

CX_EXTERN CX_NONNULL_ARG(1)
void cx_strfree_a(const CxAllocator *alloc, cxmutstr *str);

CX_EXTERN CX_NONNULL_ARG(1)
int cx_strcpy_a_(const CxAllocator *alloc, cxmutstr *dest, cxstring src);

#define cx_strcpy_a(alloc, dest, src) cx_strcpy_a_(alloc, dest, cx_strcast(src))

#define cx_strcpy(dest, src) cx_strcpy_a(cxDefaultAllocator, dest, src)

CX_EXTERN CX_NODISCARD
size_t cx_strlen(size_t count, ...);

CX_EXTERN CX_NONNULL
cxmutstr cx_strcat_a(const CxAllocator *alloc,
        cxmutstr str, size_t count, ...);

#define cx_strcat(str, count, ...) \
        cx_strcat_a(cxDefaultAllocator, str, count, __VA_ARGS__)

CX_EXTERN CX_NODISCARD
cxstring cx_strsubsl_(cxstring string, size_t start, size_t length);

CX_EXTERN CX_NODISCARD
cxstring cx_strsubs_(cxstring string, size_t start);

CX_INLINE
cxmutstr cx_strsubs_m_(cxmutstr string, size_t start) {
    return cx_mutstrcast(cx_strsubs_(cx_strcast(string), start));
}

CX_INLINE
cxmutstr cx_strsubsl_m_(cxmutstr string, size_t start, size_t length) {
    return cx_mutstrcast(cx_strsubsl_(cx_strcast(string), start, length));
}
 
#ifdef __cplusplus
CX_CPPDECL cxstring cx_strsubs_cpp_(cxstring string, size_t start) {
    return cx_strsubs_(string, start);
}
CX_CPPDECL cxstring cx_strsubsl_cpp_(cxstring string, size_t start, size_t length) {
    return cx_strsubsl_(string, start, length);
}
CX_CPPDECL cxmutstr cx_strsubs_cpp_(cxmutstr string, size_t start) {
    return cx_strsubs_m_(string, start);
}
CX_CPPDECL cxmutstr cx_strsubsl_cpp_(cxmutstr string, size_t start, size_t length) {
    return cx_strsubsl_m_(string, start, length);
}
#define cx_strsubs(string, start) cx_strsubs_cpp_(cx_strcast_m(string), start)
#define cx_strsubsl(string, start, length) cx_strsubsl_cpp_(cx_strcast_m(string), start, length)
#else
#define cx_strsubs(string, start) _Generic(cx_strcast_m(string), \
        cxstring: cx_strsubs_, \
        cxmutstr: cx_strsubs_m_)(cx_strcast_m(string), start)

#define cx_strsubsl(string, start, length) _Generic(cx_strcast_m(string), \
        cxstring: cx_strsubsl_, \
        cxmutstr: cx_strsubsl_m_)(cx_strcast_m(string), start, length)
#endif

CX_INLINE
char cx_strat_(cxstring str, off_t index) {
    size_t i;
    if (index >= 0) {
        i = index;
    } else {
        i = (size_t) (str.length + index);
    }
    if (i >= str.length) {
        return '\0';
    }
    return str.ptr[i];
}

#define cx_strat(str, index) cx_strat_(cx_strcast(str), index)

CX_EXTERN CX_NODISCARD
cxstring cx_strchr_(cxstring string, int chr);

CX_EXTERN CX_NODISCARD
cxstring cx_strrchr_(cxstring string, int chr);
 
#ifdef __cplusplus
CX_CPPDECL cxstring cx_strchr_cpp_(cxstring string, int chr) {
    return cx_strchr_(string, chr);
}
CX_CPPDECL cxmutstr cx_strchr_cpp_(cxmutstr string, int chr) {
    return cx_mutstrcast(cx_strchr_(cx_strcast(string), chr));
}
#define cx_strchr(s, chr) cx_strchr_cpp_(cx_strcast_m(s), chr)
CX_CPPDECL cxstring cx_strrchr_cpp_(cxstring string, int chr) {
    return cx_strrchr_(string, chr);
}
CX_CPPDECL cxmutstr cx_strrchr_cpp_(cxmutstr string, int chr) {
    return cx_mutstrcast(cx_strrchr_(cx_strcast(string), chr));
}
#define cx_strrchr(s, chr) cx_strrchr_cpp_(cx_strcast_m(s), chr)
#else
CX_INLINE cxmutstr cx_strchr_m_(cxmutstr string, int chr) {
    return cx_mutstrcast(cx_strchr_(cx_strcast(string), chr));
}

CX_INLINE  cxmutstr cx_strrchr_m_(cxmutstr string, int chr) {
    return cx_mutstrcast(cx_strrchr_(cx_strcast(string), chr));
}

#define cx_strchr(string, chr) _Generic(cx_strcast_m(string), \
        cxstring: cx_strchr_, \
        cxmutstr: cx_strchr_m_)(cx_strcast_m(string), chr)

#define cx_strrchr(string, chr) _Generic(cx_strcast_m(string), \
        cxstring: cx_strrchr_, \
        cxmutstr: cx_strrchr_m_)(cx_strcast_m(string), chr)
#endif

CX_EXTERN CX_NODISCARD
cxstring cx_strstr_(cxstring haystack, cxstring needle);
 
#ifdef __cplusplus
CX_CPPDECL cxstring cx_strstr_cpp_(cxstring haystack, cxstring needle) {
    return cx_strstr_(haystack, needle);
}
CX_CPPDECL cxmutstr cx_strstr_cpp_(cxmutstr haystack, cxstring needle) {
    return cx_mutstrcast(cx_strstr_(cx_strcast(haystack), needle));
}
#define cx_strstr(h,n) cx_strstr_cpp_(cx_strcast_m(h), cx_strcast(n))
#else
CX_INLINE  cxmutstr cx_strstr_m_(cxmutstr haystack, cxstring needle) {
    return cx_mutstrcast(cx_strstr_(cx_strcast(haystack), needle));
}

#define cx_strstr(haystack, needle) _Generic(cx_strcast_m(haystack), \
        cxstring: cx_strstr_,\
        cxmutstr: cx_strstr_m_)(cx_strcast_m(haystack), cx_strcast(needle))
#endif

CX_EXTERN CX_NODISCARD CX_NONNULL CX_ACCESS_W(4, 3)
size_t cx_strsplit_(cxstring string, cxstring delim,
        size_t limit, cxstring *output);

CX_EXTERN CX_NODISCARD CX_NONNULL CX_ACCESS_W(5)
size_t cx_strsplit_a_(const CxAllocator *allocator,
        cxstring string, cxstring delim,
        size_t limit, cxstring **output);
 

CX_EXTERN CX_NODISCARD CX_NONNULL CX_ACCESS_W(4, 3)
size_t cx_strsplit_m_(cxmutstr string, cxstring delim,
        size_t limit, cxmutstr *output);

CX_EXTERN CX_NODISCARD CX_NONNULL CX_ACCESS_W(5)
size_t cx_strsplit_ma_(const CxAllocator *allocator,
        cxmutstr string, cxstring delim, size_t limit,
        cxmutstr **output);
 
#ifdef __cplusplus
CX_CPPDECL size_t cx_strsplit_cpp_(cxstring string, cxstring delim,
        size_t limit, cxstring *output) {
    return cx_strsplit_(string, delim, limit, output);
}
CX_CPPDECL size_t cx_strsplit_cpp_(cxmutstr string, cxstring delim,
        size_t limit, cxmutstr *output) {
    return cx_strsplit_m_(string, delim, limit, output);
}
CX_CPPDECL size_t cx_strsplit_a_cpp_(const CxAllocator *allocator,
        cxstring string, cxstring delim, size_t limit, cxstring **output) {
    return cx_strsplit_a_(allocator, string, delim, limit, output);
}
CX_CPPDECL size_t cx_strsplit_a_cpp_(const CxAllocator *allocator,
        cxmutstr string, cxstring delim, size_t limit, cxmutstr **output) {
    return cx_strsplit_ma_(allocator, string, delim, limit, output);
}
#define cx_strsplit(string, delim, limit, output) \
        cx_strsplit_cpp_(cx_strcast_m(string), cx_strcast(delim), limit, output)
#define cx_strsplit_a(allocator, string, delim, limit, output) \
        cx_strsplit_a_cpp_(allocator, cx_strcast_m(string), cx_strcast(delim), limit, output)
#else
#define cx_strsplit(string, delim, limit, output) \
        _Generic(cx_strcast_m(string), \
        cxstring: cx_strsplit_, \
        cxmutstr: cx_strsplit_m_)\
        (cx_strcast_m(string), cx_strcast(delim), limit, output)

#define cx_strsplit_a(allocator, string, delim, limit, output) \
        _Generic(cx_strcast_m(string), \
        cxstring: cx_strsplit_a_, \
        cxmutstr: cx_strsplit_ma_)\
        (allocator, cx_strcast_m(string), cx_strcast(delim), limit, output)
#endif

CX_EXTERN CX_NODISCARD
int cx_strcmp_(cxstring s1, cxstring s2);

#define cx_strcmp(s1, s2) cx_strcmp_(cx_strcast(s1), cx_strcast(s2))

CX_EXTERN CX_NODISCARD
int cx_strcasecmp_(cxstring s1, cxstring s2);

#define cx_strcasecmp(s1, s2) cx_strcasecmp_(cx_strcast(s1), cx_strcast(s2))

CX_EXTERN CX_NODISCARD CX_NONNULL
int cx_strcmp_p(const void *s1, const void *s2);

CX_EXTERN CX_NODISCARD CX_NONNULL
int cx_strcasecmp_p(const void *s1, const void *s2);

CX_EXTERN CX_NODISCARD CX_NONNULL
cxmutstr cx_strdup_a_(const CxAllocator *allocator, cxstring string);

#define cx_strdup_a(allocator, string) cx_strdup_a_((allocator), cx_strcast(string))

#define cx_strdup(string) cx_strdup_a(cxDefaultAllocator, string)

CX_EXTERN CX_NODISCARD
cxstring cx_strtrim_(cxstring string);
 
#ifdef __cplusplus
CX_CPPDECL cxstring cx_strtrim_cpp_(cxstring string) {
    return cx_strtrim_(string);
}
CX_CPPDECL cxmutstr cx_strtrim_cpp_(cxmutstr string) {
    return cx_mutstrcast(cx_strtrim_(cx_strcast(string)));
}
#define cx_strtrim(string) cx_strtrim_cpp_(cx_strcast_m(string))
#else
CX_INLINE cxmutstr cx_strtrim_m_(cxmutstr string) {
    return cx_mutstrcast(cx_strtrim_(cx_strcast(string)));
}

#define cx_strtrim(string) _Generic(cx_strcast_m(string), \
        cxstring: cx_strtrim_, \
        cxmutstr: cx_strtrim_m_)(cx_strcast_m(string))
#endif

CX_EXTERN CX_NODISCARD
bool cx_strprefix_(cxstring string, cxstring prefix);

#define cx_strprefix(string, prefix) cx_strprefix_(cx_strcast(string), cx_strcast(prefix))

CX_EXTERN CX_NODISCARD
bool cx_strsuffix_(cxstring string, cxstring suffix);

#define cx_strsuffix(string, suffix) cx_strsuffix_(cx_strcast(string), cx_strcast(suffix))

CX_EXTERN CX_NODISCARD
bool cx_strcaseprefix_(cxstring string, cxstring prefix);

#define cx_strcaseprefix(string, prefix) cx_strcaseprefix_(cx_strcast(string), cx_strcast(prefix))

CX_EXTERN CX_NODISCARD
bool cx_strcasesuffix_(cxstring string, cxstring suffix);

#define cx_strcasesuffix(string, suffix) cx_strcasesuffix_(cx_strcast(string), cx_strcast(suffix))

CX_EXTERN CX_NODISCARD CX_NONNULL
cxmutstr cx_strreplace_(const CxAllocator *allocator,
        cxstring str, cxstring search, cxstring replacement, size_t replmax);

#define cx_strreplacen_a(allocator, str, search, replacement, replmax) \
        cx_strreplace_(allocator, cx_strcast(str), cx_strcast(search), cx_strcast(replacement), replmax)

#define cx_strreplacen(str, search, replacement, replmax) \
        cx_strreplacen_a(cxDefaultAllocator, str, search, replacement, replmax)

#define cx_strreplace_a(allocator, str, search, replacement) \
        cx_strreplacen_a(allocator, str, search, replacement, SIZE_MAX)

#define cx_strreplace(str, search, replacement) \
        cx_strreplacen_a(cxDefaultAllocator, str, search, replacement, SIZE_MAX)

CX_EXTERN CX_NODISCARD
CxStrtokCtx cx_strtok_(cxstring str, cxstring delim, size_t limit);

#define cx_strtok(str, delim, limit) \
        cx_strtok_(cx_strcast(str), cx_strcast(delim), (limit))

CX_EXTERN CX_NONNULL CX_NODISCARD CX_ACCESS_W(2)
bool cx_strtok_next_(CxStrtokCtx *ctx, cxstring *token);
 
#ifdef __cplusplus
CX_CPPDECL cx_strtok_next(CxStrtokCtx *ctx, cxstring *token) {
    return cx_strtok_next_(ctx, token);
}
CX_CPPDECL cx_strtok_next(CxStrtokCtx *ctx, cxmutstr *token) {
    // Note: this is actually UB - fixed with start_lifetime_as() in C++23
    //       but it works on all supported platforms
    return cx_strtok_next_(ctx, reinterpret_cast<cxstring*>(token));
}
#else // ! __cplusplus
#define cx_strtok_next(ctx, token) _Generic((token), \
        cxstring*: cx_strtok_next_, \
        cxmutstr*: cx_strtok_next_)(ctx, (cxstring*)token)
#endif

CX_EXTERN CX_NONNULL CX_ACCESS_R(2, 3)
void cx_strtok_delim(CxStrtokCtx *ctx, const cxstring *delim, size_t count);
 
/* ------------------------------------------------------------------------- *
 *                string to number conversion functions                      *
 * ------------------------------------------------------------------------- */

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtos_lc_(cxstring str, short *output, int base, const char *groupsep);

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtoi_lc_(cxstring str, int *output, int base, const char *groupsep);

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtol_lc_(cxstring str, long *output, int base, const char *groupsep);

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtoll_lc_(cxstring str, long long *output, int base, const char *groupsep);

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtoi8_lc_(cxstring str, int8_t *output, int base, const char *groupsep);

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtoi16_lc_(cxstring str, int16_t *output, int base, const char *groupsep);

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtoi32_lc_(cxstring str, int32_t *output, int base, const char *groupsep);

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtoi64_lc_(cxstring str, int64_t *output, int base, const char *groupsep);

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtous_lc_(cxstring str, unsigned short *output, int base, const char *groupsep);

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtou_lc_(cxstring str, unsigned int *output, int base, const char *groupsep);

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtoul_lc_(cxstring str, unsigned long *output, int base, const char *groupsep);

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtoull_lc_(cxstring str, unsigned long long *output, int base, const char *groupsep);

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtou8_lc_(cxstring str, uint8_t *output, int base, const char *groupsep);

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtou16_lc_(cxstring str, uint16_t *output, int base, const char *groupsep);

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtou32_lc_(cxstring str, uint32_t *output, int base, const char *groupsep);

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtou64_lc_(cxstring str, uint64_t *output, int base, const char *groupsep);

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtoz_lc_(cxstring str, size_t *output, int base, const char *groupsep);

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtof_lc_(cxstring str, float *output, char decsep, const char *groupsep);

CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
int cx_strtod_lc_(cxstring str, double *output, char decsep, const char *groupsep);

#define cx_strtos_lc(str, output, base, groupsep) cx_strtos_lc_(cx_strcast(str), output, base, groupsep)

#define cx_strtoi_lc(str, output, base, groupsep) cx_strtoi_lc_(cx_strcast(str), output, base, groupsep)

#define cx_strtol_lc(str, output, base, groupsep) cx_strtol_lc_(cx_strcast(str), output, base, groupsep)

#define cx_strtoll_lc(str, output, base, groupsep) cx_strtoll_lc_(cx_strcast(str), output, base, groupsep)

#define cx_strtoi8_lc(str, output, base, groupsep) cx_strtoi8_lc_(cx_strcast(str), output, base, groupsep)

#define cx_strtoi16_lc(str, output, base, groupsep) cx_strtoi16_lc_(cx_strcast(str), output, base, groupsep)

#define cx_strtoi32_lc(str, output, base, groupsep) cx_strtoi32_lc_(cx_strcast(str), output, base, groupsep)

#define cx_strtoi64_lc(str, output, base, groupsep) cx_strtoi64_lc_(cx_strcast(str), output, base, groupsep)

#define cx_strtous_lc(str, output, base, groupsep) cx_strtous_lc_(cx_strcast(str), output, base, groupsep)

#define cx_strtou_lc(str, output, base, groupsep) cx_strtou_lc_(cx_strcast(str), output, base, groupsep)

#define cx_strtoul_lc(str, output, base, groupsep) cx_strtoul_lc_(cx_strcast(str), output, base, groupsep)

#define cx_strtoull_lc(str, output, base, groupsep) cx_strtoull_lc_(cx_strcast(str), output, base, groupsep)

#define cx_strtou8_lc(str, output, base, groupsep) cx_strtou8_lc_(cx_strcast(str), output, base, groupsep)

#define cx_strtou16_lc(str, output, base, groupsep) cx_strtou16_lc_(cx_strcast(str), output, base, groupsep)

#define cx_strtou32_lc(str, output, base, groupsep) cx_strtou32_lc_(cx_strcast(str), output, base, groupsep)

#define cx_strtou64_lc(str, output, base, groupsep) cx_strtou64_lc_(cx_strcast(str), output, base, groupsep)

#define cx_strtoz_lc(str, output, base, groupsep) cx_strtoz_lc_(cx_strcast(str), output, base, groupsep)

#define cx_strtos(str, output, base) cx_strtos_lc_(cx_strcast(str), output, base, ",")

#define cx_strtoi(str, output, base) cx_strtoi_lc_(cx_strcast(str), output, base, ",")

#define cx_strtol(str, output, base) cx_strtol_lc_(cx_strcast(str), output, base, ",")

#define cx_strtoll(str, output, base) cx_strtoll_lc_(cx_strcast(str), output, base, ",")

#define cx_strtoi8(str, output, base) cx_strtoi8_lc_(cx_strcast(str), output, base, ",")

#define cx_strtoi16(str, output, base) cx_strtoi16_lc_(cx_strcast(str), output, base, ",")

#define cx_strtoi32(str, output, base) cx_strtoi32_lc_(cx_strcast(str), output, base, ",")

#define cx_strtoi64(str, output, base) cx_strtoi64_lc_(cx_strcast(str), output, base, ",")

#define cx_strtoz(str, output, base) cx_strtoz_lc_(cx_strcast(str), output, base, ",")

#define cx_strtous(str, output, base) cx_strtous_lc_(cx_strcast(str), output, base, ",")

#define cx_strtou(str, output, base) cx_strtou_lc_(cx_strcast(str), output, base, ",")

#define cx_strtoul(str, output, base) cx_strtoul_lc_(cx_strcast(str), output, base, ",")

#define cx_strtoull(str, output, base) cx_strtoull_lc_(cx_strcast(str), output, base, ",")

#define cx_strtou8(str, output, base) cx_strtou8_lc_(cx_strcast(str), output, base, ",")

#define cx_strtou16(str, output, base) cx_strtou16_lc_(cx_strcast(str), output, base, ",")

#define cx_strtou32(str, output, base) cx_strtou32_lc_(cx_strcast(str), output, base, ",")

#define cx_strtou64(str, output, base) cx_strtou64_lc_(cx_strcast(str), output, base, ",")

#define cx_strtof_lc(str, output, decsep, groupsep) cx_strtof_lc_(cx_strcast(str), output, decsep, groupsep)

#define cx_strtod_lc(str, output, decsep, groupsep) cx_strtod_lc_(cx_strcast(str), output, decsep, groupsep)

#define cx_strtof(str, output) cx_strtof_lc_(cx_strcast(str), output, '.', ",")

#define cx_strtod(str, output) cx_strtod_lc_(cx_strcast(str), output, '.', ",")
 
#endif //UCX_STRING_H