src/a.c

   1 #define LIBA_A_C
   2 #include "a/a.h"
   3 #include <string.h>
   4 #include <stdlib.h>
   5 #if defined(A_HAVE_MIMALLOC_H)
   6 #include <mimalloc-override.h>
   7 #endif /* A_HAVE_MIMALLOC_H */
   8
   9 void *a_copy(void *__restrict dst, void const *__restrict src, a_size siz) { return memcpy(dst, src, siz); }
  10
  11 void *a_move(void *dst, void const *src, a_size siz) { return memmove(dst, src, siz); }
  12
  13 void *a_fill(void *ptr, a_size siz, int val) { return memset(ptr, val, siz); }
  14
  15 void *a_zero(void *ptr, a_size siz) { return memset(ptr, 0, siz); }
  16
  17 void a_swap(void *_lhs, void *_rhs, a_size siz)
  18 {
  19     a_byte *lhs = (a_byte *)_lhs;
  20     a_byte *rhs = (a_byte *)_rhs;
  21     for (a_byte buf; siz; --siz, ++lhs, ++rhs)
  22     {
  23         buf = *lhs;
  24         *lhs = *rhs;
  25         *rhs = buf;
  26     }
  27 }
  28
  29 a_u32 a_hash_bkdr(void const *_str, a_u32 val)
  30 {
  31     a_byte const *str = (a_byte const *)_str;
  32     if (str)
  33     {
  34         for (; *str; ++str)
  35         {
  36             val = val * 131 + *str;
  37         }
  38     }
  39     return val;
  40 }
  41
  42 a_u32 a_hash_bkdr_(void const *_ptr, a_size siz, a_u32 val)
  43 {
  44     a_byte const *ptr = (a_byte const *)_ptr;
  45     if (ptr && siz)
  46     {
  47         for (; siz; --siz, ++ptr)
  48         {
  49             val = val * 131 + *ptr;
  50         }
  51     }
  52     return val;
  53 }
  54
  55 a_u32 a_hash_sdbm(void const *_str, a_u32 val)
  56 {
  57     a_byte const *str = (a_byte const *)_str;
  58     if (str)
  59     {
  60         for (; *str; ++str)
  61         {
  62             val = val * 65599 + *str;
  63         }
  64     }
  65     return val;
  66 }
  67
  68 a_u32 a_hash_sdbm_(void const *_ptr, a_size siz, a_u32 val)
  69 {
  70     a_byte const *ptr = (a_byte const *)_ptr;
  71     if (ptr && siz)
  72     {
  73         for (; siz; --siz, ++ptr)
  74         {
  75             val = val * 65599 + *ptr;
  76         }
  77     }
  78     return val;
  79 }
  80
  81 void a_float_push(a_float *block_p, a_size block_n,
  82                   a_float const *cache_p, a_size cache_n)
  83 {
  84     a_size const n = A_MIN(cache_n, block_n);
  85     for (a_size t = block_n, s = block_n - n; s;)
  86     {
  87         block_p[--t] = block_p[--s];
  88     }
  89     for (a_size i = 0; i != n; ++i)
  90     {
  91         block_p[i] = cache_p[i];
  92     }
  93 }
  94
  95 void a_float_roll(a_float *block_p, a_size block_n,
  96                   a_float *shift_p, a_size shift_n)
  97 {
  98     a_size const shift = shift_n % block_n;
  99     a_size const start = block_n - shift;
 100     for (a_size t = 0, s = start; t != shift;)
 101     {
 102         shift_p[t++] = block_p[s++];
 103     }
 104     for (a_size t = block_n, s = start; s;)
 105     {
 106         block_p[--t] = block_p[--s];
 107     }
 108     for (a_size i = 0; i != shift; ++i)
 109     {
 110         block_p[i] = shift_p[i];
 111     }
 112 }
 113
 114 A_ALLOC((*a_alloc), addr, size) = a_alloc_;
 115 A_ALLOC(a_alloc_, addr, size)
 116 {
 117     if (size)
 118     {
 119         if (addr)
 120         {
 121             return realloc(addr, size);
 122         }
 123         return malloc(size);
 124     }
 125     free(addr);
 126     return A_NULL;
 127 }