summaryrefslogtreecommitdiffstats
path: root/src/H5Tbit.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/H5Tbit.c')
-rw-r--r--src/H5Tbit.c395
1 files changed, 184 insertions, 211 deletions
diff --git a/src/H5Tbit.c b/src/H5Tbit.c
index 12d1fd1..df6d2c3 100644
--- a/src/H5Tbit.c
+++ b/src/H5Tbit.c
@@ -11,10 +11,9 @@
* help@hdfgroup.org. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-/*
- * Module Info: Operations on bit vectors. A bit vector is an array of bytes
- * with the least-significant bits in the first byte. That is,
- * the bytes are in little-endian order.
+/* Module Info: Operations on bit vectors. A bit vector is an array of bytes
+ * with the least-significant bits in the first byte. That is,
+ * the bytes are in little-endian order.
*/
#include "H5Tmodule.h" /* This source code file is part of the H5T module */
@@ -29,14 +28,11 @@
/*-------------------------------------------------------------------------
- * Function: H5T__bit_copy
+ * Function: H5T__bit_copy
*
- * Purpose: Copies bits from one vector to another.
+ * Purpose: Copies bits from one vector to another.
*
- * Return: void
- *
- * Programmer: Robb Matzke
- * Wednesday, June 10, 1998
+ * Return: void
*
*-------------------------------------------------------------------------
*/
@@ -50,8 +46,7 @@ H5T__bit_copy(uint8_t *dst, size_t dst_offset, const uint8_t *src,
FUNC_ENTER_PACKAGE_NOERR
- /*
- * Normalize the offset to be a byte number and a bit offset within that
+ /* Normalize the offset to be a byte number and a bit offset within that
* byte.
*/
s_idx = src_offset / 8;
@@ -59,8 +54,7 @@ H5T__bit_copy(uint8_t *dst, size_t dst_offset, const uint8_t *src,
src_offset %= 8;
dst_offset %= 8;
- /*
- * Get things rolling. This means copying bits until we're aligned on a
+ /* Get things rolling. This means copying bits until we're aligned on a
* source byte. This the following example, five bits are copied to the
* destination.
*
@@ -75,30 +69,29 @@ H5T__bit_copy(uint8_t *dst, size_t dst_offset, const uint8_t *src,
* ...+---------------+---------------+
* dst[d_idx+1] dst[d_idx]
*/
- while(src_offset && size > 0) {
- size_t nbits = MIN3(size, 8 - dst_offset, 8 - src_offset);
- size_t mask = ((size_t)1 << nbits) - 1;
-
- dst[d_idx] &= (uint8_t)~(mask << dst_offset);
- dst[d_idx] = (uint8_t)(dst[d_idx] | (((src[s_idx] >> src_offset) & (uint8_t)mask) << dst_offset));
-
- src_offset += nbits;
- if(src_offset >= 8) {
- s_idx++;
- src_offset %= 8;
- } /* end if */
-
- dst_offset += nbits;
- if(dst_offset >= 8) {
- d_idx++;
- dst_offset %= 8;
- } /* end if */
-
- size -= nbits;
- } /* end while */
-
- /*
- * The middle bits. We are aligned on a source byte which needs to be
+ while (src_offset && size > 0) {
+ size_t nbits = MIN3(size, 8 - dst_offset, 8 - src_offset);
+ size_t mask = ((size_t)1 << nbits) - 1;
+
+ dst[d_idx] &= (uint8_t)~(mask << dst_offset);
+ dst[d_idx] = (uint8_t)(dst[d_idx] | (((src[s_idx] >> src_offset) & (uint8_t)mask) << dst_offset));
+
+ src_offset += nbits;
+ if (src_offset >= 8) {
+ s_idx++;
+ src_offset %= 8;
+ }
+
+ dst_offset += nbits;
+ if (dst_offset >= 8) {
+ d_idx++;
+ dst_offset %= 8;
+ }
+
+ size -= nbits;
+ }
+
+ /* The middle bits. We are aligned on a source byte which needs to be
* copied to two (or one in the degenerate case) destination bytes.
*
* src[s_idx]
@@ -122,48 +115,48 @@ H5T__bit_copy(uint8_t *dst, size_t dst_offset, const uint8_t *src,
mask_lo = ((size_t)1 << (8 - shift)) - 1;
mask_hi = (~mask_lo) & 0xff;
- for(/*void*/; size > 8; size -= 8, d_idx++, s_idx++) {
- if(shift) {
- dst[d_idx + 0] &= (uint8_t)(~(mask_lo << shift));
- dst[d_idx + 0] |= (uint8_t)((src[s_idx] & mask_lo) << shift);
- dst[d_idx + 1] &= (uint8_t)(~(mask_hi >> (8 - shift)));
- dst[d_idx + 1] |= (uint8_t)((src[s_idx] & mask_hi) >> (8 - shift));
- } /* end if */
+ for (/*void*/; size > 8; size -= 8, d_idx++, s_idx++) {
+ if (shift) {
+ dst[d_idx + 0] &= (uint8_t)(~(mask_lo << shift));
+ dst[d_idx + 0] |= (uint8_t)((src[s_idx] & mask_lo) << shift);
+ dst[d_idx + 1] &= (uint8_t)(~(mask_hi >> (8 - shift)));
+ dst[d_idx + 1] |= (uint8_t)((src[s_idx] & mask_hi) >> (8 - shift));
+ }
else
- dst[d_idx] = src[s_idx];
- } /* end for */
+ dst[d_idx] = src[s_idx];
+ }
/* Finish up */
- while(size > 0) {
- size_t nbits = (size_t)MIN3 (size, 8 - dst_offset, 8 - src_offset);
- size_t mask = ((size_t)1 << nbits) - 1;
+ while (size > 0) {
+ size_t nbits = (size_t)MIN3 (size, 8 - dst_offset, 8 - src_offset);
+ size_t mask = ((size_t)1 << nbits) - 1;
- dst[d_idx] &= (uint8_t)(~(mask << dst_offset));
- dst[d_idx] = (uint8_t)(dst[d_idx] | (((src[s_idx] >> src_offset) & (uint8_t)mask) << dst_offset));
+ dst[d_idx] &= (uint8_t)(~(mask << dst_offset));
+ dst[d_idx] = (uint8_t)(dst[d_idx] | (((src[s_idx] >> src_offset) & (uint8_t)mask) << dst_offset));
- src_offset += nbits;
- if(src_offset >= 8) {
- s_idx++;
- src_offset %= 8;
- } /* end if */
+ src_offset += nbits;
+ if (src_offset >= 8) {
+ s_idx++;
+ src_offset %= 8;
+ }
- dst_offset += nbits;
- if(dst_offset >= 8) {
- d_idx++;
- dst_offset %= 8;
- } /* end if */
+ dst_offset += nbits;
+ if (dst_offset >= 8) {
+ d_idx++;
+ dst_offset %= 8;
+ }
- size -= nbits;
- } /* end while */
+ size -= nbits;
+ }
FUNC_LEAVE_NOAPI_VOID
} /* end H5T__bit_copy() */
/*-------------------------------------------------------------------------
- * Function: H5T__bit_shift
+ * Function: H5T__bit_shift
*
- * Purpose: Simulation of hardware shifting. Shifts a bit vector
+ * Purpose: Simulation of hardware shifting. Shifts a bit vector
* in a way similar to shifting a variable value, like
* value <<= 3, or value >>= 16. SHIFT_DIST is positive for
* left shift, negative for right shift. The bit vector starts
@@ -173,10 +166,7 @@ H5T__bit_copy(uint8_t *dst, size_t dst_offset, const uint8_t *src,
* For example, if we have a bit sequence 00011100, offset=2,
* size=3, shift_dist=2, the result will be 00010000.
*
- * Return: void
- *
- * Programmer: Raymond Lu
- * Monday, April 12, 2004
+ * Return: void
*
*-------------------------------------------------------------------------
*/
@@ -193,25 +183,25 @@ H5T__bit_shift(uint8_t *buf, ssize_t shift_dist, size_t offset, size_t size)
HDassert(buf);
HDassert(size);
- if(shift_dist) {
+ if (shift_dist) {
size_t abs_shift_dist = (size_t)ABS(shift_dist);
- if(abs_shift_dist >= size)
+ if (abs_shift_dist >= size)
H5T__bit_set(buf, offset, size, 0);
else {
size_t buf_size = (size / 8) + 1; /* Size of shift buffer needed */
uint8_t *shift_buf; /* Pointer to shift buffer */
/* Wrap the local buffer for serialized header info */
- if(NULL == (wb = H5WB_wrap(tmp_buf, sizeof(tmp_buf))))
+ if (NULL == (wb = H5WB_wrap(tmp_buf, sizeof(tmp_buf))))
HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "can't wrap buffer")
/* Get a pointer to a buffer that's large enough */
- if(NULL == (shift_buf = (uint8_t *)H5WB_actual(wb, buf_size)))
+ if (NULL == (shift_buf = (uint8_t *)H5WB_actual(wb, buf_size)))
HGOTO_ERROR(H5E_DATATYPE, H5E_NOSPACE, FAIL, "can't get actual buffer")
/* Shift vector by making copies */
- if(shift_dist > 0) { /* left shift */
+ if (shift_dist > 0) { /* left shift */
/* Copy part to be shifted to a temporary buffer */
H5T__bit_copy(shift_buf, (size_t)0, buf, offset, size - abs_shift_dist);
@@ -220,18 +210,18 @@ H5T__bit_shift(uint8_t *buf, ssize_t shift_dist, size_t offset, size_t size)
/* Zero-set the left part*/
H5T__bit_set(buf, offset, abs_shift_dist, 0);
- } /* end if */
+ }
else { /* right shift */
H5T__bit_copy(shift_buf, (size_t)0, buf, offset + abs_shift_dist, size - abs_shift_dist);
H5T__bit_copy(buf, offset, shift_buf, (size_t)0, size - abs_shift_dist);
H5T__bit_set(buf, offset + size - abs_shift_dist, abs_shift_dist, 0);
- } /* end else */
+ }
} /* end else */
} /* end if */
done:
/* Release resources */
- if(wb && H5WB_unwrap(wb) < 0)
+ if (wb && H5WB_unwrap(wb) < 0)
HDONE_ERROR(H5E_DATATYPE, H5E_CLOSEERROR, FAIL, "can't close wrapped buffer")
FUNC_LEAVE_NOAPI(ret_value)
@@ -239,27 +229,24 @@ done:
/*-------------------------------------------------------------------------
- * Function: H5T__bit_get_d
+ * Function: H5T__bit_get_d
*
- * Purpose: Return a small bit sequence as a number. Bit vector starts
+ * Purpose: Return a small bit sequence as a number. Bit vector starts
* at OFFSET and is SIZE bits long.
*
- * Return: Success: The bit sequence interpretted as an unsigned
- * integer.
- *
- * Failure: 0
+ * Return: Success: The bit sequence interpretted as an unsigned
+ * integer.
*
- * Programmer: Robb Matzke
- * Tuesday, June 23, 1998
+ * Failure: 0
*
*-------------------------------------------------------------------------
*/
uint64_t
H5T__bit_get_d(uint8_t *buf, size_t offset, size_t size)
{
- uint64_t val = 0;
- size_t i, hs;
- uint64_t ret_value = 0; /* Return value */
+ uint64_t val = 0;
+ size_t i, hs;
+ uint64_t ret_value = 0; /* Return value */
FUNC_ENTER_PACKAGE_NOERR
@@ -271,11 +258,11 @@ H5T__bit_get_d(uint8_t *buf, size_t offset, size_t size)
break;
case H5T_ORDER_BE:
- for(i = 0, hs = sizeof(val) / 2; i < hs; i++) {
+ for (i = 0, hs = sizeof(val) / 2; i < hs; i++) {
uint8_t tmp = ((uint8_t*)&val)[i];
((uint8_t*)&val)[i] = ((uint8_t*)&val)[sizeof(val) - (i + 1)];
((uint8_t*)&val)[sizeof(val) - (i + 1)] = tmp;
- } /* end for */
+ }
break;
case H5T_ORDER_ERROR:
@@ -285,7 +272,7 @@ H5T__bit_get_d(uint8_t *buf, size_t offset, size_t size)
default:
/* Unknown endianness. Bail out. */
HGOTO_DONE(UFAIL)
- } /* end switch */
+ }
/* Set return value */
ret_value = val;
@@ -296,14 +283,11 @@ done:
/*-------------------------------------------------------------------------
- * Function: H5T__bit_set_d
+ * Function: H5T__bit_set_d
*
- * Purpose: Sets part of a bit vector to the specified unsigned value.
+ * Purpose: Sets part of a bit vector to the specified unsigned value.
*
- * Return: void
- *
- * Programmer: Robb Matzke
- * Wednesday, June 24, 1998
+ * Return: void
*
*-------------------------------------------------------------------------
*/
@@ -321,11 +305,11 @@ H5T__bit_set_d(uint8_t *buf, size_t offset, size_t size, uint64_t val)
break;
case H5T_ORDER_BE:
- for(i = 0, hs = sizeof(val) / 2; i < hs; i++) {
+ for (i = 0, hs = sizeof(val) / 2; i < hs; i++) {
uint8_t tmp = ((uint8_t *)&val)[i];
((uint8_t *)&val)[i] = ((uint8_t *)&val)[sizeof(val) - (i + 1)];
((uint8_t *)&val)[sizeof(val) - (i + 1)] = tmp;
- } /* end for */
+ }
break;
case H5T_ORDER_ERROR:
@@ -334,7 +318,7 @@ H5T__bit_set_d(uint8_t *buf, size_t offset, size_t size, uint64_t val)
case H5T_ORDER_MIXED:
default:
HDabort();
- } /* end switch */
+ }
H5T__bit_copy(buf, offset, (uint8_t*)&val, (size_t)0, size);
@@ -343,24 +327,19 @@ H5T__bit_set_d(uint8_t *buf, size_t offset, size_t size, uint64_t val)
/*-------------------------------------------------------------------------
- * Function: H5T__bit_set
+ * Function: H5T__bit_set
*
- * Purpose: Sets or clears bits in a contiguous region of a vector
- * beginning at bit OFFSET and continuing for SIZE bits.
+ * Purpose: Sets or clears bits in a contiguous region of a vector
+ * beginning at bit OFFSET and continuing for SIZE bits.
*
- * Return: void
- *
- * Programmer: Robb Matzke
- * Wednesday, June 10, 1998
- *
- * Modifications:
+ * Return: void
*
*-------------------------------------------------------------------------
*/
void
H5T__bit_set(uint8_t *buf, size_t offset, size_t size, hbool_t value)
{
- int idx;
+ int idx;
FUNC_ENTER_PACKAGE_NOERR
@@ -369,54 +348,51 @@ H5T__bit_set(uint8_t *buf, size_t offset, size_t size, hbool_t value)
offset %= 8;
/* The first partial byte */
- if(size && offset % 8) {
- size_t nbits = MIN(size, 8 - offset);
- unsigned mask = ((unsigned)1 << nbits) - 1;
+ if (size && offset % 8) {
+ size_t nbits = MIN(size, 8 - offset);
+ unsigned mask = ((unsigned)1 << nbits) - 1;
- if(value)
- buf[idx] = (uint8_t)(buf[idx] | (mask << offset));
- else
- buf[idx] &= (uint8_t)(~(mask << offset));
+ if (value)
+ buf[idx] = (uint8_t)(buf[idx] | (mask << offset));
+ else
+ buf[idx] &= (uint8_t)(~(mask << offset));
- idx++;
- size -= nbits;
- } /* end if */
+ idx++;
+ size -= nbits;
+ }
/* The middle bytes */
- while(size >= 8) {
- buf[idx++] = value ? 0xff : 0x00;
- size -= 8;
- } /* end while */
+ while (size >= 8) {
+ buf[idx++] = value ? 0xff : 0x00;
+ size -= 8;
+ }
/* The last partial byte */
- if(size) {
- if(value)
- buf[idx] |= (uint8_t)(((unsigned)1 << size) - 1);
- else
- buf[idx] &= (uint8_t)(~(((unsigned)1 << size) - 1));
- } /* end if */
+ if (size) {
+ if (value)
+ buf[idx] |= (uint8_t)(((unsigned)1 << size) - 1);
+ else
+ buf[idx] &= (uint8_t)(~(((unsigned)1 << size) - 1));
+ }
FUNC_LEAVE_NOAPI_VOID
} /* end H5T__bit_set() */
/*-------------------------------------------------------------------------
- * Function: H5T__bit_find
+ * Function: H5T__bit_find
*
- * Purpose: Finds the first bit with the specified VALUE within a region
- * of a bit vector. The region begins at OFFSET and continues
- * for SIZE bits, but the region can be searched from the least
- * significat end toward the most significant end(H5T_BIT_LSB
- * as DIRECTION), or from the most significant end to the least
- * significant end(H5T_BIT_MSB as DIRECTION).
+ * Purpose: Finds the first bit with the specified VALUE within a region
+ * of a bit vector. The region begins at OFFSET and continues
+ * for SIZE bits, but the region can be searched from the least
+ * significat end toward the most significant end(H5T_BIT_LSB
+ * as DIRECTION), or from the most significant end to the least
+ * significant end(H5T_BIT_MSB as DIRECTION).
*
- * Return: Success: The position of the bit found, relative to
- * the offset.
+ * Return: Success: The position of the bit found, relative to
+ * the offset.
*
- * Failure: -1
- *
- * Programmer: Robb Matzke
- * Wednesday, June 10, 1998
+ * Failure: -1
*
*-------------------------------------------------------------------------
*/
@@ -424,9 +400,9 @@ ssize_t
H5T__bit_find(uint8_t *buf, size_t offset, size_t size, H5T_sdir_t direction,
hbool_t value)
{
- ssize_t base = (ssize_t)offset;
- ssize_t idx, i;
- size_t iu;
+ ssize_t base = (ssize_t)offset;
+ ssize_t idx, i;
+ size_t iu;
ssize_t ret_value = (-1); /* Return value */
/* Use FUNC_ENTER_PACKAGE_NOERR here to avoid performance issues */
@@ -435,16 +411,16 @@ H5T__bit_find(uint8_t *buf, size_t offset, size_t size, H5T_sdir_t direction,
/* Some functions call this with value=TRUE */
HDassert(TRUE == 1);
- switch(direction) {
+ switch (direction) {
case H5T_BIT_LSB:
/* Calculate index */
idx = (ssize_t)(offset / 8);
offset %= 8;
/* Beginning */
- if(offset) {
- for(iu = offset; iu < 8 && size > 0; iu++, size--)
- if(value == (hbool_t)((buf[idx] >> iu) & 0x01))
+ if (offset) {
+ for (iu = offset; iu < 8 && size > 0; iu++, size--)
+ if (value == (hbool_t)((buf[idx] >> iu) & 0x01))
HGOTO_DONE(8 * idx + (ssize_t)iu - base);
offset = 0;
@@ -452,10 +428,10 @@ H5T__bit_find(uint8_t *buf, size_t offset, size_t size, H5T_sdir_t direction,
} /* end if */
/* Middle */
- while(size >= 8) {
- if((value ? 0x00 : 0xff) != buf[idx])
- for(i = 0; i < 8; i++)
- if(value == (hbool_t)((buf[idx] >> i) & 0x01))
+ while (size >= 8) {
+ if ((value ? 0x00 : 0xff) != buf[idx])
+ for (i = 0; i < 8; i++)
+ if (value == (hbool_t)((buf[idx] >> i) & 0x01))
HGOTO_DONE(8 * idx + i - base);
size -= 8;
@@ -463,8 +439,8 @@ H5T__bit_find(uint8_t *buf, size_t offset, size_t size, H5T_sdir_t direction,
} /* end while */
/* End */
- for(i = 0; i < (ssize_t)size; i++)
- if(value == (hbool_t)((buf[idx] >> i) & 0x01))
+ for (i = 0; i < (ssize_t)size; i++)
+ if (value == (hbool_t)((buf[idx] >> i) & 0x01))
HGOTO_DONE(8 * idx + i - base);
break;
@@ -474,19 +450,19 @@ H5T__bit_find(uint8_t *buf, size_t offset, size_t size, H5T_sdir_t direction,
offset %= 8;
/* Beginning */
- if(size > 8 - offset && (offset + size) % 8) {
- for(iu = (offset + size) % 8; iu > 0; --iu, --size)
- if(value == (hbool_t)((buf[idx] >> (iu - 1)) & 0x01))
+ if (size > 8 - offset && (offset + size) % 8) {
+ for (iu = (offset + size) % 8; iu > 0; --iu, --size)
+ if (value == (hbool_t)((buf[idx] >> (iu - 1)) & 0x01))
HGOTO_DONE(8 * idx + (ssize_t)(iu - 1) - base);
--idx;
} /* end if */
/* Middle */
- while(size >= 8) {
- if((value ? 0x00 : 0xff) != buf[idx]) {
- for(i = 7; i >= 0; --i)
- if(value == (hbool_t)((buf[idx] >> i) & 0x01))
+ while (size >= 8) {
+ if ((value ? 0x00 : 0xff) != buf[idx]) {
+ for (i = 7; i >= 0; --i)
+ if (value == (hbool_t)((buf[idx] >> i) & 0x01))
HGOTO_DONE(8 * idx + i - base);
} /* end if */
@@ -495,11 +471,11 @@ H5T__bit_find(uint8_t *buf, size_t offset, size_t size, H5T_sdir_t direction,
} /* end while */
/* End */
- if(size > 0) {
- for(iu = offset + size; iu > offset; --iu)
- if(value == (hbool_t)((buf[idx] >> (iu - 1)) & 0x01))
+ if (size > 0) {
+ for (iu = offset + size; iu > offset; --iu)
+ if (value == (hbool_t)((buf[idx] >> (iu - 1)) & 0x01))
HGOTO_DONE(8 * idx + (ssize_t)(iu - 1) - base);
- } /* end if */
+ }
break;
default:
@@ -519,17 +495,14 @@ done:
*
* Return: The carry-out value. TRUE if overflows, FALSE otherwise.
*
- * Programmer: Robb Matzke
- * Friday, June 26, 1998
- *
*-------------------------------------------------------------------------
*/
hbool_t
H5T__bit_inc(uint8_t *buf, size_t start, size_t size)
{
- size_t idx = start / 8;
- unsigned carry = 1;
- unsigned acc, mask;
+ size_t idx = start / 8;
+ unsigned carry = 1;
+ unsigned acc, mask;
/* Use FUNC_ENTER_PACKAGE_NOERR here to avoid performance issues */
FUNC_ENTER_PACKAGE_NOERR
@@ -539,7 +512,7 @@ H5T__bit_inc(uint8_t *buf, size_t start, size_t size)
start %= 8;
/* The first partial byte */
- if(start) {
+ if (start) {
if(size + start < 8)
mask = ((unsigned)1 << size) - 1;
else
@@ -552,34 +525,34 @@ H5T__bit_inc(uint8_t *buf, size_t start, size_t size)
size -= MIN(size, 8 - start);
start = 0;
idx++;
- } /* end if */
+ }
/* The middle */
- while(carry && size >= 8) {
+ while (carry && size >= 8) {
acc = buf[idx];
acc++;
carry = acc & 0x100;
buf[idx] = acc & 0xff;
idx++;
size -= 8;
- } /* end while */
+ }
/* The last bits */
- if(carry && size > 0) {
+ if (carry && size > 0) {
mask = ((unsigned)1 << size) - 1;
acc = buf[idx] & mask;
acc++;
carry = acc & ((unsigned)1 << size);
buf[idx] &= (uint8_t)(~mask);
buf[idx] |= (uint8_t)(acc & mask);
- } /* end if */
+ }
FUNC_LEAVE_NOAPI(carry ? TRUE : FALSE)
} /* end H5T__bit_inc() */
/*-------------------------------------------------------------------------
- * Function: H5T__bit_dec
+ * Function: H5T__bit_dec
*
* Purpose: Decrement part of a bit field by substracting 1. The bit
* field starts with bit position START and is SIZE bits long.
@@ -587,18 +560,15 @@ H5T__bit_inc(uint8_t *buf, size_t start, size_t size)
* Return: The "borrow-in" value. It's TRUE if underflows, FALSE
* otherwise.
*
- * Programmer: Raymond Lu
- * March 17, 2004
- *
*-------------------------------------------------------------------------
*/
hbool_t
H5T__bit_dec(uint8_t *buf, size_t start, size_t size)
{
- size_t idx = start / 8;
+ size_t idx = start / 8;
size_t pos = start % 8;
uint8_t tmp;
- unsigned borrow = 0;
+ unsigned borrow = 0;
/* Use FUNC_ENTER_PACKAGE_NOERR here to avoid performance issues */
FUNC_ENTER_PACKAGE_NOERR
@@ -607,71 +577,72 @@ H5T__bit_dec(uint8_t *buf, size_t start, size_t size)
HDassert(size);
/* The first partial byte */
- if((size + start - 1) / 8 > idx) { /*bit sequence doesn't end in the same byte as starts*/
+ if ((size + start - 1) / 8 > idx) {
+ /* The bit sequence doesn't end in the same byte as starts */
+
/* Example: a sequence like 11000100 and start = 3. We substract 00001000 from
* it and get 10111100. If a sequence is 00000111, we do right shift for START
* bits and get 00000000. So we need to borrow from higher byte when we substract
* 00001000.
*/
- if(!(buf[idx] >> pos))
+ if (!(buf[idx] >> pos))
borrow = 1;
buf[idx] = (uint8_t)(buf[idx] - (1 << pos));
idx++;
size -= (8 - pos);
/* The middle bytes */
- while(borrow && size >= 8) {
- if(buf[idx])
+ while (borrow && size >= 8) {
+ if (buf[idx])
borrow = 0;
buf[idx]--;
idx++;
size -= 8;
- } /* end while */
+ }
/* The last partial byte */
- if(borrow && size > 0) {
+ if (borrow && size > 0) {
/* Similar to the first byte case, where sequence ends in the same byte as starts */
tmp = buf[idx];
buf[idx]--;
- if((buf[idx] >> size) != tmp >> size)
+ if ((buf[idx] >> size) != tmp >> size)
buf[idx] = (uint8_t)(buf[idx] + (1 << size));
- } /* end if */
- } /* end if */
- else { /* bit sequence ends in the same byte as starts */
+ }
+ }
+ else {
+ /* The bit sequence ends in the same byte as starts */
+
/* Example: a sequence like 11000100 and pos=3, size=3. We substract 00001000
* and get 10111100. A bit is borrowed from 6th bit(buf[idx]>>6=00000010, tmp>>6=00000011,
* not equal). We need to put this bit back by increment 1000000.
*/
tmp = buf[idx];
buf[idx] = (uint8_t)(buf[idx] - (1 << pos));
- if((buf[idx] >> (pos + size)) != tmp >> (pos + size)) {
+ if ((buf[idx] >> (pos + size)) != tmp >> (pos + size)) {
buf[idx] = (uint8_t)(buf[idx] + (1 << (pos + size)));
borrow = 1;
- } /* end if */
- } /* end else */
+ }
+ }
FUNC_LEAVE_NOAPI(borrow ? TRUE : FALSE)
} /* end H5T__bit_dec() */
/*-------------------------------------------------------------------------
- * Function: H5T__bit_neg
- *
- * Purpose: negate part of a bit sequence. The bit
- * field starts with bit position START and is SIZE bits long.
+ * Function: H5T__bit_neg
*
- * Return: void
+ * Purpose: Negate part of a bit sequence. The bit field starts with
+ * bit position START and is SIZE bits long.
*
- * Programmer: Raymond Lu
- * March 19, 2004
+ * Return: void
*
*-------------------------------------------------------------------------
*/
void
H5T__bit_neg(uint8_t *buf, size_t start, size_t size)
{
- size_t idx = start / 8;
+ size_t idx = start / 8;
size_t pos = start % 8;
uint8_t tmp[1];
@@ -695,17 +666,19 @@ H5T__bit_neg(uint8_t *buf, size_t start, size_t size)
buf[idx] = (uint8_t)~(buf[idx]);
idx++;
size -= 8;
- } /* end while */
+ }
/* The last partial byte */
if(size > 0) {
/* Similar to the first byte case, where sequence ends in the same byte as starts */
tmp[0] = (uint8_t)~buf[idx];
H5T__bit_copy(&(buf[idx]), (size_t)0, tmp, (size_t)0, size);
- } /* end if */
- } /* end if */
- else /* bit sequence ends in the same byte as starts */
+ }
+ }
+ else {
+ /* bit sequence ends in the same byte as starts */
H5T__bit_copy(&(buf[idx]), pos, tmp, pos, size);
+ }
FUNC_LEAVE_NOAPI_VOID
} /* end H5T__bit_neg() */