rename CEIL as DIV_ROUND_UP

[fw/openocd] / src / helper / binarybuffer.c

diff --git a/src/helper/binarybuffer.c b/src/helper/binarybuffer.c
index 0def9485530afd834cf956b71b4efd4926bd05b4..081cc037ebd6c346ae2b360124f81f463914a99c 100644 (file)
--- a/src/helper/binarybuffer.c
+++ b/src/helper/binarybuffer.c
@@ -48,89 +48,94 @@ const unsigned char bit_reverse_table256[] =
 };
 
 
-uint8_t* buf_cpy(const uint8_t *from, uint8_t *to, int size)
+void* buf_cpy(const void *from, void *_to, unsigned size)
 {
-       if (from == NULL)
+       if (NULL == from || NULL == _to)
                return NULL;
 
-       for (unsigned i = 0, num_bytes = CEIL(size, 8); i < num_bytes; i++)
-               to[i] = from[i];
+       // copy entire buffer
+       memcpy(_to, from, DIV_ROUND_UP(size, 8));
 
        /* mask out bits that don't belong to the buffer */
-       if (size % 8)
+       unsigned trailing_bits = size % 8;
+       if (trailing_bits)
        {
-               to[size / 8] &= (0xff >> (8 - (size % 8)));
+               uint8_t *to = _to;
+               to[size / 8] &= (1 << trailing_bits) - 1;
        }
+       return _to;
+}
 
-       return to;
+static bool buf_cmp_masked(uint8_t a, uint8_t b, uint8_t m)
+{
+       return (a & m) != (b & m);
+}
+static bool buf_cmp_trailing(uint8_t a, uint8_t b, uint8_t m, unsigned trailing)
+{
+       uint8_t mask = (1 << trailing) - 1;
+       return buf_cmp_masked(a, b, mask & m);
 }
 
-int buf_cmp(const uint8_t *buf1, const uint8_t *buf2, int size)
+bool buf_cmp(const void *_buf1, const void *_buf2, unsigned size)
 {
-       if (!buf1 || !buf2)
-               return 1;
+       if (!_buf1 || !_buf2)
+               return _buf1 != _buf2;
 
-       for (unsigned i = 0, num_bytes = CEIL(size, 8); i < num_bytes; i++)
-       {
-               /* last byte */
-               /* mask out bits that don't really belong to the buffer if size isn't a multiple of 8 bits */
-               if ((size % 8) && (i == num_bytes -1))
-               {
-                       if ((buf1[i] & ((1 << (size % 8)) - 1)) != (buf2[i] & ((1 << (size % 8)) - 1)))
-                               return 1;
-               }
-               else
-               {
-                       if (buf1[i] != buf2[i])
-                               return 1;
-               }
-       }
+       unsigned last = size / 8;
+       if (memcmp(_buf1, _buf2, last) != 0)
+               return false;
+
+       unsigned trailing = size % 8;
+       if (!trailing)
+               return false;
 
-       return 0;
+       const uint8_t *buf1 = _buf1, *buf2 = _buf2;
+       return buf_cmp_trailing(buf1[last], buf2[last], 0xff, trailing);
 }
 
-int buf_cmp_mask(const uint8_t *buf1, const uint8_t *buf2, const uint8_t *mask, int size)
+bool buf_cmp_mask(const void *_buf1, const void *_buf2,
+               const void *_mask, unsigned size)
 {
-       for (unsigned i = 0, num_bytes = CEIL(size, 8); i < num_bytes; i++)
+       if (!_buf1 || !_buf2)
+               return _buf1 != _buf2 || _buf1 != _mask;
+
+       const uint8_t *buf1 = _buf1, *buf2 = _buf2, *mask = _mask;
+       unsigned last = size / 8;
+       for (unsigned i = 0; i < last; i++)
        {
-               /* last byte */
-               /* mask out bits that don't really belong to the buffer if size isn't a multiple of 8 bits */
-               if ((size % 8) && (i == num_bytes -1))
-               {
-                       if ((buf1[i] & ((1 << (size % 8)) - 1) & mask[i]) !=
-                               (buf2[i] & ((1 << (size % 8)) - 1) & mask[i]))
-                               return 1;
-               }
-               else
-               {
-                       if ((buf1[i] & mask[i]) != (buf2[i] & mask[i]))
-                               return 1;
-               }
+               if (buf_cmp_masked(buf1[i], buf2[i], mask[i]))
+                       return true;
        }
-
-       return 0;
+       unsigned trailing = size % 8;
+       if (!trailing)
+               return false;
+       return buf_cmp_trailing(buf1[last], buf2[last], mask[last], trailing);
 }
 
-uint8_t* buf_set_ones(uint8_t *buf, int count)
+
+void* buf_set_ones(void *_buf, unsigned size)
 {
-       for (unsigned i = 0, num_bytes = CEIL(count, 8); i < num_bytes; i++)
-       {
-               if (count >= 8)
-                       buf[i] = 0xff;
-               else
-                       buf[i] = (1 << count) - 1;
+       uint8_t *buf = _buf;
+       if (!buf)
+               return NULL;
 
-               count -= 8;
-       }
+       memset(buf, 0xff, size / 8);
+
+       unsigned trailing_bits = size % 8;
+       if (trailing_bits)
+               buf[size / 8] = (1 << trailing_bits) - 1;
 
        return buf;
 }
 
-uint8_t* buf_set_buf(const uint8_t *src, int src_start, uint8_t *dst, int dst_start, int len)
+void* buf_set_buf(const void *_src, unsigned src_start,
+               void *_dst, unsigned dst_start, unsigned len)
 {
-       int src_idx = src_start, dst_idx = dst_start;
+       const uint8_t *src = _src;
+       uint8_t *dst = _dst;
 
-       for (int i = 0; i < len; i++)
+       unsigned src_idx = src_start, dst_idx = dst_start;
+       for (unsigned i = 0; i < len; i++)
        {
                if (((src[src_idx / 8] >> (src_idx % 8)) & 1) == 1)
                        dst[dst_idx / 8] |= 1 << (dst_idx % 8);
@@ -186,11 +191,11 @@ char* buf_to_str(const void *_buf, unsigned buf_len, unsigned radix)
                return NULL;
        }
 
-       unsigned str_len = ceil_f_to_u32(CEIL(buf_len, 8) * factor);
+       unsigned str_len = ceil_f_to_u32(DIV_ROUND_UP(buf_len, 8) * factor);
        char *str = calloc(str_len + 1, 1);
 
        const uint8_t *buf = _buf;
-       int b256_len = CEIL(buf_len, 8);
+       int b256_len = DIV_ROUND_UP(buf_len, 8);
        for (int i = b256_len - 1; i >= 0; i--)
        {
                uint32_t tmp = buf[i];
@@ -295,7 +300,7 @@ int str_to_buf(const char *str, unsigned str_len,
        }
 
        uint8_t *buf = _buf;
-       for (unsigned j = 0; j < CEIL(buf_len, 8); j++)
+       for (unsigned j = 0; j < DIV_ROUND_UP(buf_len, 8); j++)
        {
                if (j < b256_len)
                        buf[j] = b256_buf[j];