XROAD
Classes | Macros
xroad_string.h File Reference
#include "xroad_aux.h"
#include "xroad_format.h"
#include <string.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdarg.h>
#include <ctype.h>
Include dependency graph for xroad_string.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  xroad_str_s
 
struct  xroad_str_fixed_s
 

Macros

#define _GNU_SOURCE
 
#define xroad_str_concat(str1, str2)
 
#define xroad_str_concata(str1, str2)
 
#define xroad_str_to_cstr(str)
 
#define xroad_str_cmp(a, b)
 
#define xroad_str_startwith(a, prefix)
 
#define xroad_str_endwith(a, suffix)
 
#define xroad_str_has(a, subs)
 
#define xroad_str_null   (xroad_str_t){0, NULL}
 
#define xroad_str_is_null(str)
 
#define xroad_str_is_empty(str)
 
#define xroad_str(str)   (xroad_str_t){sizeof(str) - 1, str}
 
#define xroad_str_from_arr(arr)   (xroad_str_t){strnlen(arr, sizeof(arr)), arr}
 
#define xroad_str_from_cstr(str)
 
#define xroad_str_len(str, len)
 
#define xroad_str_free(str)
 
#define xroad_str_dup(str)
 
#define xroad_str_dupa(str)
 
#define xroad_str_alloc(str)
 
#define xroad_str_alloc_len(str, len)
 
#define xroad_str_alloca(str)
 
#define xroad_str_fixed_size(str)   sizeof((str)->data)
 
#define xroad_str_from_fixed(str)
 
#define xroad_str_decl(name, sz)   typedef struct { uint32_t len; char data[sz]; } name ## _t;
 
#define xroad_str_fixed_set(str, val)
 
#define xroad_str_fixed_vformat(str, fmt, ap)
 
#define xroad_str_fixed_format(str, fmt, ...)
 
#define xroad_str_fixed_concat(lhs, rhs)
 
#define xroad_str_fixed_to_cstr(str)
 
#define xroad_str_fixed_to_upper(str)
 
#define xroad_str_to_sql(v)
 
#define xroad_str_to_lower(v)
 

Detailed Description

Author
Dmitry S. Melnikov, dmitr.nosp@m.yme@.nosp@m.gmail.nosp@m..com

Macro Definition Documentation

◆ xroad_str

#define xroad_str (   str)    (xroad_str_t){sizeof(str) - 1, str}

convert string literal(!) to xroad_str_t

◆ xroad_str_alloc

#define xroad_str_alloc (   str)
Value:
({ \
const char* tmp = (str); \
(xroad_str_t){(uint32_t)strlen(tmp), tmp == NULL ? NULL : strdup(tmp)}; \
})
xroad_str_t
struct xroad_str_s xroad_str_t
see common/xroad_string.h for details
Definition: xroad_common_fwd.h:39

allocate new string

◆ xroad_str_alloc_len

#define xroad_str_alloc_len (   str,
  len 
)
Value:
({ \
uint32_t len_77 = (len); \
const char* tmp = (str); \
(xroad_str_t){len_77, tmp == NULL ? NULL : strndup(tmp, len_77)}; \
})

allocate new string with len

◆ xroad_str_alloca

#define xroad_str_alloca (   str)
Value:
({ \
const char* tmp = (str); \
(xroad_str_t){(uint32_t)strlen(tmp), tmp == NULL ? NULL : strdupa(tmp)}; \
})

allocate new string using alloca

◆ xroad_str_cmp

#define xroad_str_cmp (   a,
  b 
)
Value:
({ \
xroad_str_t tmp_1234599 = (a); \
xroad_str_t tmp_5432199 = (b); \
tmp_1234599.len == tmp_5432199.len ? \
strncmp(tmp_1234599.data, tmp_5432199.data, tmp_1234599.len) : \
(tmp_1234599.len < tmp_5432199.len ? -1 : 1); \
})

compare two strings

Returns
the same as for strcmp

◆ xroad_str_concat

