binarybuffer: fix whitespace related issues

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

diff --git a/src/helper/binarybuffer.c b/src/helper/binarybuffer.c
index 405e1011dd686df3220b99b7d7c747fb3abc1b4b..d813ecf537e551c794abd8ed73a97ae85fbbb0df 100644 (file)
--- a/src/helper/binarybuffer.c
+++ b/src/helper/binarybuffer.c
@@ -2,7 +2,7 @@
  *   Copyright (C) 2004, 2005 by Dominic Rath                              *
  *   Dominic.Rath@gmx.de                                                   *
  *                                                                         *
- *   Copyright (C) 2007,2008 Øyvind Harboe                                 *
+ *   Copyright (C) 2007,2008 Øyvind Harboe                                 *
  *   oyvind.harboe@zylin.com                                               *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -24,12 +24,7 @@
 #include "config.h"
 #endif
 
-#include <stdlib.h>
-#include <string.h>
-
-#include "types.h"
 #include "log.h"
-
 #include "binarybuffer.h"
 
 const unsigned char bit_reverse_table256[] =
@@ -53,7 +48,7 @@ const unsigned char bit_reverse_table256[] =
 };
 
 
-u8* buf_cpy(u8 *from, u8 *to, int size)
+uint8_t* buf_cpy(const uint8_t *from, uint8_t *to, int size)
 {
        unsigned int num_bytes = CEIL(size, 8);
        unsigned int i;
@@ -73,7 +68,7 @@ u8* buf_cpy(u8 *from, u8 *to, int size)
        return to;
 }
 
-int buf_cmp(u8 *buf1, u8 *buf2, int size)
+int buf_cmp(const uint8_t *buf1, const uint8_t *buf2, int size)
 {
        int num_bytes = CEIL(size, 8);
        int i;
@@ -85,7 +80,7 @@ int buf_cmp(u8 *buf1, u8 *buf2, int size)
        {
                /* 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 ((size % 8) && (i == num_bytes -1))
                {
                        if ((buf1[i] & ((1 << (size % 8)) - 1)) != (buf2[i] & ((1 << (size % 8)) - 1)))
                                return 1;
@@ -100,7 +95,7 @@ int buf_cmp(u8 *buf1, u8 *buf2, int size)
        return 0;
 }
 
-int buf_cmp_mask(u8 *buf1, u8 *buf2, u8 *mask, int size)
+int buf_cmp_mask(const uint8_t *buf1, const uint8_t *buf2, const uint8_t *mask, int size)
 {
        int num_bytes = CEIL(size, 8);
        int i;
@@ -109,7 +104,7 @@ int buf_cmp_mask(u8 *buf1, u8 *buf2, u8 *mask, int size)
        {
                /* 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 ((size % 8) && (i == num_bytes -1))
                {
                        if ((buf1[i] & ((1 << (size % 8)) - 1) & mask[i]) !=
                                (buf2[i] & ((1 << (size % 8)) - 1) & mask[i]))
@@ -125,7 +120,7 @@ int buf_cmp_mask(u8 *buf1, u8 *buf2, u8 *mask, int size)
        return 0;
 }
 
-u8* buf_set_ones(u8 *buf, int count)
+uint8_t* buf_set_ones(uint8_t *buf, int count)
 {
        int num_bytes = CEIL(count, 8);
        int i;
@@ -143,17 +138,17 @@ u8* buf_set_ones(u8 *buf, int count)
        return buf;
 }
 
-u8* buf_set_buf(u8 *src, int src_start, u8 *dst, int dst_start, int len)
+uint8_t* buf_set_buf(const uint8_t *src, int src_start, uint8_t *dst, int dst_start, int len)
 {
        int src_idx = src_start, dst_idx = dst_start;
        int i;
 
        for (i = 0; i < len; i++)
        {
-               if (((src[src_idx/8] >> (src_idx % 8)) & 1) == 1)
-                       dst[dst_idx/8] |= 1 << (dst_idx%8);
+               if (((src[src_idx / 8] >> (src_idx % 8)) & 1) == 1)
+                       dst[dst_idx / 8] |= 1 << (dst_idx % 8);
                else
-                       dst[dst_idx/8] &= ~(1 << (dst_idx%8));
+                       dst[dst_idx / 8] &= ~(1 << (dst_idx % 8));
                dst_idx++;
                src_idx++;
        }
@@ -161,9 +156,9 @@ u8* buf_set_buf(u8 *src, int src_start, u8 *dst, int dst_start, int len)
        return dst;
 }
 
-u32 flip_u32(u32 value, unsigned int num)
+uint32_t flip_u32(uint32_t value, unsigned int num)
 {
-       u32 c;
+       uint32_t c;
 
        c = (bit_reverse_table256[value & 0xff] << 24) |
                (bit_reverse_table256[(value >> 8) & 0xff] << 16) |
@@ -178,7 +173,7 @@ u32 flip_u32(u32 value, unsigned int num)
 
 int ceil_f_to_u32(float x)
 {
-       u32 y;
+       uint32_t y;
 
        if (x < 0)      /* return zero for negative numbers */
                return 0;
@@ -191,14 +186,14 @@ int ceil_f_to_u32(float x)
        return y;
 }
 
-char* buf_to_str(const u8 *buf, int buf_len, int radix)
+char* buf_to_str(const uint8_t *buf, int buf_len, int radix)
 {
        const char *DIGITS = "0123456789ABCDEF";
        float factor;
        char *str;
        int str_len;
        int b256_len = CEIL(buf_len, 8);
-       u32 tmp;
+       uint32_t tmp;
 
        int j; /* base-256 digits */
        int i; /* output digits (radix) */
@@ -229,8 +224,8 @@ char* buf_to_str(const u8 *buf, int buf_len, int radix)
 
                for (j = str_len; j > 0; j--)
                {
-                       tmp += (u32)str[j-1] * 256;
-                       str[j-1] = (u8)(tmp % radix);
+                       tmp += (uint32_t)str[j-1] * 256;
+                       str[j-1] = (uint8_t)(tmp % radix);
                        tmp /= radix;
                }
        }
@@ -241,12 +236,12 @@ char* buf_to_str(const u8 *buf, int buf_len, int radix)
        return str;
 }
 
