From b5a3a90c0cce016a0e130010c24eede4ed358046 Mon Sep 17 00:00:00 2001 From: Brian Paul Date: Tue, 5 Mar 2019 10:05:18 -0700 Subject: [PATCH] gallium/util: whitespace cleanups in u_bitmask.[ch] Reviewed-by: Timothy Arceri Reviewed-by: Jose Fonseca --- src/gallium/auxiliary/util/u_bitmask.c | 129 +++++++++++++------------ src/gallium/auxiliary/util/u_bitmask.h | 40 ++++---- 2 files changed, 85 insertions(+), 84 deletions(-) diff --git a/src/gallium/auxiliary/util/u_bitmask.c b/src/gallium/auxiliary/util/u_bitmask.c index b15dfd8d678..397b497d81a 100644 --- a/src/gallium/auxiliary/util/u_bitmask.c +++ b/src/gallium/auxiliary/util/u_bitmask.c @@ -1,8 +1,8 @@ /************************************************************************** - * + * * Copyright 2009 VMware, Inc. * All Rights Reserved. - * + * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including @@ -10,11 +10,11 @@ * distribute, sub license, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: - * + * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial portions * of the Software. - * + * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. @@ -22,13 +22,13 @@ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - * + * **************************************************************************/ /** * @file * Generic bitmask implementation. - * + * * @author Jose Fonseca */ @@ -40,7 +40,7 @@ #include "util/u_bitmask.h" -typedef uint32_t util_bitmask_word; +typedef uint32_t util_bitmask_word; #define UTIL_BITMASK_INITIAL_WORDS 16 @@ -51,10 +51,10 @@ typedef uint32_t util_bitmask_word; struct util_bitmask { util_bitmask_word *words; - + /** Number of bits we can currently hold */ unsigned size; - + /** Number of consecutive bits set at the start of the bitmask */ unsigned filled; }; @@ -64,26 +64,27 @@ struct util_bitmask * util_bitmask_create(void) { struct util_bitmask *bm; - + bm = MALLOC_STRUCT(util_bitmask); if (!bm) return NULL; - - bm->words = (util_bitmask_word *)CALLOC(UTIL_BITMASK_INITIAL_WORDS, sizeof(util_bitmask_word)); - if(!bm->words) { + + bm->words = (util_bitmask_word *) + CALLOC(UTIL_BITMASK_INITIAL_WORDS, sizeof(util_bitmask_word)); + if (!bm->words) { FREE(bm); return NULL; } - + bm->size = UTIL_BITMASK_INITIAL_WORDS * UTIL_BITMASK_BITS_PER_WORD; bm->filled = 0; - + return bm; } /** - * Resize the bitmask if necessary + * Resize the bitmask if necessary */ static inline boolean util_bitmask_resize(struct util_bitmask *bm, @@ -94,36 +95,37 @@ util_bitmask_resize(struct util_bitmask *bm, util_bitmask_word *new_words; /* Check integer overflow */ - if(!minimum_size) + if (!minimum_size) return FALSE; - - if(bm->size >= minimum_size) + + if (bm->size >= minimum_size) return TRUE; assert(bm->size % UTIL_BITMASK_BITS_PER_WORD == 0); new_size = bm->size; - while(new_size < minimum_size) { + while (new_size < minimum_size) { new_size *= 2; /* Check integer overflow */ - if(new_size < bm->size) + if (new_size < bm->size) return FALSE; } assert(new_size); assert(new_size % UTIL_BITMASK_BITS_PER_WORD == 0); - - new_words = (util_bitmask_word *)REALLOC((void *)bm->words, - bm->size / UTIL_BITMASK_BITS_PER_BYTE, - new_size / UTIL_BITMASK_BITS_PER_BYTE); + + new_words = (util_bitmask_word *) + REALLOC((void *)bm->words, + bm->size / UTIL_BITMASK_BITS_PER_BYTE, + new_size / UTIL_BITMASK_BITS_PER_BYTE); if (!new_words) return FALSE; - - memset(new_words + bm->size/UTIL_BITMASK_BITS_PER_WORD, - 0, + + memset(new_words + bm->size/UTIL_BITMASK_BITS_PER_WORD, + 0, (new_size - bm->size)/UTIL_BITMASK_BITS_PER_BYTE); - + bm->size = new_size; bm->words = new_words; - + return TRUE; } @@ -137,8 +139,8 @@ util_bitmask_filled_set(struct util_bitmask *bm, { assert(bm->filled <= bm->size); assert(index < bm->size); - - if(index == bm->filled) { + + if (index == bm->filled) { ++bm->filled; assert(bm->filled <= bm->size); } @@ -150,8 +152,8 @@ util_bitmask_filled_unset(struct util_bitmask *bm, { assert(bm->filled <= bm->size); assert(index < bm->size); - - if(index < bm->filled) + + if (index < bm->filled) bm->filled = index; } @@ -162,16 +164,16 @@ util_bitmask_add(struct util_bitmask *bm) unsigned word; unsigned bit; util_bitmask_word mask; - + assert(bm); /* linear search for an empty index */ word = bm->filled / UTIL_BITMASK_BITS_PER_WORD; bit = bm->filled % UTIL_BITMASK_BITS_PER_WORD; mask = 1 << bit; - while(word < bm->size / UTIL_BITMASK_BITS_PER_WORD) { - while(bit < UTIL_BITMASK_BITS_PER_WORD) { - if(!(bm->words[word] & mask)) + while (word < bm->size / UTIL_BITMASK_BITS_PER_WORD) { + while (bit < UTIL_BITMASK_BITS_PER_WORD) { + if (!(bm->words[word] & mask)) goto found; ++bm->filled; ++bit; @@ -184,7 +186,7 @@ util_bitmask_add(struct util_bitmask *bm) found: /* grow the bitmask if necessary */ - if(!util_bitmask_resize(bm, bm->filled)) + if (!util_bitmask_resize(bm, bm->filled)) return UTIL_BITMASK_INVALID_INDEX; assert(!(bm->words[word] & mask)); @@ -195,17 +197,17 @@ found: unsigned -util_bitmask_set(struct util_bitmask *bm, +util_bitmask_set(struct util_bitmask *bm, unsigned index) { unsigned word; unsigned bit; util_bitmask_word mask; - + assert(bm); - + /* grow the bitmask if necessary */ - if(!util_bitmask_resize(bm, index)) + if (!util_bitmask_resize(bm, index)) return UTIL_BITMASK_INVALID_INDEX; word = index / UTIL_BITMASK_BITS_PER_WORD; @@ -215,22 +217,22 @@ util_bitmask_set(struct util_bitmask *bm, bm->words[word] |= mask; util_bitmask_filled_set(bm, index); - + return index; } void -util_bitmask_clear(struct util_bitmask *bm, +util_bitmask_clear(struct util_bitmask *bm, unsigned index) { unsigned word; unsigned bit; util_bitmask_word mask; - + assert(bm); - - if(index >= bm->size) + + if (index >= bm->size) return; word = index / UTIL_BITMASK_BITS_PER_WORD; @@ -238,30 +240,30 @@ util_bitmask_clear(struct util_bitmask *bm, mask = 1 << bit; bm->words[word] &= ~mask; - + util_bitmask_filled_unset(bm, index); } boolean -util_bitmask_get(struct util_bitmask *bm, +util_bitmask_get(struct util_bitmask *bm, unsigned index) { unsigned word = index / UTIL_BITMASK_BITS_PER_WORD; unsigned bit = index % UTIL_BITMASK_BITS_PER_WORD; util_bitmask_word mask = 1 << bit; - + assert(bm); - - if(index < bm->filled) { + + if (index < bm->filled) { assert(bm->words[word] & mask); return TRUE; } - if(index >= bm->size) + if (index >= bm->size) return FALSE; - if(bm->words[word] & mask) { + if (bm->words[word] & mask) { util_bitmask_filled_set(bm, index); return TRUE; } @@ -271,27 +273,27 @@ util_bitmask_get(struct util_bitmask *bm, unsigned -util_bitmask_get_next_index(struct util_bitmask *bm, +util_bitmask_get_next_index(struct util_bitmask *bm, unsigned index) { unsigned word = index / UTIL_BITMASK_BITS_PER_WORD; unsigned bit = index % UTIL_BITMASK_BITS_PER_WORD; util_bitmask_word mask = 1 << bit; - if(index < bm->filled) { + if (index < bm->filled) { assert(bm->words[word] & mask); return index; } - if(index >= bm->size) { + if (index >= bm->size) { return UTIL_BITMASK_INVALID_INDEX; } /* Do a linear search */ - while(word < bm->size / UTIL_BITMASK_BITS_PER_WORD) { - while(bit < UTIL_BITMASK_BITS_PER_WORD) { - if(bm->words[word] & mask) { - if(index == bm->filled) { + while (word < bm->size / UTIL_BITMASK_BITS_PER_WORD) { + while (bit < UTIL_BITMASK_BITS_PER_WORD) { + if (bm->words[word] & mask) { + if (index == bm->filled) { ++bm->filled; assert(bm->filled <= bm->size); } @@ -305,7 +307,7 @@ util_bitmask_get_next_index(struct util_bitmask *bm, bit = 0; mask = 1; } - + return UTIL_BITMASK_INVALID_INDEX; } @@ -325,4 +327,3 @@ util_bitmask_destroy(struct util_bitmask *bm) FREE(bm); } } - diff --git a/src/gallium/auxiliary/util/u_bitmask.h b/src/gallium/auxiliary/util/u_bitmask.h index 98b85ddecd5..f0769683aa1 100644 --- a/src/gallium/auxiliary/util/u_bitmask.h +++ b/src/gallium/auxiliary/util/u_bitmask.h @@ -1,8 +1,8 @@ /************************************************************************** - * + * * Copyright 2009 VMware, Inc. * All Rights Reserved. - * + * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including @@ -10,11 +10,11 @@ * distribute, sub license, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: - * + * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial portions * of the Software. - * + * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. @@ -22,13 +22,13 @@ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - * + * **************************************************************************/ /** * @file * Generic bitmask. - * + * * @author Jose Fonseca */ @@ -45,8 +45,8 @@ extern "C" { #define UTIL_BITMASK_INVALID_INDEX (~0U) - - + + /** * Abstract data type to represent arbitrary set of bits. */ @@ -59,10 +59,10 @@ util_bitmask_create(void); /** * Search a cleared bit and set it. - * + * * It searches for the first cleared bit. - * - * Returns the bit index on success, or UTIL_BITMASK_INVALID_INDEX on out of + * + * Returns the bit index on success, or UTIL_BITMASK_INVALID_INDEX on out of * memory growing the bitmask. */ unsigned @@ -70,20 +70,20 @@ util_bitmask_add(struct util_bitmask *bm); /** * Set a bit. - * - * Returns the input index on success, or UTIL_BITMASK_INVALID_INDEX on out of + * + * Returns the input index on success, or UTIL_BITMASK_INVALID_INDEX on out of * memory growing the bitmask. */ unsigned -util_bitmask_set(struct util_bitmask *bm, +util_bitmask_set(struct util_bitmask *bm, unsigned index); void -util_bitmask_clear(struct util_bitmask *bm, +util_bitmask_clear(struct util_bitmask *bm, unsigned index); boolean -util_bitmask_get(struct util_bitmask *bm, +util_bitmask_get(struct util_bitmask *bm, unsigned index); @@ -93,8 +93,8 @@ util_bitmask_destroy(struct util_bitmask *bm); /** * Search for the first set bit. - * - * Returns UTIL_BITMASK_INVALID_INDEX if a set bit cannot be found. + * + * Returns UTIL_BITMASK_INVALID_INDEX if a set bit cannot be found. */ unsigned util_bitmask_get_first_index(struct util_bitmask *bm); @@ -102,8 +102,8 @@ util_bitmask_get_first_index(struct util_bitmask *bm); /** * Search for the first set bit, starting from the giving index. - * - * Returns UTIL_BITMASK_INVALID_INDEX if a set bit cannot be found. + * + * Returns UTIL_BITMASK_INVALID_INDEX if a set bit cannot be found. */ unsigned util_bitmask_get_next_index(struct util_bitmask *bm, -- 2.30.2