string.h

Go to the documentation of this file.

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2017 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 "ucx.h"
#include "allocator.h"
#include <stddef.h>

/*
 * Use this macro to disable the shortcuts if you experience macro collision.
 */
#ifndef UCX_NO_SSTR_SHORTCUTS

#define ST(s) { s, sizeof(s)-1 }

#define S(s) sstrn(s, sizeof(s)-1)

#define SC(s) scstrn(s, sizeof(s)-1)
#endif /* UCX_NO_SSTR_SHORTCUTS */

/*
 * Use this macro to disable the format macros.
 */
#ifndef UCX_NO_SSTR_FORMAT_MACROS

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

#define PRIsstr ".*s"
#endif /* UCX_NO_SSTR_FORMAT_MACROS */

#ifdef  __cplusplus
extern "C" {
#endif
  
typedef struct {
    char *ptr;
    size_t length;
} sstr_t;

typedef struct {
    const char *ptr;
    size_t length;
} scstr_t;

#ifdef  __cplusplus
}
#endif


#ifdef __cplusplus

inline scstr_t s2scstr(sstr_t s) {
    scstr_t c;
    c.ptr = s.ptr;
    c.length = s.length;
    return c;
}

inline scstr_t s2scstr(scstr_t str) {
    return str;
}

#define SCSTR(s) s2scstr(s)
#else

scstr_t ucx_sc2sc(scstr_t str);

scstr_t ucx_ss2sc(sstr_t str);

#if __STDC_VERSION__ >= 201112L

#define SCSTR(str) _Generic(str, sstr_t: ucx_ss2sc, scstr_t: ucx_sc2sc)(str)

#elif defined(__GNUC__) || defined(__clang__)

#define SCSTR(str) __builtin_choose_expr( \
        __builtin_types_compatible_p(typeof(str), sstr_t), \
        ucx_ss2sc, \
        ucx_sc2sc)(str)

#elif defined(__sun)

#define SCSTR(str) ({typeof(str) ucx_tmp_var_str = str; \
    scstr_t ucx_tmp_var_c; \
    ucx_tmp_var_c.ptr = ucx_tmp_var_str.ptr;\
    ucx_tmp_var_c.length = ucx_tmp_var_str.length;\
    ucx_tmp_var_c; })
#else /* no generics and no builtins */

scstr_t ucx_ss2c_s();

#define SCSTR(str) ucx_ss2c_s(str)
#endif /* C11 feature test */

#endif /* C++ */

#ifdef  __cplusplus
extern "C" {
#endif


sstr_t sstr(char *cstring);

sstr_t sstrn(char *cstring, size_t length);

scstr_t scstr(const char *cstring);


scstr_t scstrn(const char *cstring, size_t length);

size_t scstrnlen(size_t count, ...);

#define sstrnlen(count, ...) scstrnlen(count, __VA_ARGS__)

sstr_t scstrcat(size_t count, scstr_t s1, ...);

#define sstrcat(count, s1, ...) scstrcat(count, SCSTR(s1), __VA_ARGS__)

sstr_t scstrcat_a(UcxAllocator *alloc, size_t count, scstr_t s1, ...);

#define sstrcat_a(alloc, count, s1, ...) \
    scstrcat_a(alloc, count, SCSTR(s1), __VA_ARGS__)

sstr_t sstrsubs(sstr_t string, size_t start);

sstr_t sstrsubsl(sstr_t string, size_t start, size_t length);

scstr_t scstrsubs(scstr_t string, size_t start);

scstr_t scstrsubsl(scstr_t string, size_t start, size_t length);

sstr_t sstrchr(sstr_t string, int chr);

sstr_t sstrrchr(sstr_t string, int chr);

scstr_t scstrchr(scstr_t string, int chr);

scstr_t scstrrchr(scstr_t string, int chr);

sstr_t scstrsstr(sstr_t string, scstr_t match);

#define sstrstr(string, match) scstrsstr(string, SCSTR(match))

scstr_t scstrscstr(scstr_t string, scstr_t match);

#define sstrscstr(string, match) scstrscstr(string, SCSTR(match))

sstr_t* scstrsplit(scstr_t string, scstr_t delim, ssize_t *count);

#define sstrsplit(string, delim, count) \
    scstrsplit(SCSTR(string), SCSTR(delim), count)

sstr_t* scstrsplit_a(UcxAllocator *allocator, scstr_t string, scstr_t delim,
        ssize_t *count);

#define sstrsplit_a(allocator, string, delim, count) \
    scstrsplit_a(allocator, SCSTR(string), SCSTR(delim), count)

int scstrcmp(scstr_t s1, scstr_t s2);

#define sstrcmp(s1, s2) scstrcmp(SCSTR(s1), SCSTR(s2))

int scstrcasecmp(scstr_t s1, scstr_t s2);

#define sstrcasecmp(s1, s2) scstrcasecmp(SCSTR(s1), SCSTR(s2))

sstr_t scstrdup(scstr_t string);

#define sstrdup(string) scstrdup(SCSTR(string))

sstr_t scstrdup_a(UcxAllocator *allocator, scstr_t string);

#define sstrdup_a(allocator, string) scstrdup_a(allocator, SCSTR(string))


sstr_t sstrtrim(sstr_t string);

scstr_t scstrtrim(scstr_t string);

int scstrprefix(scstr_t string, scstr_t prefix);

#define sstrprefix(string, prefix) scstrprefix(SCSTR(string), SCSTR(prefix))

int scstrsuffix(scstr_t string, scstr_t suffix);

#define sstrsuffix(string, suffix) scstrsuffix(SCSTR(string), SCSTR(suffix))

int scstrcaseprefix(scstr_t string, scstr_t prefix);

#define sstrcaseprefix(string, prefix) \
  scstrcaseprefix(SCSTR(string), SCSTR(prefix))

int scstrcasesuffix(scstr_t string, scstr_t suffix);

#define sstrcasesuffix(string, suffix) \
  scstrcasesuffix(SCSTR(string), SCSTR(suffix))

sstr_t scstrlower(scstr_t string);

#define sstrlower(string) scstrlower(SCSTR(string))

sstr_t scstrlower_a(UcxAllocator *allocator, scstr_t string);


#define sstrlower_a(allocator, string) scstrlower_a(allocator, SCSTR(string))

sstr_t scstrupper(scstr_t string);

#define sstrupper(string) scstrupper(SCSTR(string))

sstr_t scstrupper_a(UcxAllocator *allocator, scstr_t string);

#define sstrupper_a(allocator, string) scstrupper_a(allocator, string)

#ifdef  __cplusplus
}
#endif

#endif  /* UCX_STRING_H */