str.h

Go to the documentation of this file.

/* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
/* If you are missing that file, acquire a complete release at teeworlds.com.                */
 
#ifndef BASE_STR_H
#define BASE_STR_H
 
#include <array>
#include <cinttypes>
#include <cstdarg>
#include <cstddef>
#include <cstdint>
#include <cstring>

 
#ifdef __MINGW32__
#undef PRId64
#undef PRIu64
#undef PRIX64
#define PRId64 "I64d"
#define PRIu64 "I64u"
#define PRIX64 "I64X"
#define PRIzu "Iu"
#else
#define PRIzu "zu"
#endif

int str_copy(char *dst, const char *src, int dst_size);

template<int N>
void str_copy(char (&dst)[N], const char *src)
{
    str_copy(dst, src, N);
}

template<size_t N>
void str_copy(std::array<char, N> &dst, const char *src)
{
    str_copy(dst.data(), src, static_cast<int>(N));
}

void str_append(char *dst, const char *src, int dst_size);

template<int N>
void str_append(char (&dst)[N], const char *src)
{
    str_append(dst, src, N);
}

void str_truncate(char *dst, int dst_size, const char *src, int truncation_len);

int str_length(const char *str);

[[gnu::format(printf, 3, 0)]] int str_format_v(char *buffer, int buffer_size, const char *format, va_list args);

[[gnu::format(printf, 3, 4)]] int str_format(char *buffer, int buffer_size, const char *format, ...);
 
#if !defined(CONF_DEBUG)
int str_format_int(char *buffer, size_t buffer_size, int value);
 
template<typename... Args>
int str_format_opt(char *buffer, int buffer_size, const char *format, Args... args)
{
    static_assert(sizeof...(args) > 0, "Use str_copy instead of str_format without format arguments");
    return str_format(buffer, buffer_size, format, args...);
}
 
template<>
inline int str_format_opt(char *buffer, int buffer_size, const char *format, int val) // NOLINT(readability-inconsistent-declaration-parameter-name)
{
    if(strcmp(format, "%d") == 0)
    {
        return str_format_int(buffer, buffer_size, val);
    }
    else
    {
        return str_format(buffer, buffer_size, format, val);
    }
}
 
#define str_format str_format_opt
#endif
 
char str_uppercase(char c);
 
bool str_isnum(char c);
 
bool str_isallnum(const char *str);
 
bool str_isallnum_hex(const char *str);

bool str_isspace(char c);

const char *str_trim_words(const char *str, int words);

bool str_has_cc(const char *str);

void str_sanitize_cc(char *str);

void str_sanitize(char *str);

void str_sanitize_filename(char *str);

bool str_valid_filename(const char *str);

int str_comp_filenames(const char *a, const char *b);

void str_clean_whitespaces(char *str);

char *str_skip_to_whitespace(char *str);

const char *str_skip_to_whitespace_const(const char *str);

char *str_skip_whitespaces(char *str);

const char *str_skip_whitespaces_const(const char *str);

int str_comp_nocase(const char *a, const char *b);

int str_comp_nocase_num(const char *a, const char *b, int num);

int str_comp(const char *a, const char *b);

int str_comp_num(const char *a, const char *b, int num);

const char *str_startswith_nocase(const char *str, const char *prefix);

const char *str_startswith(const char *str, const char *prefix);

const char *str_endswith_nocase(const char *str, const char *suffix);

const char *str_endswith(const char *str, const char *suffix);

const char *str_find_nocase(const char *haystack, const char *needle);

const char *str_find(const char *haystack, const char *needle);

const char *str_next_token(const char *str, const char *delim, char *buffer, size_t buffer_size);

bool str_in_list(const char *list, const char *delim, const char *needle);

bool str_delimiters_around_offset(const char *haystack, const char *delim, int offset, int *start, int *end);

const char *str_rchr(const char *haystack, char needle);

int str_countchr(const char *haystack, char needle);

void str_hex(char *dst, int dst_size, const void *data, int data_size);

void str_hex_cstyle(char *dst, int dst_size, const void *data, int data_size, int bytes_per_line = 12);

int str_hex_decode(void *dst, int dst_size, const char *src);

void str_base64(char *dst, int dst_size, const void *data, int data_size);

int str_base64_decode(void *dst, int dst_size, const char *data);

void str_escape(char **dst, const char *src, const char *end);

void str_unescape_newlines(char *str);
 
int str_toint(const char *str);
bool str_toint(const char *str, int *out);
int str_toint_base(const char *str, int base);
unsigned long str_toulong_base(const char *str, int base);
int64_t str_toint64_base(const char *str, int base = 10);
float str_tofloat(const char *str);
bool str_tofloat(const char *str, float *out);
 
unsigned str_quickhash(const char *str);

int str_utf8_encode(char *ptr, int chr);

int str_utf8_decode(const char **ptr);

void str_utf8_truncate(char *dst, int dst_size, const char *src, int truncation_len);

int str_utf8_fix_truncation(char *str);

void str_utf8_trim_right(char *param);

void str_utf8_tolower(const char *input, char *output, size_t size);

bool str_utf8_isspace(int code);

bool str_utf8_isstart(char c);

int str_utf8_rewind(const char *str, int cursor);

const char *str_utf8_find_nocase(const char *haystack, const char *needle, const char **end = nullptr);

int str_utf8_comp_nocase(const char *a, const char *b);

int str_utf8_comp_nocase_num(const char *a, const char *b, int num);

const char *str_utf8_skip_whitespaces(const char *str);

int str_utf8_forward(const char *str, int cursor);

bool str_utf8_check(const char *str);

void str_utf8_copy_num(char *dst, const char *src, int dst_size, int num);

void str_utf8_stats(const char *str, size_t max_size, size_t max_count, size_t *size, size_t *count);

size_t str_utf8_offset_bytes_to_chars(const char *str, size_t byte_offset);

size_t str_utf8_offset_chars_to_bytes(const char *str, size_t char_offset);

int str_utf8_dist(const char *a, const char *b);

int str_utf8_dist_buffer(const char *a, const char *b, int *buf, int buf_len);

int str_utf32_dist_buffer(const int *a, int a_len, const int *b, int b_len, int *buf, int buf_len);
 
int str_utf8_to_skeleton(const char *str, int *buf, int buf_len);

int str_utf8_comp_confusable(const char *str1, const char *str2);

int str_utf8_tolower_codepoint(int code);
 
#endif