#define xroad_str_concat (   str1,
  str2 
)
Value:
({ \
xroad_str_t tmp_1234599 = (str1); \
xroad_str_t tmp_5432199 = (str2); \
char* data_1234 = (char*)malloc(tmp_1234599.len + tmp_5432199.len); \
memcpy(data_1234, tmp_1234599.data, tmp_1234599.len); \
memcpy(data_1234 + tmp_1234599.len, tmp_5432199.data, tmp_5432199.len); \
(xroad_str_t){tmp_1234599.len + tmp_5432199.len, data_1234}; \
})

concatenate two strings

Parameters
[in,out]str1- destination string
[in]str2- source c-string

◆ xroad_str_concata

#define xroad_str_concata (   str1,
  str2 
)
Value:
({ \
xroad_str_t tmp_1234599 = (str1); \
xroad_str_t tmp_5432199 = (str2); \
char* data_1234 = (char*)alloca(tmp_1234599.len + tmp_5432199.len); \
memcpy(data_1234, tmp_1234599.data, tmp_1234599.len); \
memcpy(data_1234 + tmp_1234599.len, tmp_5432199.data, tmp_5432199.len); \
(xroad_str_t){tmp_1234599.len + tmp_5432199.len, data_1234}; \
})

concatenate two strings at malloca buffer

Parameters
[in,out]str1- destination string
[in]str2- source c-string

◆ xroad_str_decl

#define xroad_str_decl (   name,
  sz 
)    typedef struct { uint32_t len; char data[sz]; } name ## _t;

creates fixed length string and related methods for string data + 1 byte for zero end char

Parameters
[in]name- name of type
[in]sz- maximum string length.

◆ xroad_str_dup

#define xroad_str_dup (   str)
Value:
({ \
xroad_str_t a = (str); \
(xroad_str_t){a.len, a.data == NULL ? NULL : strndup(a.data, a.len)}; \
})

duplicates string

◆ xroad_str_dupa

#define xroad_str_dupa (   str)
Value:
({ \
xroad_str_t a = (str); \
(xroad_str_t){a.len, a.data == NULL ? NULL : strndupa(a.data, a.len)}; \
})

duplicates string using alloca

◆ xroad_str_endwith

#define xroad_str_endwith (   a,
  suffix 
)
Value:
({ \
xroad_str_t a_1234599 = (a); \
xroad_str_t suffix_5432199 = (suffix); \
bool res = a_1234599.len < suffix_5432199.len; \
if (!res) \
{ \
uint32_t offset = a_1234599.len - suffix_5432199.len; \
res = !strncmp(a_1234599.data + offset, suffix_5432199.data, suffix_5432199.len); \
} \
res; \
}) \

check if string ends with suffix

Returns
true or false

◆ xroad_str_fixed_concat

#define xroad_str_fixed_concat (   lhs,
  rhs 
)
Value:
({ \
__typeof__ (lhs) _lhs = (lhs); \
xroad_str_t _rhs = (rhs); \
uint32_t cat_len_123 = xroad_min((xroad_str_fixed_size(_lhs) - _lhs->len), _rhs.len); \
memcpy(_lhs->data + _lhs->len, _rhs.data, cat_len_123); \
_lhs->len += cat_len_123; \
cat_len_123; \
})
xroad_min
#define xroad_min(a, b)
Definition: xroad_aux.h:32
xroad_str_fixed_size
#define xroad_str_fixed_size(str)
Definition: xroad_string.h:250

concatenate two fixed length strings

Parameters
[in]lhs- pointer to fixed length string
[in]rhs- xroad_str_t
Returns
new fixed length str size

◆ xroad_str_fixed_format

