Address clang-tidy feedback on readability and brace use

Author: phillipjohnston

Diff for: src/aligned_malloc.c

@@ -52,18 +52,18 @@ void* aligned_malloc(size_t align, size_t size)
 		 * We also allocate extra bytes to ensure we can meet the alignment
 		 */
 		size_t hdr_size = PTR_OFFSET_SZ + (align - 1);
-		void* p = malloc(size + hdr_size);
+		void* base_ptr = malloc(size + hdr_size);
 
-		if(p)
+		if(base_ptr)
 		{
 			/*
 			 * Add the offset size to malloc's pointer (we will always store that)
 			 * Then align the resulting value to the target alignment
 			 */
-			ptr = (void*)align_up(((uintptr_t)p + PTR_OFFSET_SZ), align);
+			ptr = (void*)align_up(((uintptr_t)base_ptr + PTR_OFFSET_SZ), align);
 
 			// Calculate the offset and store it behind our aligned pointer
-			*((offset_t*)ptr - 1) = (offset_t)((uintptr_t)ptr - (uintptr_t)p);
+			*((offset_t*)ptr - 1) = (offset_t)((uintptr_t)ptr - (uintptr_t)base_ptr);
 
 		} // else NULL, could not malloc
 	} // else NULL, invalid arguments
@@ -97,6 +97,6 @@ void aligned_free(void* ptr)
 	/*
 	 * Once we have the offset, we can get our original pointer and call free
 	 */
-	void* p = (void*)((uint8_t*)ptr - offset);
-	free(p);
+	void* base_ptr = (void*)((uint8_t*)ptr - offset);
+	free(base_ptr);
 }

Diff for: src/malloc_freertos.c

@@ -51,14 +51,14 @@ static volatile bool initialized_ = false;
 
 #pragma mark - Private Functions -
 
-static int cmp_heap(const void* a, const void* b)
+static int cmp_heap(const void* region_a, const void* region_b)
 {
-	const HeapRegion_t* ua = a;
-	const HeapRegion_t* ub = b;
+	const HeapRegion_t* heapregion_a = region_a;
+	const HeapRegion_t* heapregion_b = region_b;
 
-	return ((ua->pucStartAddress < ub->pucStartAddress)
+	return ((heapregion_a->pucStartAddress < heapregion_b->pucStartAddress)
 				? -1
-				: ((ua->pucStartAddress != ub->pucStartAddress)));
+				: ((heapregion_a->pucStartAddress != heapregion_b->pucStartAddress)));
 }
 
 /**

Diff for: src/malloc_threadx.c

@@ -41,8 +41,8 @@ void malloc_addblock(void* addr, size_t size)
 	 * tx_byte_pool_create is ThreadX's API to create a byte pool using a memory block.
 	 * We are essentially just wrapping ThreadX APIs into a simpler form
 	 */
-	unsigned r = tx_byte_pool_create(&malloc_pool_, "Heap Memory Pool", addr, size);
-	assert(r == TX_SUCCESS);
+	unsigned return_code = tx_byte_pool_create(&malloc_pool_, "Heap Memory Pool", addr, size);
+	assert(return_code == TX_SUCCESS);
 
 	// Signal to any threads waiting on do_malloc that we are done
 	initialized_ = true;
@@ -65,10 +65,10 @@ void* malloc(size_t size)
 	if(size > 0)
 	{
 		// We simply wrap the threadX call into a standard form
-		unsigned r = tx_byte_allocate(&malloc_pool_, &ptr, size, TX_WAIT_FOREVER);
+		unsigned return_code = tx_byte_allocate(&malloc_pool_, &ptr, size, TX_WAIT_FOREVER);
 
 		// I add the string to provide a more helpful error output.  It's value is always true.
-		assert(r == TX_SUCCESS && "malloc failed");
+		assert(return_code == TX_SUCCESS && "malloc failed");
 	} // else NULL if there was an error
 
 	return ptr;
@@ -82,7 +82,7 @@ void free(void* ptr)
 	if(ptr)
 	{
 		// We simply wrap the threadX call into a standard form
-		unsigned r = tx_byte_release(ptr);
-		assert(r == TX_SUCCESS);
+		unsigned return_code = tx_byte_release(ptr);
+		assert(return_code == TX_SUCCESS);
 	}
 }

Diff for: src/posix_memalign.c

@@ -7,25 +7,25 @@
 
 int posix_memalign(void** __memptr, size_t __alignment, size_t __size)
 {
-	int r = ENOMEM;
+	int return_code = ENOMEM;
 
 	assert(__memptr);
 	assert(__size > 0);
 
 	// TODO: Do we need to check if __alignment is a multiple of sizeof(void *)?
 	if(!IS_POWER_2(__alignment))
 	{
-		r = EINVAL;
+		return_code = EINVAL;
 	}
 	else
 	{
 		*__memptr = aligned_malloc(__alignment, __size);
 
 		if(*__memptr != NULL)
 		{
-			r = 0;
+			return_code = 0;
 		}
 	}
 
-	return r;
+	return return_code;
 }

Diff for: test/src/aligned_malloc.c

