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"
 
cx_attr_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;
 
#ifdef __cplusplus
extern "C" {
 
#define CX_STR(literal) cxstring{literal, sizeof(literal) - 1}
 
#else // __cplusplus
 
#define CX_STR(literal) ((cxstring){literal, sizeof(literal) - 1})
 
#endif
 
 
cx_attr_nonnull
cx_attr_nodiscard
cx_attr_cstr_arg(1)
cx_attr_export
cxmutstr cx_mutstr(char *cstring);
 
cx_attr_nodiscard
cx_attr_access_rw(1, 2)
cx_attr_export
cxmutstr cx_mutstrn(
        char *cstring,
        size_t length
);
 
cx_attr_nonnull
cx_attr_nodiscard
cx_attr_cstr_arg(1)
cx_attr_export
cxstring cx_str(const char *cstring);
 
 
cx_attr_nodiscard
cx_attr_access_r(1, 2)
cx_attr_export
cxstring cx_strn(
        const char *cstring,
        size_t length
);
 
#ifdef __cplusplus
} // extern "C"
cx_attr_nodiscard
static inline cxstring cx_strcast(cxmutstr str) {
    return cx_strn(str.ptr, str.length);
}
cx_attr_nodiscard
static inline cxstring cx_strcast(cxstring str) {
    return str;
}
extern "C" {
#else
cx_attr_nodiscard
static inline cxstring cx_strcast_m(cxmutstr str) {
    return (cxstring) {str.ptr, str.length};
}
cx_attr_nodiscard
static inline cxstring cx_strcast_c(cxstring str) {
    return str;
}
 
#define cx_strcast(str) _Generic((str), \
        cxmutstr: cx_strcast_m, \
        cxstring: cx_strcast_c) \
        (str)
#endif
 
cx_attr_export
void cx_strfree(cxmutstr *str);
 
cx_attr_nonnull_arg(1)
cx_attr_export
void cx_strfree_a(
        const CxAllocator *alloc,
        cxmutstr *str
);
 
cx_attr_nodiscard
cx_attr_export
size_t cx_strlen(
        size_t count,
        ...
);
 
cx_attr_nodiscard
cx_attr_nonnull
cx_attr_export
cxmutstr cx_strcat_ma(
        const CxAllocator *alloc,
        cxmutstr str,
        size_t count,
        ...
);
 
#define cx_strcat_a(alloc, count, ...) \
cx_strcat_ma(alloc, cx_mutstrn(NULL, 0), count, __VA_ARGS__)
 
#define cx_strcat(count, ...) \
cx_strcat_ma(cxDefaultAllocator, cx_mutstrn(NULL, 0), count, __VA_ARGS__)
 
#define cx_strcat_m(str, count, ...) \
cx_strcat_ma(cxDefaultAllocator, str, count, __VA_ARGS__)
 
cx_attr_nodiscard
cx_attr_export
cxstring cx_strsubs(
        cxstring string,
        size_t start
);
 
cx_attr_nodiscard
cx_attr_export
cxstring cx_strsubsl(
        cxstring string,
        size_t start,
        size_t length
);
 
cx_attr_nodiscard
cx_attr_export
cxmutstr cx_strsubs_m(
        cxmutstr string,
        size_t start
);
 
cx_attr_nodiscard
cx_attr_export
cxmutstr cx_strsubsl_m(
        cxmutstr string,
        size_t start,
        size_t length
);
 
cx_attr_nodiscard
cx_attr_export
cxstring cx_strchr(
        cxstring string,
        int chr
);
 
cx_attr_nodiscard
cx_attr_export
cxmutstr cx_strchr_m(
        cxmutstr string,
        int chr
);
 
cx_attr_nodiscard
cx_attr_export
cxstring cx_strrchr(
        cxstring string,
        int chr
);
 
cx_attr_nodiscard
cx_attr_export
cxmutstr cx_strrchr_m(
        cxmutstr string,
        int chr
);
 
cx_attr_nodiscard
cx_attr_export
cxstring cx_strstr(
        cxstring haystack,
        cxstring needle
);
 
cx_attr_nodiscard
cx_attr_export
cxmutstr cx_strstr_m(
        cxmutstr haystack,
        cxstring needle
);
 
cx_attr_nodiscard
cx_attr_nonnull
cx_attr_access_w(4, 3)
cx_attr_export
size_t cx_strsplit(
        cxstring string,
        cxstring delim,
        size_t limit,
        cxstring *output
);
 
cx_attr_nodiscard
cx_attr_nonnull
cx_attr_access_w(5)
cx_attr_export
size_t cx_strsplit_a(
        const CxAllocator *allocator,
        cxstring string,
        cxstring delim,
        size_t limit,
        cxstring **output
);
 
 
cx_attr_nodiscard
cx_attr_nonnull
cx_attr_access_w(4, 3)
cx_attr_export
size_t cx_strsplit_m(
        cxmutstr string,
        cxstring delim,
        size_t limit,
        cxmutstr *output
);
 
