xroad_string.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _GNU_SOURCE
#  define _GNU_SOURCE
#endif
 
#include "xroad_aux.h"
#include "xroad_format.h"
#include <string.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdarg.h>
#include <ctype.h>
 
#ifdef __cplusplus
extern "C"
{
#endif
 
struct xroad_str_s
{
   uint32_t    len;  
   const char* data; 
};
 
struct xroad_str_fixed_s
{
   uint32_t len; 
   char data[0]; 
};
 
#define xroad_str_concat(str1, str2)                                             \
({                                                                               \
   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};                  \
})
 
#define xroad_str_concata(str1, str2)                                            \
({                                                                               \
   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};                  \
})
 
#define xroad_str_to_cstr(str)                          \
({                                                      \
   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);   \
})
 
#define xroad_str_cmp(a, b)                                             \
({                                                                      \
   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);                     \
})
 
#define xroad_str_startwith(a, prefix)                                           \
({                                                                               \
   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); \
})
 
#define xroad_str_endwith(a, suffix)                                                    \
({                                                                                      \
   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;                                                                                 \
})                                                                                      \
 
#define xroad_str_has(a, subs)                                                                                       \
({                                                                                                                   \
   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));                                \
})
 
#define xroad_str_null (xroad_str_t){0, NULL}
 
#define xroad_str_is_null(str)      \
({                                  \
   xroad_str_t a = (str);           \
   (a.len == 0 && a.data == NULL);  \
})
 
#define xroad_str_is_empty(str)    \
({                                 \
   xroad_str_t a = (str);          \
   (a.len == 0 && a.data != NULL); \
})
 
#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)                                            \
   ({                                                                       \
      char* _s_11_ = (char*)(str);                                          \
      (xroad_str_t){_s_11_ == NULL ? 0 : (uint32_t)strlen(_s_11_), _s_11_}; \
   })
 
#define xroad_str_len(str, len)                                      \
   ({                                                                \
      char* _s_11_ = (char*)(str);                                   \
      (xroad_str_t){_s_11_ == NULL ? 0U : (uint32_t)(len), _s_11_};  \
   })
 
#define xroad_str_free(str)                     \
({                                              \
   xroad_str_t* ptr = (xroad_str_t*)&(str);     \
   free((void*)ptr->data);                      \
   ptr->data = NULL;                            \
   ptr->len = 0;                                \
})
 
#define xroad_str_dup(str)                                                 \
({                                                                         \
   xroad_str_t a = (str);                                                  \
   (xroad_str_t){a.len, a.data == NULL ? NULL : strndup(a.data, a.len)};   \
})
 
#define xroad_str_dupa(str)                                                \
({                                                                         \
   xroad_str_t a = (str);                                                  \
   (xroad_str_t){a.len, a.data == NULL ? NULL : strndupa(a.data, a.len)};  \
})
 
#define xroad_str_alloc(str)                                               \
({                                                                         \
   const char* tmp = (str);                                                \
   (xroad_str_t){(uint32_t)strlen(tmp), tmp == NULL ? NULL : strdup(tmp)}; \
})
 
#define xroad_str_alloc_len(str, len)                                      \
({                                                                         \
   uint32_t len_77 = (len);                                                \
   const char* tmp = (str);                                                \
   (xroad_str_t){len_77, tmp == NULL ? NULL : strndup(tmp, len_77)};       \
})
 
#define xroad_str_alloca(str)                                               \
({                                                                          \
   const char* tmp = (str);                                                 \
   (xroad_str_t){(uint32_t)strlen(tmp), tmp == NULL ? NULL : strdupa(tmp)}; \
})
 
#define xroad_str_fixed_size(str) sizeof((str)->data)
 
#define xroad_str_from_fixed(str)                                             \
({                                                                            \
   __typeof__ (str) ptr_6584 = (str);                                         \
   ptr_6584 ? xroad_str_len(ptr_6584->data, ptr_6584->len) : xroad_str_null;  \
})
 
#define xroad_str_decl(name, sz)                                                          \
typedef struct { uint32_t len; char data[sz]; } name ## _t;
 
#define xroad_str_fixed_set(str, val)                                                     \
({                                                                                        \
   __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;                                                                         \
})
 
#define xroad_str_fixed_vformat(str, fmt, ap)                                                   \
({                                                                                              \
   __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_;                                                                                    \
})
 
#define xroad_str_fixed_format(str, fmt, ...)                                                            \
({                                                                                                       \
   __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_;                                                                                             \
})
 
#define xroad_str_fixed_concat(lhs, rhs)                                                        \
({                                                                                              \
   __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;                                                                                 \
})
 
#define xroad_str_fixed_to_cstr(str)                                     \
({                                                                       \
   __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;                                                                  \
})
 
#define xroad_str_fixed_to_upper(str)                                   \
({                                                                      \
   __typeof__ (str) tmp_1234599 = (str);                                \
   for(uint32_t i = 0; i < tmp_1234599->len; ++i)                       \
   {                                                                    \
      tmp_1234599->data[i] = toupper(tmp_1234599->data[i]);             \
   }                                                                    \
})
 
#define xroad_str_to_sql(v)                                          \
({                                                                   \
   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);                                          \
})
 
#define xroad_str_to_lower(v)                                        \
({                                                                   \
   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};                                        \
})
 
#ifdef __cplusplus
}
#endif