libobs/util: Fix operator precedence in dyamic array macros

Passing DARRAY with an operator such as dereference (`*`) sometimes
caused a compile error. To avoid the error, introduced parentheses
inside the macros.

libobs/util/darray.h

@@ -479,70 +479,73 @@ static inline void darray_swap(const size_t element_size, struct darray *dst,
 		};                       \
 	}
 
-#define da_init(v) darray_init(&v.da)
+#define da_init(v) darray_init(&(v).da)
 
-#define da_free(v) darray_free(&v.da)
+#define da_free(v) darray_free(&(v).da)
 
-#define da_alloc_size(v) (sizeof(*v.array) * v.num)
+#define da_alloc_size(v) (sizeof(*(v).array) * (v).num)
 
-#define da_end(v) darray_end(sizeof(*v.array), &v.da)
+#define da_end(v) darray_end(sizeof(*(v).array), &(v).da)
 
 #define da_reserve(v, capacity) \
-	darray_reserve(sizeof(*v.array), &v.da, capacity)
+	darray_reserve(sizeof(*(v).array), &(v).da, capacity)
 
-#define da_resize(v, size) darray_resize(sizeof(*v.array), &v.da, size)
+#define da_resize(v, size) darray_resize(sizeof(*(v).array), &(v).da, size)
 
-#define da_clear(v) darray_clear(&v.da)
+#define da_clear(v) darray_clear(&(v).da)
 
-#define da_copy(dst, src) darray_copy(sizeof(*dst.array), &dst.da, &src.da)
+#define da_copy(dst, src) \
+	darray_copy(sizeof(*(dst).array), &(dst).da, &(src).da)
 
 #define da_copy_array(dst, src_array, n) \
-	darray_copy_array(sizeof(*dst.array), &dst.da, src_array, n)
+	darray_copy_array(sizeof(*(dst).array), &(dst).da, src_array, n)
 
-#define da_move(dst, src) darray_move(&dst.da, &src.da)
+#define da_move(dst, src) darray_move(&(dst).da, &(src).da)
 
 #ifdef ENABLE_DARRAY_TYPE_TEST
 #ifdef __cplusplus
 #define da_type_test(v, item)                 \
 	({                                    \
 		if (false) {                  \
-			auto _t = v.array;    \
+			auto _t = (v).array;  \
 			_t = (item);          \
 			(void)_t;             \
 			*(v).array = *(item); \
 		}                             \
 	})
 #else