cx_attr_nodiscard
cx_attr_nonnull
cx_attr_access_w(5)
cx_attr_export
size_t cx_strsplit_ma(
        const CxAllocator *allocator,
        cxmutstr string,
        cxstring delim,
        size_t limit,
        cxmutstr **output
);
 
cx_attr_nodiscard
cx_attr_export
int cx_strcmp(
        cxstring s1,
        cxstring s2
);
 
cx_attr_nodiscard
cx_attr_export
int cx_strcasecmp(
        cxstring s1,
        cxstring s2
);
 
cx_attr_nodiscard
cx_attr_nonnull
cx_attr_export
int cx_strcmp_p(
        const void *s1,
        const void *s2
);
 
cx_attr_nodiscard
cx_attr_nonnull
cx_attr_export
int cx_strcasecmp_p(
        const void *s1,
        const void *s2
);
 
 
cx_attr_nodiscard
cx_attr_nonnull
cx_attr_export
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_attr_nodiscard
cx_attr_export
cxstring cx_strtrim(cxstring string);
 
cx_attr_nodiscard
cx_attr_export
cxmutstr cx_strtrim_m(cxmutstr string);
 
cx_attr_nodiscard
cx_attr_export
bool cx_strprefix(
        cxstring string,
        cxstring prefix
);
 
cx_attr_nodiscard
cx_attr_export
bool cx_strsuffix(
        cxstring string,
        cxstring suffix
);
 
cx_attr_nodiscard
cx_attr_export
bool cx_strcaseprefix(
        cxstring string,
        cxstring prefix
);
 
cx_attr_nodiscard
cx_attr_export
bool cx_strcasesuffix(
        cxstring string,
        cxstring suffix
);
 
cx_attr_nodiscard
cx_attr_nonnull
cx_attr_export
cxmutstr cx_strreplacen_a(
        const CxAllocator *allocator,
        cxstring str,
        cxstring search,
        cxstring replacement,
        size_t 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_attr_nodiscard
cx_attr_export
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_attr_nonnull
cx_attr_nodiscard
cx_attr_access_w(2)
cx_attr_export
bool cx_strtok_next(
        CxStrtokCtx *ctx,
        cxstring *token
);
 
cx_attr_nonnull
cx_attr_nodiscard
cx_attr_access_w(2)
cx_attr_export
bool cx_strtok_next_m(
        CxStrtokCtx *ctx,
        cxmutstr *token
);
 
cx_attr_nonnull
cx_attr_access_r(2, 3)
cx_attr_export
void cx_strtok_delim(
        CxStrtokCtx *ctx,
        const cxstring *delim,
        size_t count
);
 
/* ------------------------------------------------------------------------- *
 *                string to number conversion functions                      *
 * ------------------------------------------------------------------------- */
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
int cx_strtos_lc_(cxstring str, short *output, int base, const char *groupsep);
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
int cx_strtoi_lc_(cxstring str, int *output, int base, const char *groupsep);
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
int cx_strtol_lc_(cxstring str, long *output, int base, const char *groupsep);
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
int cx_strtoll_lc_(cxstring str, long long *output, int base, const char *groupsep);
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
int cx_strtoi8_lc_(cxstring str, int8_t *output, int base, const char *groupsep);
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
int cx_strtoi16_lc_(cxstring str, int16_t *output, int base, const char *groupsep);
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
int cx_strtoi32_lc_(cxstring str, int32_t *output, int base, const char *groupsep);
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
int cx_strtoi64_lc_(cxstring str, int64_t *output, int base, const char *groupsep);
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
int cx_strtous_lc_(cxstring str, unsigned short *output, int base, const char *groupsep);
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
int cx_strtou_lc_(cxstring str, unsigned int *output, int base, const char *groupsep);
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
int cx_strtoul_lc_(cxstring str, unsigned long *output, int base, const char *groupsep);
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
int cx_strtoull_lc_(cxstring str, unsigned long long *output, int base, const char *groupsep);
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
int cx_strtou8_lc_(cxstring str, uint8_t *output, int base, const char *groupsep);
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
int cx_strtou16_lc_(cxstring str, uint16_t *output, int base, const char *groupsep);
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
int cx_strtou32_lc_(cxstring str, uint32_t *output, int base, const char *groupsep);
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
int cx_strtou64_lc_(cxstring str, uint64_t *output, int base, const char *groupsep);
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
int cx_strtoz_lc_(cxstring str, size_t *output, int base, const char *groupsep);
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
int cx_strtof_lc_(cxstring str, float *output, char decsep, const char *groupsep);
 
cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
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, '.', ",")
 
#ifdef __cplusplus
} // extern "C"
#endif
 
#endif //UCX_STRING_H