#define xroad_str_fixed_format (   str,
  fmt,
  ... 
)
Value:
({ \
__typeof__ (str) str_123_ = (str); \
int32_t res_123_ = xroad_format(str_123_->data, xroad_str_fixed_size(str_123_), fmt, ## __VA_ARGS__); \
if (res_123_ > 0) \
{ \
str_123_->len = xroad_min((uint32_t)res_123_, xroad_str_fixed_size(str_123_)); \
} \
res_123_; \
})
xroad_format
int32_t xroad_format(char *buf, uint32_t len, const char *fmt,...)

set fixed length string using format. The same as xroad_str_fixed_vformat

Parameters
[in]str- pointer to fixed length string to set
[in]fmt- format (see xroad_format.h for format details)
Returns
length of str after applying format

◆ xroad_str_fixed_set

#define xroad_str_fixed_set (   str,
  val 
)
Value:
({ \
__typeof__ (str) _str_123 = (str); \
xroad_str_t _val_123 = (val); \
_str_123->len = xroad_min(xroad_str_fixed_size(_str_123), _val_123.len); \
if (!xroad_str_is_null(_val_123)) \
{ \
memcpy(_str_123->data, _val_123.data, _str_123->len); \
} \
_str_123->len; \
})
xroad_str_is_null
#define xroad_str_is_null(str)
Definition: xroad_string.h:147

set fixed length string with data

Parameters
[in]str- pointer to fixed length string to set
[in]val- pointer to xroad_str_t with value to set
Returns
new length of fixed string

◆ xroad_str_fixed_size

#define xroad_str_fixed_size (   str)    sizeof((str)->data)

returns fixed string size

◆ xroad_str_fixed_to_cstr

#define xroad_str_fixed_to_cstr (   str)
Value:
({ \
__typeof__ (str) tmp_1234599 = (str); \
char* res = NULL; \
if (tmp_1234599) \
{ \
char* tmp_991 = (char*)alloca(tmp_1234599->len + 1); \
tmp_991[tmp_1234599->len] = 0; \
res = (char*)memcpy(tmp_991, tmp_1234599->data, tmp_1234599->len); \
} \
res; \
})

convert fixed length string to c-string. c-string is allocated on stack

Parameters
[in]str- pointer to fixed length string
Returns
c-string

◆ xroad_str_fixed_to_upper

#define xroad_str_fixed_to_upper (   str)
Value:
({ \
__typeof__ (str) tmp_1234599 = (str); \
for(uint32_t i = 0; i < tmp_1234599->len; ++i) \
{ \
tmp_1234599->data[i] = toupper(tmp_1234599->data[i]); \
} \
})

convert string to upper case

Parameters
[in]str- string to convert

◆ xroad_str_fixed_vformat

#define xroad_str_fixed_vformat (   str,
  fmt,
  ap 
)
Value:
({ \
__typeof__ (str) str_123_ = (str); \
int32_t res_123_ = xroad_vformat(str_123_->data, xroad_str_fixed_size(str_123_), fmt, ap); \
if (res_123_ > 0) \
{ \
str_123_->len = xroad_min((uint32_t)res_123_, xroad_str_fixed_size(str_123_)); \
} \
res_123_; \
})
xroad_vformat
int32_t xroad_vformat(char *buf, uint32_t len, const char *fmt, va_list ap)

set fixed length string using format

Parameters
[in]str- pointer to fixed length string to set
[in]fmt- format (see xroad_format.h for format details)
[in]ap- list of parameters
Returns
length of str after applying format

◆ xroad_str_free

#define xroad_str_free (   str)
Value:
({ \
xroad_str_t* ptr = (xroad_str_t*)&(str); \
free((void*)ptr->data); \
ptr->data = NULL; \
ptr->len = 0; \
})
xroad_str_s
Definition: xroad_string.h:29

frees string data

◆ xroad_str_from_arr

#define xroad_str_from_arr (   arr)    (xroad_str_t){strnlen(arr, sizeof(arr)), arr}

convert char array to xroad_str_t

◆ xroad_str_from_cstr

#define xroad_str_from_cstr (   str)
Value:
({ \
char* _s_11_ = (char*)(str); \
(xroad_str_t){_s_11_ == NULL ? 0 : (uint32_t)strlen(_s_11_), _s_11_}; \
})

convert string to xroad_str_t