-#define da_type_test(v, item)                       \
-	({                                          \
-		if (false) {                        \
-			const typeof(*v.array) *_t; \
-			_t = (item);                \
-			(void)_t;                   \
-			*(v).array = *(item);       \
-		}                                   \
+#define da_type_test(v, item)                         \
+	({                                            \
+		if (false) {                          \
+			const typeof(*(v).array) *_t; \
+			_t = (item);                  \
+			(void)_t;                     \
+			*(v).array = *(item);         \
+		}                                     \
 	})
 #endif
 #endif // ENABLE_DARRAY_TYPE_TEST
 
 #ifdef ENABLE_DARRAY_TYPE_TEST
-#define da_find(v, item, idx)                                    \
-	({                                                       \
-		da_type_test(v, item);                           \
-		darray_find(sizeof(*v.array), &v.da, item, idx); \
+#define da_find(v, item, idx)                                        \
+	({                                                           \
+		da_type_test(v, item);                               \
+		darray_find(sizeof(*(v).array), &(v).da, item, idx); \
 	})
 #else
-#define da_find(v, item, idx) darray_find(sizeof(*v.array), &v.da, item, idx)
+#define da_find(v, item, idx) \
+	darray_find(sizeof(*(v).array), &(v).da, item, idx)
 #endif
 
 #ifdef ENABLE_DARRAY_TYPE_TEST
-#define da_push_back(v, item)                                    \
-	({                                                       \
-		da_type_test(v, item);                           \
-		darray_push_back(sizeof(*v.array), &v.da, item); \
+#define da_push_back(v, item)                                        \
+	({                                                           \
+		da_type_test(v, item);                               \
+		darray_push_back(sizeof(*(v).array), &(v).da, item); \
 	})
 #else
-#define da_push_back(v, item) darray_push_back(sizeof(*v.array), &v.da, item)
+#define da_push_back(v, item) \
+	darray_push_back(sizeof(*(v).array), &(v).da, item)
 #endif
 
 #ifdef __GNUC__
@@ -557,96 +560,101 @@ static inline void darray_swap(const size_t element_size, struct darray *dst,
 		&d->array[d->num - 1];                                       \
 	})
 #else
-#define da_push_back_new(v) darray_push_back_new(sizeof(*v.array), &v.da)
+#define da_push_back_new(v) darray_push_back_new(sizeof(*(v).array), &(v).da)
 #endif
 
 #ifdef ENABLE_DARRAY_TYPE_TEST
-#define da_push_back_array(dst, src_array, n)                                  \
-	({                                                                     \
-		da_type_test(dst, src_array);                                  \
-		darray_push_back_array(sizeof(*dst.array), &dst.da, src_array, \
-				       n);                                     \
+#define da_push_back_array(dst, src_array, n)                           \
+	({                                                              \
+		da_type_test(dst, src_array);                           \
+		darray_push_back_array(sizeof(*(dst).array), &(dst).da, \
+				       src_array, n);                   \
 	})
 #else
 #define da_push_back_array(dst, src_array, n) \
-	darray_push_back_array(sizeof(*dst.array), &dst.da, src_array, n)
+	darray_push_back_array(sizeof(*(dst).array), &(dst).da, src_array, n)
 #endif
 
 #ifdef ENABLE_DARRAY_TYPE_TEST
-#define da_push_back_da(dst, src)                                              \
-	({                                                                     \
-		da_type_test(dst, src.array);                                  \
-		darray_push_back_darray(sizeof(*dst.array), &dst.da, &src.da); \
+#define da_push_back_da(dst, src)                                        \
+	({                                                               \
+		da_type_test(dst, (src).array);                          \
+		darray_push_back_darray(sizeof(*(dst).array), &(dst).da, \
+					&(src).da);                      \
 	})
 #else
 #define da_push_back_da(dst, src) \
-	darray_push_back_darray(sizeof(*dst.array), &dst.da, &src.da)
+	darray_push_back_darray(sizeof(*(dst).array), &(dst).da, &(src).da)
 #endif
 
 #ifdef ENABLE_DARRAY_TYPE_TEST
-#define da_insert(v, idx, item)                                    \
-	({                                                         \
-		da_type_test(v, item);                             \
-		darray_insert(sizeof(*v.array), &v.da, idx, item); \
+#define da_insert(v, idx, item)                                        \
+	({                                                             \
+		da_type_test(v, item);                                 \
+		darray_insert(sizeof(*(v).array), &(v).da, idx, item); \
 	})
 #else
 #define da_insert(v, idx, item) \
-	darray_insert(sizeof(*v.array), &v.da, idx, item)
+	darray_insert(sizeof(*(v).array), &(v).da, idx, item)
 #endif
 
-#define da_insert_new(v, idx) darray_insert_new(sizeof(*v.array), &v.da, idx)
+#define da_insert_new(v, idx) \
+	darray_insert_new(sizeof(*(v).array), &(v).da, idx)
 
 #ifdef ENABLE_DARRAY_TYPE_TEST
-#define da_insert_array(dst, idx, src_array, n)                       \
-	({                                                            \
-		da_type_test(dst, src_array);                         \
-		darray_insert_array(sizeof(*dst.array), &dst.da, idx, \
-				    src_array, n);                    \
+#define da_insert_array(dst, idx, src_array, n)                           \
+	({                                                                \
+		da_type_test(dst, src_array);                             \
+		darray_insert_array(sizeof(*(dst).array), &(dst).da, idx, \
+				    src_array, n);                        \
 	})
 #else
 #define da_insert_array(dst, idx, src_array, n) \
-	darray_insert_array(sizeof(*dst.array), &dst.da, idx, src_array, n)
+	darray_insert_array(sizeof(*(dst).array), &(dst).da, idx, src_array, n)
 #endif
 
 #ifdef ENABLE_DARRAY_TYPE_TEST
-#define da_insert_da(dst, idx, src)                                    \
-	({                                                             \
-		da_type_test(dst, src.array);                          \
-		darray_insert_darray(sizeof(*dst.array), &dst.da, idx, \
-				     &src.da);                         \
+#define da_insert_da(dst, idx, src)                                        \
+	({                                                                 \
+		da_type_test(dst, (src).array);                            \
+		darray_insert_darray(sizeof(*(dst).array), &(dst).da, idx, \
+				     &(src).da);                           \
 	})
 #else
 #define da_insert_da(dst, idx, src) \
-	darray_insert_darray(sizeof(*dst.array), &dst.da, idx, &src.da)
+	darray_insert_darray(sizeof(*(dst).array), &(dst).da, idx, &(src).da)
 #endif
 
-#define da_erase(dst, idx) darray_erase(sizeof(*dst.array), &dst.da, idx)
+#define da_erase(dst, idx) darray_erase(sizeof(*(dst).array), &(dst).da, idx)
 
 #ifdef ENABLE_DARRAY_TYPE_TEST
-#define da_erase_item(dst, item)                                      \
-	({                                                            \
-		da_type_test(dst, item);                              \
-		darray_erase_item(sizeof(*dst.array), &dst.da, item); \
+#define da_erase_item(dst, item)                                          \
+	({                                                                \
+		da_type_test(dst, item);                                  \
+		darray_erase_item(sizeof(*(dst).array), &(dst).da, item); \
 	})
 #else
 #define da_erase_item(dst, item) \
-	darray_erase_item(sizeof(*dst.array), &dst.da, item)
+	darray_erase_item(sizeof(*(dst).array), &(dst).da, item)
 #endif
 
 #define da_erase_range(dst, from, to) \
-	darray_erase_range(sizeof(*dst.array), &dst.da, from, to)
+	darray_erase_range(sizeof(*(dst).array), &(dst).da, from, to)
 
-#define da_pop_back(dst) darray_pop_back(sizeof(*dst.array), &dst.da);
+#define da_pop_back(dst) darray_pop_back(sizeof(*(dst).array), &(dst).da);
 
-#define da_join(dst, src) darray_join(sizeof(*dst.array), &dst.da, &src.da)
+#define da_join(dst, src) \
+	darray_join(sizeof(*(dst).array), &(dst).da, &(src).da)
 
-#define da_split(dst1, dst2, src, idx) \
-	darray_split(sizeof(*src.array), &dst1.da, &dst2.da, &src.da, idx)
+#define da_split(dst1, dst2, src, idx)                                        \
+	darray_split(sizeof(*(src).array), &(dst1).da, &(dst2).da, &(src).da, \
+		     idx)
 
 #define da_move_item(v, from, to) \
-	darray_move_item(sizeof(*v.array), &v.da, from, to)
+	darray_move_item(sizeof(*(v).array), &(v).da, from, to)
 
-#define da_swap(v, idx1, idx2) darray_swap(sizeof(*v.array), &v.da, idx1, idx2)
+#define da_swap(v, idx1, idx2) \
+	darray_swap(sizeof(*(v).array), &(v).da, idx1, idx2)
 
 #ifdef __cplusplus
 }