-int str_to_buf(const char *str, int str_len, u8 *buf, int buf_len, int radix)
+int str_to_buf(const char *str, int str_len, uint8_t *buf, int buf_len, int radix)
 {
        char *charbuf;
-       u32 tmp;
+       uint32_t tmp;
        float factor;
-       u8 *b256_buf;
+       uint8_t *b256_buf;
        int b256_len;
 
        int j; /* base-256 digits */
@@ -303,13 +298,13 @@ int str_to_buf(const char *str, int str_len, u8 *buf, int buf_len, int radix)
                        tmp = (tmp - 'A' + 10);
                else continue;  /* skip characters other than [0-9,a-f,A-F] */
 
-               if (tmp >= (u32)radix)
+               if (tmp >= (uint32_t)radix)
                        continue;       /* skip digits invalid for the current radix */
 
                for (j = 0; j < b256_len; j++)
                {
-                       tmp += (u32)b256_buf[j] * radix;
-                       b256_buf[j] = (u8)(tmp & 0xFF);
+                       tmp += (uint32_t)b256_buf[j] * radix;
+                       b256_buf[j] = (uint8_t)(tmp & 0xFF);
                        tmp >>= 8;
                }
 
@@ -332,12 +327,3 @@ int str_to_buf(const char *str, int str_len, u8 *buf, int buf_len, int radix)
 
        return i;
 }
-
-int buf_to_u32_handler(u8 *in_buf, void *priv, struct scan_field_s *field)
-{
-       u32 *dest = priv;
-
-       *dest = buf_get_u32(in_buf, 0, 32);
-
-       return ERROR_OK;
-}