◆ xroad_str_from_fixed

#define xroad_str_from_fixed (   str)
Value:
({ \
__typeof__ (str) ptr_6584 = (str); \
ptr_6584 ? xroad_str_len(ptr_6584->data, ptr_6584->len) : xroad_str_null; \
})
xroad_str_len
#define xroad_str_len(str, len)
Definition: xroad_string.h:184
xroad_str_null
#define xroad_str_null
Definition: xroad_string.h:142

converts fixed length string ptr to xroad_str_t

◆ xroad_str_has

#define xroad_str_has (   a,
  subs 
)
Value:
({ \
xroad_str_t a_1234599 = (a); \
xroad_str_t subs_5432199 = (subs); \
void* res_1234599 = memmem((void*)a_1234599.data, a_1234599.len, (void*)subs_5432199.data, subs_5432199.len); \
(int64_t)(!res_1234599 ? -1 : ((uint64_t)res_1234599 - (uint64_t)a_1234599.data)); \
})

check if string contains substring (subs)

Returns
-1 - string has no subs, else offset of subs placement

◆ xroad_str_is_empty

#define xroad_str_is_empty (   str)
Value:
({ \
xroad_str_t a = (str); \
(a.len == 0 && a.data != NULL); \
})

check if string is empty('')

◆ xroad_str_is_null

#define xroad_str_is_null (   str)
Value:
({ \
xroad_str_t a = (str); \
(a.len == 0 && a.data == NULL); \
})

check if string is null

◆ xroad_str_len

#define xroad_str_len (   str,
  len 
)
Value:
({ \
char* _s_11_ = (char*)(str); \
(xroad_str_t){_s_11_ == NULL ? 0U : (uint32_t)(len), _s_11_}; \
})

create xroad_str_t from str and its length

◆ xroad_str_null

#define xroad_str_null   (xroad_str_t){0, NULL}

null string

◆ xroad_str_startwith

#define xroad_str_startwith (   a,
  prefix 
)
Value:
({ \
xroad_str_t a_1234599 = (a); \
xroad_str_t prefix_5432199 = (prefix); \
a_1234599.len < prefix_5432199.len ? false : !strncmp(a_1234599.data, prefix_5432199.data, prefix_5432199.len); \
})

check if string starts with prefix

Returns
true or false

◆ xroad_str_to_cstr

#define xroad_str_to_cstr (   str)
Value:
({ \
xroad_str_t _tmp_9023 = (str); \
char* res = (char*)alloca(_tmp_9023.len + 1); \
res[_tmp_9023.len] = '\0'; \
(char*)memcpy(res, _tmp_9023.data, _tmp_9023.len); \
})

convert string to c-string

Parameters
[in]str- string to convert
Returns
c-string, must NOT be deallocated to free call

◆ xroad_str_to_lower

#define xroad_str_to_lower (   v)
Value:
({ \
xroad_str_t s = (v); \
char* buf = alloca(s.len); \
for(int32_t i = 0;i < s.len; ++i) \
{ \
buf[i] = tolower(s.data[i]); \
} \
(xroad_str_t){s.len, buf}; \
})

converts string to lower case

◆ xroad_str_to_sql

#define xroad_str_to_sql (   v)
Value:
({ \
xroad_str_t s = (v); \
char* buf = "NULL"; \
uint32_t len = 4; \
if (!xroad_str_is_null(s)) \
{ \
buf = alloca(s.len * 2 + 2); \
char* it = buf; \
*it = '\''; \
++it; \
len = 1; \
for (int32_t i = 0; i < s.len; ++i) \
{ \
if (s.data[i] == '\'') \
{ \
*it = '\''; \
++it; \
len += 1; \
} \
*it = s.data[i]; \
++it; \
len += 1; \
} \
*it = '\''; \
len += 1; \
} \
xroad_str_len(buf, len); \
})

convert string to SQL representation (NULL, 'string ''value') with escaping

Parameters
[in]v- xroad_str_t to convert
Returns
xroad_str_t SQL string