@@ -71,16 +71,16 @@ static void aligned_malloc_test(void** __attribute__((unused)) state)
 __attribute__((unused)) static void posix_memalign_test(void** __attribute__((unused)) state)
 {
 	void* ptr = NULL;
-	int r = posix_memalign(&ptr, 8, 8);
+	int return_code = posix_memalign(&ptr, 8, 8);
 	assert_non_null(ptr);
-	assert_int_equal(r, 0);
+	assert_int_equal(return_code, 0);
 
 	aligned_free(ptr);
 	ptr = NULL;
 
-	r = posix_memalign(&ptr, 3, 8);
+	return_code = posix_memalign(&ptr, 3, 8);
 	assert_null(ptr);
-	assert_int_equal(r, EINVAL);
+	assert_int_equal(return_code, EINVAL);
 }
 
 int aligned_malloc_tests(void)

Diff for: test/src/malloc_freelist.c

@@ -18,7 +18,7 @@
 
 #define ALLOCATION_TEST_COUNT 768
 
-static void* p[ALLOCATION_TEST_COUNT];
+static void* pointer_array[ALLOCATION_TEST_COUNT];
 
 static void malloc_test(void** __attribute__((unused)) state)
 {
@@ -47,34 +47,38 @@ static void malloc_test(void** __attribute__((unused)) state)
 
 	for(size_t i = 0; i < ALLOCATION_TEST_COUNT; i++)
 	{
-		p[i] = malloc(1024);
-		assert_non_null(p[i]);
-		assert_in_range((uintptr_t)p[i], mem_block_addr, mem_block_end_addr);
+		pointer_array[i] = malloc(1024);
+		assert_non_null(pointer_array[i]);
+		assert_in_range((uintptr_t)pointer_array[i], mem_block_addr, mem_block_end_addr);
 		// Test for unique addresses
 		if(i > 0)
-			assert_not_in_set((uintptr_t)p[i], (uintptr_t*)p, i - 1);
+		{
+			assert_not_in_set((uintptr_t)pointer_array[i], (uintptr_t*)pointer_array, i - 1);
+		}
 	}
 
 	// Cleanup
 	for(size_t i = 0; i < ALLOCATION_TEST_COUNT; i++)
 	{
-		free(p[i]);
+		free(pointer_array[i]);
 	}
 
 	// Run test again, will not fail if our memory has been returned!
 	for(size_t i = 0; i < ALLOCATION_TEST_COUNT; i++)
 	{
-		p[i] = malloc(1024);
-		assert_non_null(p[i]);
-		assert_in_range((uintptr_t)p[i], mem_block_addr, mem_block_end_addr);
+		pointer_array[i] = malloc(1024);
+		assert_non_null(pointer_array[i]);
+		assert_in_range((uintptr_t)pointer_array[i], mem_block_addr, mem_block_end_addr);
 		if(i > 0)
-			assert_not_in_set((uintptr_t)p[i], (uintptr_t*)p, i - 1);
+		{
+			assert_not_in_set((uintptr_t)pointer_array[i], (uintptr_t*)pointer_array, i - 1);
+		}
 	}
 
 	// Cleanup
 	for(size_t i = 0; i < ALLOCATION_TEST_COUNT; i++)
 	{
-		free(p[i]);
+		free(pointer_array[i]);
 	}
 }
 

Diff for: test/src/malloc_freelist_locking.c

@@ -18,7 +18,7 @@
 
 #define ALLOCATION_TEST_COUNT 768
 
-static void* p[ALLOCATION_TEST_COUNT];
+static void* ptr_array[ALLOCATION_TEST_COUNT];
 
 bool malloc_lock_called = false;
 bool malloc_unlock_called = false;
@@ -67,29 +67,29 @@ static void malloc_locking_test(void** __attribute__((unused)) state)
 
 	for(int i = 0; i < ALLOCATION_TEST_COUNT; i++)
 	{
-		p[i] = malloc(1024);
-		assert_non_null(p[i]);
-		assert_in_range((uintptr_t)p[i], mem_block_addr, mem_block_end_addr);
+		ptr_array[i] = malloc(1024);
+		assert_non_null(ptr_array[i]);
+		assert_in_range((uintptr_t)ptr_array[i], mem_block_addr, mem_block_end_addr);
 	}
 
 	// Cleanup
 	for(int i = 0; i < ALLOCATION_TEST_COUNT; i++)
 	{
-		free(p[i]);
+		free(ptr_array[i]);
 	}
 
 	// Run test again, will not fail if our memory has been returned!
 	for(int i = 0; i < ALLOCATION_TEST_COUNT; i++)
 	{
-		p[i] = malloc(1024);
-		assert_non_null(p[i]);
-		assert_in_range((uintptr_t)p[i], mem_block_addr, mem_block_end_addr);
+		ptr_array[i] = malloc(1024);
+		assert_non_null(ptr_array[i]);
+		assert_in_range((uintptr_t)ptr_array[i], mem_block_addr, mem_block_end_addr);
 	}
 
 	// Cleanup
 	for(int i = 0; i < ALLOCATION_TEST_COUNT; i++)
 	{
-		free(p[i]);
+		free(ptr_array[i]);
 	}
 
 	assert_true(malloc_lock_called);