upb: start to lock down upb_Array
PiperOrigin-RevId: 585696951
diff --git a/upb/message/internal/array.h b/upb/message/internal/array.h
index dc68a66..a99e2e4 100644
--- a/upb/message/internal/array.h
+++ b/upb/message/internal/array.h
@@ -35,81 +35,82 @@
// Bit #2 contains the frozen/immutable flag (currently unimplemented).
uintptr_t data;
- size_t size; // The number of elements in the array.
- size_t capacity; // Allocated storage. Measured in elements.
+ size_t size; // The number of elements in the array.
+ size_t UPB_PRIVATE(capacity); // Allocated storage. Measured in elements.
};
// LINT.ThenChange(GoogleInternalName1)
-UPB_INLINE void _upb_Array_SetTaggedPtr(upb_Array* arr, void* data,
- size_t lg2) {
+UPB_INLINE void UPB_PRIVATE(_upb_Array_SetTaggedPtr)(upb_Array* array,
+ void* data, size_t lg2) {
UPB_ASSERT(lg2 != 1);
UPB_ASSERT(lg2 <= 4);
const size_t bits = lg2 - (lg2 != 0);
- arr->data = (uintptr_t)data | bits;
+ array->data = (uintptr_t)data | bits;
}
-UPB_INLINE size_t _upb_Array_ElemSizeLg2(const upb_Array* arr) {
- const size_t bits = arr->data & _UPB_ARRAY_MASK_LG2;
+UPB_INLINE size_t UPB_PRIVATE(_upb_Array_ElemSizeLg2)(const upb_Array* array) {
+ const size_t bits = array->data & _UPB_ARRAY_MASK_LG2;
const size_t lg2 = bits + (bits != 0);
return lg2;
}
-UPB_INLINE const void* _upb_array_constptr(const upb_Array* arr) {
- _upb_Array_ElemSizeLg2(arr); // Check assertions.
- return (void*)(arr->data & ~(uintptr_t)_UPB_ARRAY_MASK_ALL);
+UPB_INLINE const void* _upb_array_constptr(const upb_Array* array) {
+ UPB_PRIVATE(_upb_Array_ElemSizeLg2)(array); // Check assertions.
+ return (void*)(array->data & ~(uintptr_t)_UPB_ARRAY_MASK_ALL);
}
-UPB_INLINE void* _upb_array_ptr(upb_Array* arr) {
- return (void*)_upb_array_constptr(arr);
+UPB_INLINE void* _upb_array_ptr(upb_Array* array) {
+ return (void*)_upb_array_constptr(array);
}
-UPB_INLINE upb_Array* _upb_Array_New(upb_Arena* a, size_t init_capacity,
- int elem_size_lg2) {
+UPB_INLINE upb_Array* UPB_PRIVATE(_upb_Array_New)(upb_Arena* arena,
+ size_t init_capacity,
+ int elem_size_lg2) {
UPB_ASSERT(elem_size_lg2 != 1);
UPB_ASSERT(elem_size_lg2 <= 4);
- const size_t arr_size = UPB_ALIGN_UP(sizeof(upb_Array), UPB_MALLOC_ALIGN);
- const size_t bytes = arr_size + (init_capacity << elem_size_lg2);
- upb_Array* arr = (upb_Array*)upb_Arena_Malloc(a, bytes);
- if (!arr) return NULL;
- _upb_Array_SetTaggedPtr(arr, UPB_PTR_AT(arr, arr_size, void), elem_size_lg2);
- arr->size = 0;
- arr->capacity = init_capacity;
- return arr;
+ const size_t array_size = UPB_ALIGN_UP(sizeof(upb_Array), UPB_MALLOC_ALIGN);
+ const size_t bytes = array_size + (init_capacity << elem_size_lg2);
+ upb_Array* array = (upb_Array*)upb_Arena_Malloc(arena, bytes);
+ if (!array) return NULL;
+ UPB_PRIVATE(_upb_Array_SetTaggedPtr)
+ (array, UPB_PTR_AT(array, array_size, void), elem_size_lg2);
+ array->size = 0;
+ array->UPB_PRIVATE(capacity) = init_capacity;
+ return array;
}
// Resizes the capacity of the array to be at least min_size.
-bool _upb_array_realloc(upb_Array* arr, size_t min_size, upb_Arena* arena);
+bool UPB_PRIVATE(_upb_Array_Realloc)(upb_Array* array, size_t min_size,
+ upb_Arena* arena);
-UPB_INLINE bool _upb_array_reserve(upb_Array* arr, size_t size,
- upb_Arena* arena) {
- if (arr->capacity < size) return _upb_array_realloc(arr, size, arena);
+UPB_INLINE bool UPB_PRIVATE(_upb_Array_Reserve)(upb_Array* array, size_t size,
+ upb_Arena* arena) {
+ if (array->UPB_PRIVATE(capacity) < size)
+ return UPB_PRIVATE(_upb_Array_Realloc)(array, size, arena);
return true;
}
// Resize without initializing new elements.
-UPB_INLINE bool _upb_Array_ResizeUninitialized(upb_Array* arr, size_t size,
+UPB_INLINE bool _upb_Array_ResizeUninitialized(upb_Array* array, size_t size,
upb_Arena* arena) {
- UPB_ASSERT(size <= arr->size || arena); // Allow NULL arena when shrinking.
- if (!_upb_array_reserve(arr, size, arena)) return false;
- arr->size = size;
+ UPB_ASSERT(size <= array->size || arena); // Allow NULL arena when shrinking.
+ if (!UPB_PRIVATE(_upb_Array_Reserve)(array, size, arena)) return false;
+ array->size = size;
return true;
}
// This function is intended for situations where elem_size is compile-time
// constant or a known expression of the form (1 << lg2), so that the expression
// i*elem_size does not result in an actual multiplication.
-UPB_INLINE void _upb_Array_Set(upb_Array* arr, size_t i, const void* data,
- size_t elem_size) {
- UPB_ASSERT(i < arr->size);
- UPB_ASSERT(elem_size == 1U << _upb_Array_ElemSizeLg2(arr));
- char* arr_data = (char*)_upb_array_ptr(arr);
+UPB_INLINE void UPB_PRIVATE(_upb_Array_Set)(upb_Array* array, size_t i,
+ const void* data,
+ size_t elem_size) {
+ UPB_ASSERT(i < array->size);
+ UPB_ASSERT(elem_size == 1U << UPB_PRIVATE(_upb_Array_ElemSizeLg2)(array));
+ char* arr_data = (char*)_upb_array_ptr(array);
memcpy(arr_data + (i * elem_size), data, elem_size);
}
-UPB_INLINE void _upb_array_detach(const void* msg, size_t ofs) {
- *UPB_PTR_AT(msg, ofs, upb_Array*) = NULL;
-}
-
#ifdef __cplusplus
} /* extern "C" */
#endif
