struct tally *tally;
/* There is always 1 bucket. */
- if (buckets == 0)
+ if (buckets == 0) {
buckets = 1;
+ }
/* Overly cautious check for overflow. */
- if (sizeof(*tally) * buckets / sizeof(*tally) != buckets)
+ if (sizeof(*tally) * buckets / sizeof(*tally) != buckets) {
return NULL;
+ }
+
tally = (struct tally *)malloc(
sizeof(*tally) + sizeof(tally->counts[0])*(buckets-1));
if (tally == NULL) {
static unsigned bucket_of(ssize_t min, unsigned step_bits, ssize_t val)
{
/* Don't over-shift. */
- if (step_bits == SIZET_BITS)
+ if (step_bits == SIZET_BITS) {
return 0;
+ }
assert(step_bits < SIZET_BITS);
return (size_t)(val - min) >> step_bits;
}
static ssize_t bucket_min(ssize_t min, unsigned step_bits, unsigned b)
{
/* Don't over-shift. */
- if (step_bits == SIZET_BITS)
+ if (step_bits == SIZET_BITS) {
return min;
+ }
assert(step_bits < SIZET_BITS);
return min + ((ssize_t)b << step_bits);
}
/* Does shifting by this many bits truncate the number? */
static bool shift_overflows(size_t num, unsigned bits)
{
- if (bits == 0)
+ if (bits == 0) {
return false;
+ }
return ((num << bits) >> 1) != (num << (bits - 1));
}
unsigned int i, old_min;
/* Uninitialized? Don't do anything... */
- if (tally->max < tally->min)
+ if (tally->max < tally->min) {
goto update;
+ }
/* If we don't have sufficient range, increase step bits until
* buckets cover entire range of ssize_t anyway. */