From b0d3a787cc7f460df40452d0094f70f5ba750c6d Mon Sep 17 00:00:00 2001 From: Eric Salo Date: Thu, 8 Feb 2024 13:37:50 -0800 Subject: [PATCH] upb: Simplify inline functions in mini_table/ and mem/ and wire/ and message/ PiperOrigin-RevId: 605413999 --- upb/mem/arena.h | 12 ++----- upb/mem/internal/arena.h | 14 ++++---- upb/message/accessors.h | 23 ++++-------- upb/message/array.h | 16 +++------ upb/message/internal/accessors.h | 36 +++++++++---------- upb/message/internal/array.h | 20 +++++------ upb/message/internal/map.h | 8 ++--- upb/message/internal/tagged_ptr.h | 10 +++--- upb/message/internal/types.h | 13 +++++-- upb/message/map.h | 6 ++-- upb/message/message.h | 4 +-- upb/message/tagged_ptr.h | 12 +++---- upb/mini_table/enum.h | 6 ++-- upb/mini_table/extension.h | 16 +++------ upb/mini_table/field.h | 50 +++++++------------------- upb/mini_table/file.h | 25 ++++--------- upb/mini_table/internal/enum.h | 2 +- upb/mini_table/internal/extension.h | 18 +++++----- upb/mini_table/internal/field.h | 46 ++++++++++++------------ upb/mini_table/internal/file.h | 14 ++++---- upb/mini_table/internal/message.h | 55 +++++++++++++---------------- upb/mini_table/internal/sub.h | 8 ++--- upb/mini_table/message.h | 32 +++++------------ upb/mini_table/sub.h | 16 +++------ upb/wire/decode.c | 2 +- upb/wire/internal/reader.h | 4 +-- upb/wire/reader.h | 8 ++--- 27 files changed, 182 insertions(+), 294 deletions(-) diff --git a/upb/mem/arena.h b/upb/mem/arena.h index 319707ec29..35e8314f6f 100644 --- a/upb/mem/arena.h +++ b/upb/mem/arena.h @@ -53,23 +53,17 @@ UPB_API_INLINE upb_Arena* upb_Arena_New(void) { return upb_Arena_Init(NULL, 0, &upb_alloc_global); } -UPB_API_INLINE void* upb_Arena_Malloc(struct upb_Arena* a, size_t size) { - return UPB_PRIVATE(_upb_Arena_Malloc)(a, size); -} +UPB_API_INLINE void* upb_Arena_Malloc(struct upb_Arena* a, size_t size); UPB_API_INLINE void* upb_Arena_Realloc(upb_Arena* a, void* ptr, size_t oldsize, - size_t size) { - return UPB_PRIVATE(_upb_Arena_Realloc)(a, ptr, oldsize, size); -} + size_t size); // Shrinks the last alloc from arena. // REQUIRES: (ptr, oldsize) was the last malloc/realloc from this arena. // We could also add a upb_Arena_TryShrinkLast() which is simply a no-op if // this was not the last alloc. UPB_API_INLINE void upb_Arena_ShrinkLast(upb_Arena* a, void* ptr, - size_t oldsize, size_t size) { - UPB_PRIVATE(_upb_Arena_ShrinkLast)(a, ptr, oldsize, size); -} + size_t oldsize, size_t size); #ifdef __cplusplus } /* extern "C" */ diff --git a/upb/mem/internal/arena.h b/upb/mem/internal/arena.h index bff2b602dd..cc97be54de 100644 --- a/upb/mem/internal/arena.h +++ b/upb/mem/internal/arena.h @@ -44,8 +44,7 @@ UPB_INLINE size_t UPB_PRIVATE(_upb_ArenaHas)(const struct upb_Arena* a) { return (size_t)(a->UPB_ONLYBITS(end) - a->UPB_ONLYBITS(ptr)); } -UPB_INLINE void* UPB_PRIVATE(_upb_Arena_Malloc)(struct upb_Arena* a, - size_t size) { +UPB_API_INLINE void* upb_Arena_Malloc(struct upb_Arena* a, size_t size) { void* UPB_PRIVATE(_upb_Arena_SlowMalloc)(struct upb_Arena * a, size_t size); size = UPB_ALIGN_MALLOC(size); @@ -65,8 +64,8 @@ UPB_INLINE void* UPB_PRIVATE(_upb_Arena_Malloc)(struct upb_Arena* a, return ret; } -UPB_INLINE void* UPB_PRIVATE(_upb_Arena_Realloc)(struct upb_Arena* a, void* ptr, - size_t oldsize, size_t size) { +UPB_API_INLINE void* upb_Arena_Realloc(struct upb_Arena* a, void* ptr, + size_t oldsize, size_t size) { oldsize = UPB_ALIGN_MALLOC(oldsize); size = UPB_ALIGN_MALLOC(size); bool is_most_recent_alloc = @@ -82,7 +81,7 @@ UPB_INLINE void* UPB_PRIVATE(_upb_Arena_Realloc)(struct upb_Arena* a, void* ptr, return ptr; } - void* ret = UPB_PRIVATE(_upb_Arena_Malloc)(a, size); + void* ret = upb_Arena_Malloc(a, size); if (ret && oldsize > 0) { memcpy(ret, ptr, UPB_MIN(oldsize, size)); @@ -91,9 +90,8 @@ UPB_INLINE void* UPB_PRIVATE(_upb_Arena_Realloc)(struct upb_Arena* a, void* ptr, return ret; } -UPB_INLINE void UPB_PRIVATE(_upb_Arena_ShrinkLast)(struct upb_Arena* a, - void* ptr, size_t oldsize, - size_t size) { +UPB_API_INLINE void upb_Arena_ShrinkLast(struct upb_Arena* a, void* ptr, + size_t oldsize, size_t size) { oldsize = UPB_ALIGN_MALLOC(oldsize); size = UPB_ALIGN_MALLOC(size); // Must be the last alloc. diff --git a/upb/message/accessors.h b/upb/message/accessors.h index 64f770b952..988b450fe5 100644 --- a/upb/message/accessors.h +++ b/upb/message/accessors.h @@ -40,30 +40,19 @@ extern "C" { // Functions ending in Extension() take a (upb_MiniTableExtension*) argument // and work only on extensions. -UPB_API_INLINE void upb_Message_Clear(upb_Message* msg, - const upb_MiniTable* m) { - UPB_PRIVATE(_upb_Message_Clear)(msg, m); -} +UPB_API_INLINE void upb_Message_Clear(upb_Message* msg, const upb_MiniTable* m); UPB_API_INLINE void upb_Message_ClearBaseField(upb_Message* msg, - const upb_MiniTableField* f) { - UPB_PRIVATE(_upb_Message_ClearBaseField)(msg, f); -} + const upb_MiniTableField* f); -UPB_API_INLINE void upb_Message_ClearExtension( - upb_Message* msg, const upb_MiniTableExtension* e) { - UPB_PRIVATE(_upb_Message_ClearExtension)(msg, e); -} +UPB_API_INLINE void upb_Message_ClearExtension(upb_Message* msg, + const upb_MiniTableExtension* e); UPB_API_INLINE bool upb_Message_HasBaseField(const upb_Message* msg, - const upb_MiniTableField* f) { - return UPB_PRIVATE(_upb_Message_HasBaseField)(msg, f); -} + const upb_MiniTableField* f); UPB_API_INLINE bool upb_Message_HasExtension(const upb_Message* msg, - const upb_MiniTableExtension* e) { - return UPB_PRIVATE(_upb_Message_HasExtension)(msg, e); -} + const upb_MiniTableExtension* e); UPB_API_INLINE uint32_t upb_Message_WhichOneofFieldNumber( const upb_Message* message, const upb_MiniTableField* oneof_field) { diff --git a/upb/message/array.h b/upb/message/array.h index 2702e1819a..8869b30a45 100644 --- a/upb/message/array.h +++ b/upb/message/array.h @@ -30,9 +30,7 @@ extern "C" { UPB_API upb_Array* upb_Array_New(upb_Arena* a, upb_CType type); // Returns the number of elements in the array. -UPB_API_INLINE size_t upb_Array_Size(const upb_Array* arr) { - return UPB_PRIVATE(_upb_Array_Size)(arr); -} +UPB_API_INLINE size_t upb_Array_Size(const upb_Array* arr); // Returns the given element, which must be within the array's current size. UPB_API upb_MessageValue upb_Array_Get(const upb_Array* arr, size_t i); @@ -70,14 +68,10 @@ UPB_API void upb_Array_Delete(upb_Array* array, size_t i, size_t count); UPB_API bool upb_Array_Resize(upb_Array* array, size_t size, upb_Arena* arena); // Returns pointer to array data. -UPB_API_INLINE const void* upb_Array_DataPtr(const upb_Array* arr) { - return UPB_PRIVATE(_upb_Array_DataPtr)(arr); -} +UPB_API_INLINE const void* upb_Array_DataPtr(const upb_Array* arr); // Returns mutable pointer to array data. -UPB_API_INLINE void* upb_Array_MutableDataPtr(upb_Array* arr) { - return UPB_PRIVATE(_upb_Array_MutableDataPtr)(arr); -} +UPB_API_INLINE void* upb_Array_MutableDataPtr(upb_Array* arr); // Mark an array and all of its descendents as frozen/immutable. // If the array elements are messages then |m| must point to the minitable for @@ -85,9 +79,7 @@ UPB_API_INLINE void* upb_Array_MutableDataPtr(upb_Array* arr) { UPB_API void upb_Array_Freeze(upb_Array* arr, const upb_MiniTable* m); // Returns whether an array has been frozen. -UPB_API_INLINE bool upb_Array_IsFrozen(const upb_Array* arr) { - return UPB_PRIVATE(_upb_Array_IsFrozen)(arr); -} +UPB_API_INLINE bool upb_Array_IsFrozen(const upb_Array* arr); #ifdef __cplusplus } /* extern "C" */ diff --git a/upb/message/internal/accessors.h b/upb/message/internal/accessors.h index a62d18ffb1..0b5cd7f480 100644 --- a/upb/message/internal/accessors.h +++ b/upb/message/internal/accessors.h @@ -225,8 +225,8 @@ UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_DataIsZero)( // of a setter is known to be a non-extension, the arena may be NULL and the // returned bool value may be ignored since it will always succeed. -UPB_INLINE bool UPB_PRIVATE(_upb_Message_HasBaseField)( - const struct upb_Message* msg, const upb_MiniTableField* field) { +UPB_API_INLINE bool upb_Message_HasBaseField(const struct upb_Message* msg, + const upb_MiniTableField* field) { UPB_ASSERT(upb_MiniTableField_HasPresence(field)); UPB_ASSUME(!upb_MiniTableField_IsExtension(field)); if (upb_MiniTableField_IsInOneof(field)) { @@ -237,10 +237,10 @@ UPB_INLINE bool UPB_PRIVATE(_upb_Message_HasBaseField)( } } -UPB_INLINE bool UPB_PRIVATE(_upb_Message_HasExtension)( - const struct upb_Message* msg, const upb_MiniTableExtension* ext) { - UPB_ASSERT(upb_MiniTableField_HasPresence(&ext->UPB_PRIVATE(field))); - return UPB_PRIVATE(_upb_Message_Getext)(msg, ext) != NULL; +UPB_API_INLINE bool upb_Message_HasExtension(const struct upb_Message* msg, + const upb_MiniTableExtension* e) { + UPB_ASSERT(upb_MiniTableField_HasPresence(&e->UPB_PRIVATE(field))); + return UPB_PRIVATE(_upb_Message_Getext)(msg, e) != NULL; } UPB_FORCEINLINE void _upb_Message_GetNonExtensionField( @@ -249,7 +249,7 @@ UPB_FORCEINLINE void _upb_Message_GetNonExtensionField( UPB_ASSUME(!upb_MiniTableField_IsExtension(field)); if ((upb_MiniTableField_IsInOneof(field) || !UPB_PRIVATE(_upb_MiniTableField_DataIsZero)(field, default_val)) && - !UPB_PRIVATE(_upb_Message_HasBaseField)(msg, field)) { + !upb_Message_HasBaseField(msg, field)) { UPB_PRIVATE(_upb_MiniTableField_DataCopy)(field, val, default_val); return; } @@ -273,7 +273,7 @@ UPB_INLINE void _upb_Message_GetExtensionField( UPB_INLINE void _upb_Message_SetNonExtensionField( struct upb_Message* msg, const upb_MiniTableField* field, const void* val) { - UPB_ASSERT(!UPB_PRIVATE(_upb_Message_IsFrozen)(msg)); + UPB_ASSERT(!upb_Message_IsFrozen(msg)); UPB_ASSUME(!upb_MiniTableField_IsExtension(field)); UPB_PRIVATE(_upb_Message_SetPresence)(msg, field); UPB_PRIVATE(_upb_MiniTableField_DataCopy) @@ -283,7 +283,7 @@ UPB_INLINE void _upb_Message_SetNonExtensionField( UPB_INLINE bool _upb_Message_SetExtensionField( struct upb_Message* msg, const upb_MiniTableExtension* mt_ext, const void* val, upb_Arena* a) { - UPB_ASSERT(!UPB_PRIVATE(_upb_Message_IsFrozen)(msg)); + UPB_ASSERT(!upb_Message_IsFrozen(msg)); UPB_ASSERT(a); upb_Extension* ext = UPB_PRIVATE(_upb_Message_GetOrCreateExtension)(msg, mt_ext, a); @@ -293,15 +293,15 @@ UPB_INLINE bool _upb_Message_SetExtensionField( return true; } -UPB_INLINE void UPB_PRIVATE(_upb_Message_Clear)(struct upb_Message* msg, - const upb_MiniTable* m) { - UPB_ASSERT(!UPB_PRIVATE(_upb_Message_IsFrozen)(msg)); +UPB_API_INLINE void upb_Message_Clear(struct upb_Message* msg, + const upb_MiniTable* m) { + UPB_ASSERT(!upb_Message_IsFrozen(msg)); memset(msg, 0, m->UPB_PRIVATE(size)); } -UPB_INLINE void UPB_PRIVATE(_upb_Message_ClearBaseField)( - struct upb_Message* msg, const upb_MiniTableField* f) { - UPB_ASSERT(!UPB_PRIVATE(_upb_Message_IsFrozen)(msg)); +UPB_API_INLINE void upb_Message_ClearBaseField(struct upb_Message* msg, + const upb_MiniTableField* f) { + UPB_ASSERT(!upb_Message_IsFrozen(msg)); if (UPB_PRIVATE(_upb_MiniTableField_HasHasbit)(f)) { UPB_PRIVATE(_upb_Message_ClearHasbit)(msg, f); } else if (upb_MiniTableField_IsInOneof(f)) { @@ -314,9 +314,9 @@ UPB_INLINE void UPB_PRIVATE(_upb_Message_ClearBaseField)( (f, UPB_PRIVATE(_upb_Message_MutableDataPtr)(msg, f), zeros); } -UPB_INLINE void UPB_PRIVATE(_upb_Message_ClearExtension)( +UPB_API_INLINE void upb_Message_ClearExtension( struct upb_Message* msg, const upb_MiniTableExtension* e) { - UPB_ASSERT(!UPB_PRIVATE(_upb_Message_IsFrozen)(msg)); + UPB_ASSERT(!upb_Message_IsFrozen(msg)); upb_Message_Internal* in = UPB_PRIVATE(_upb_Message_GetInternal)(msg); if (!in) return; const upb_Extension* base = UPB_PTR_AT(in, in->ext_begin, upb_Extension); @@ -335,7 +335,7 @@ UPB_INLINE void _upb_Message_AssertMapIsUntagged( uintptr_t default_val = 0; uintptr_t tagged; _upb_Message_GetNonExtensionField(msg, field, &default_val, &tagged); - UPB_ASSERT(!UPB_PRIVATE(_upb_TaggedMessagePtr_IsEmpty)(tagged)); + UPB_ASSERT(!upb_TaggedMessagePtr_IsEmpty(tagged)); #endif } diff --git a/upb/message/internal/array.h b/upb/message/internal/array.h index 28052e126e..0414432a95 100644 --- a/upb/message/internal/array.h +++ b/upb/message/internal/array.h @@ -45,7 +45,7 @@ UPB_INLINE void UPB_PRIVATE(_upb_Array_ShallowFreeze)(struct upb_Array* arr) { arr->UPB_ONLYBITS(data) |= _UPB_ARRAY_MASK_IMM; } -UPB_INLINE bool UPB_PRIVATE(_upb_Array_IsFrozen)(const struct upb_Array* arr) { +UPB_API_INLINE bool upb_Array_IsFrozen(const struct upb_Array* arr) { return (arr->UPB_ONLYBITS(data) & _UPB_ARRAY_MASK_IMM) != 0; } @@ -64,15 +64,13 @@ UPB_PRIVATE(_upb_Array_ElemSizeLg2)(const struct upb_Array* array) { return lg2; } -UPB_INLINE const void* UPB_PRIVATE(_upb_Array_DataPtr)( - const struct upb_Array* array) { +UPB_API_INLINE const void* upb_Array_DataPtr(const struct upb_Array* array) { UPB_PRIVATE(_upb_Array_ElemSizeLg2)(array); // Check assertions. return (void*)(array->UPB_ONLYBITS(data) & ~(uintptr_t)_UPB_ARRAY_MASK_ALL); } -UPB_INLINE void* UPB_PRIVATE(_upb_Array_MutableDataPtr)( - struct upb_Array* array) { - return (void*)UPB_PRIVATE(_upb_Array_DataPtr)(array); +UPB_API_INLINE void* upb_Array_MutableDataPtr(struct upb_Array* array) { + return (void*)upb_Array_DataPtr(array); } UPB_INLINE struct upb_Array* UPB_PRIVATE(_upb_Array_New)(upb_Arena* arena, @@ -98,7 +96,7 @@ bool UPB_PRIVATE(_upb_Array_Realloc)(struct upb_Array* array, size_t min_size, UPB_INLINE bool UPB_PRIVATE(_upb_Array_Reserve)(struct upb_Array* array, size_t size, upb_Arena* arena) { - UPB_ASSERT(!UPB_PRIVATE(_upb_Array_IsFrozen)(array)); + UPB_ASSERT(!upb_Array_IsFrozen(array)); if (array->UPB_PRIVATE(capacity) < size) return UPB_PRIVATE(_upb_Array_Realloc)(array, size, arena); return true; @@ -107,7 +105,7 @@ UPB_INLINE bool UPB_PRIVATE(_upb_Array_Reserve)(struct upb_Array* array, // Resize without initializing new elements. UPB_INLINE bool UPB_PRIVATE(_upb_Array_ResizeUninitialized)( struct upb_Array* array, size_t size, upb_Arena* arena) { - UPB_ASSERT(!UPB_PRIVATE(_upb_Array_IsFrozen)(array)); + UPB_ASSERT(!upb_Array_IsFrozen(array)); UPB_ASSERT(size <= array->UPB_ONLYBITS(size) || arena); // Allow NULL arena when shrinking. if (!UPB_PRIVATE(_upb_Array_Reserve)(array, size, arena)) return false; @@ -121,14 +119,14 @@ UPB_INLINE bool UPB_PRIVATE(_upb_Array_ResizeUninitialized)( UPB_INLINE void UPB_PRIVATE(_upb_Array_Set)(struct upb_Array* array, size_t i, const void* data, size_t elem_size) { - UPB_ASSERT(!UPB_PRIVATE(_upb_Array_IsFrozen)(array)); + UPB_ASSERT(!upb_Array_IsFrozen(array)); UPB_ASSERT(i < array->UPB_ONLYBITS(size)); UPB_ASSERT(elem_size == 1U << UPB_PRIVATE(_upb_Array_ElemSizeLg2)(array)); - char* arr_data = (char*)UPB_PRIVATE(_upb_Array_MutableDataPtr)(array); + char* arr_data = (char*)upb_Array_MutableDataPtr(array); memcpy(arr_data + (i * elem_size), data, elem_size); } -UPB_INLINE size_t UPB_PRIVATE(_upb_Array_Size)(const struct upb_Array* arr) { +UPB_API_INLINE size_t upb_Array_Size(const struct upb_Array* arr) { return arr->UPB_ONLYBITS(size); } diff --git a/upb/message/internal/map.h b/upb/message/internal/map.h index c444b2bb6a..e21b61850a 100644 --- a/upb/message/internal/map.h +++ b/upb/message/internal/map.h @@ -45,7 +45,7 @@ UPB_INLINE void UPB_PRIVATE(_upb_Map_ShallowFreeze)(struct upb_Map* map) { map->UPB_PRIVATE(is_frozen) = true; } -UPB_INLINE bool UPB_PRIVATE(_upb_Map_IsFrozen)(const struct upb_Map* map) { +UPB_API_INLINE bool upb_Map_IsFrozen(const struct upb_Map* map) { return map->UPB_PRIVATE(is_frozen); } @@ -106,14 +106,14 @@ UPB_INLINE void* _upb_map_next(const struct upb_Map* map, size_t* iter) { } UPB_INLINE void _upb_Map_Clear(struct upb_Map* map) { - UPB_ASSERT(!UPB_PRIVATE(_upb_Map_IsFrozen)(map)); + UPB_ASSERT(!upb_Map_IsFrozen(map)); upb_strtable_clear(&map->table); } UPB_INLINE bool _upb_Map_Delete(struct upb_Map* map, const void* key, size_t key_size, upb_value* val) { - UPB_ASSERT(!UPB_PRIVATE(_upb_Map_IsFrozen)(map)); + UPB_ASSERT(!upb_Map_IsFrozen(map)); upb_StringView k = _upb_map_tokey(key, key_size); return upb_strtable_remove2(&map->table, k.data, k.size, val); @@ -134,7 +134,7 @@ UPB_INLINE upb_MapInsertStatus _upb_Map_Insert(struct upb_Map* map, const void* key, size_t key_size, void* val, size_t val_size, upb_Arena* a) { - UPB_ASSERT(!UPB_PRIVATE(_upb_Map_IsFrozen)(map)); + UPB_ASSERT(!upb_Map_IsFrozen(map)); upb_StringView strkey = _upb_map_tokey(key, key_size); upb_value tabval = {0}; diff --git a/upb/message/internal/tagged_ptr.h b/upb/message/internal/tagged_ptr.h index 1e8ac7d095..47af51852e 100644 --- a/upb/message/internal/tagged_ptr.h +++ b/upb/message/internal/tagged_ptr.h @@ -26,7 +26,7 @@ UPB_PRIVATE(_upb_TaggedMessagePtr_Pack)(struct upb_Message* ptr, bool empty) { return (uintptr_t)ptr | (empty ? 1 : 0); } -UPB_INLINE bool UPB_PRIVATE(_upb_TaggedMessagePtr_IsEmpty)(uintptr_t ptr) { +UPB_API_INLINE bool upb_TaggedMessagePtr_IsEmpty(uintptr_t ptr) { return ptr & 1; } @@ -35,15 +35,15 @@ UPB_INLINE struct upb_Message* UPB_PRIVATE(_upb_TaggedMessagePtr_GetMessage)( return (struct upb_Message*)(ptr & ~(uintptr_t)1); } -UPB_INLINE struct upb_Message* UPB_PRIVATE( - _upb_TaggedMessagePtr_GetNonEmptyMessage)(uintptr_t ptr) { - UPB_ASSERT(!UPB_PRIVATE(_upb_TaggedMessagePtr_IsEmpty)(ptr)); +UPB_API_INLINE struct upb_Message* upb_TaggedMessagePtr_GetNonEmptyMessage( + uintptr_t ptr) { + UPB_ASSERT(!upb_TaggedMessagePtr_IsEmpty(ptr)); return UPB_PRIVATE(_upb_TaggedMessagePtr_GetMessage)(ptr); } UPB_INLINE struct upb_Message* UPB_PRIVATE( _upb_TaggedMessagePtr_GetEmptyMessage)(uintptr_t ptr) { - UPB_ASSERT(UPB_PRIVATE(_upb_TaggedMessagePtr_IsEmpty)(ptr)); + UPB_ASSERT(upb_TaggedMessagePtr_IsEmpty(ptr)); return UPB_PRIVATE(_upb_TaggedMessagePtr_GetMessage)(ptr); } diff --git a/upb/message/internal/types.h b/upb/message/internal/types.h index 1937edc488..7039fc9784 100644 --- a/upb/message/internal/types.h +++ b/upb/message/internal/types.h @@ -22,13 +22,16 @@ struct upb_Message { }; }; +#ifdef __cplusplus +extern "C" { +#endif + UPB_INLINE void UPB_PRIVATE(_upb_Message_ShallowFreeze)( struct upb_Message* msg) { msg->UPB_OPAQUE(internal) |= 1ULL; } -UPB_INLINE bool UPB_PRIVATE(_upb_Message_IsFrozen)( - const struct upb_Message* msg) { +UPB_API_INLINE bool upb_Message_IsFrozen(const struct upb_Message* msg) { return (msg->UPB_OPAQUE(internal) & 1ULL) != 0; } @@ -40,10 +43,14 @@ UPB_INLINE struct upb_Message_Internal* UPB_PRIVATE(_upb_Message_GetInternal)( UPB_INLINE void UPB_PRIVATE(_upb_Message_SetInternal)( struct upb_Message* msg, struct upb_Message_Internal* internal) { - UPB_ASSERT(!UPB_PRIVATE(_upb_Message_IsFrozen)(msg)); + UPB_ASSERT(!upb_Message_IsFrozen(msg)); msg->UPB_OPAQUE(internal) = (uintptr_t)internal; } +#ifdef __cplusplus +} /* extern "C" */ +#endif + #undef UPB_OPAQUE #include "upb/port/undef.inc" diff --git a/upb/message/map.h b/upb/message/map.h index 5cb1e8fed5..996bd6d502 100644 --- a/upb/message/map.h +++ b/upb/message/map.h @@ -77,7 +77,7 @@ UPB_INLINE bool upb_Map_Delete2(upb_Map* map, upb_MessageValue key, // ... // } -#define kUpb_Map_Begin ((size_t)-1) +#define kUpb_Map_Begin ((size_t) - 1) // Advances to the next entry. Returns false if no more entries are present. // Otherwise returns true and populates both *key and *value. @@ -118,9 +118,7 @@ UPB_API upb_MessageValue upb_MapIterator_Value(const upb_Map* map, size_t iter); UPB_API void upb_Map_Freeze(upb_Map* map, const upb_MiniTable* m); // Returns whether a map has been frozen. -UPB_API_INLINE bool upb_Map_IsFrozen(const upb_Map* map) { - return UPB_PRIVATE(_upb_Map_IsFrozen)(map); -} +UPB_API_INLINE bool upb_Map_IsFrozen(const upb_Map* map); #ifdef __cplusplus } /* extern "C" */ diff --git a/upb/message/message.h b/upb/message/message.h index 920a28201f..114aefb0a1 100644 --- a/upb/message/message.h +++ b/upb/message/message.h @@ -43,9 +43,7 @@ size_t upb_Message_ExtensionCount(const upb_Message* msg); UPB_API void upb_Message_Freeze(upb_Message* msg, const upb_MiniTable* m); // Returns whether a message has been frozen. -UPB_API_INLINE bool upb_Message_IsFrozen(const upb_Message* msg) { - return UPB_PRIVATE(_upb_Message_IsFrozen)(msg); -} +UPB_API_INLINE bool upb_Message_IsFrozen(const upb_Message* msg); #ifdef __cplusplus } /* extern "C" */ diff --git a/upb/message/tagged_ptr.h b/upb/message/tagged_ptr.h index f2e1bfd3b6..8d26b6ec3b 100644 --- a/upb/message/tagged_ptr.h +++ b/upb/message/tagged_ptr.h @@ -34,14 +34,10 @@ extern "C" { // Users who enable unlinked sub-messages must use this to test whether a // message is empty before accessing it. If a message is empty, it must be // first promoted using the interfaces in message/promote.h. -UPB_INLINE bool upb_TaggedMessagePtr_IsEmpty(upb_TaggedMessagePtr ptr) { - return UPB_PRIVATE(_upb_TaggedMessagePtr_IsEmpty)(ptr); -} - -UPB_INLINE upb_Message* upb_TaggedMessagePtr_GetNonEmptyMessage( - upb_TaggedMessagePtr ptr) { - return UPB_PRIVATE(_upb_TaggedMessagePtr_GetNonEmptyMessage)(ptr); -} +UPB_API_INLINE bool upb_TaggedMessagePtr_IsEmpty(upb_TaggedMessagePtr ptr); + +UPB_API_INLINE upb_Message* upb_TaggedMessagePtr_GetNonEmptyMessage( + upb_TaggedMessagePtr ptr); #ifdef __cplusplus } /* extern "C" */ diff --git a/upb/mini_table/enum.h b/upb/mini_table/enum.h index cad31ec253..b6be19f181 100644 --- a/upb/mini_table/enum.h +++ b/upb/mini_table/enum.h @@ -22,10 +22,8 @@ extern "C" { #endif // Validates enum value against range defined by enum mini table. -UPB_INLINE bool upb_MiniTableEnum_CheckValue(const upb_MiniTableEnum* e, - uint32_t val) { - return UPB_PRIVATE(_upb_MiniTableEnum_CheckValue)(e, val); -} +UPB_API_INLINE bool upb_MiniTableEnum_CheckValue(const upb_MiniTableEnum* e, + uint32_t val); #ifdef __cplusplus } /* extern "C" */ diff --git a/upb/mini_table/extension.h b/upb/mini_table/extension.h index 891f906b69..a15b98aeab 100644 --- a/upb/mini_table/extension.h +++ b/upb/mini_table/extension.h @@ -24,24 +24,16 @@ extern "C" { #endif UPB_API_INLINE upb_CType -upb_MiniTableExtension_CType(const upb_MiniTableExtension* e) { - return UPB_PRIVATE(_upb_MiniTableExtension_CType)(e); -} +upb_MiniTableExtension_CType(const upb_MiniTableExtension* e); UPB_API_INLINE uint32_t -upb_MiniTableExtension_Number(const upb_MiniTableExtension* e) { - return UPB_PRIVATE(_upb_MiniTableExtension_Number)(e); -} +upb_MiniTableExtension_Number(const upb_MiniTableExtension* e); UPB_API_INLINE const upb_MiniTable* upb_MiniTableExtension_GetSubMessage( - const upb_MiniTableExtension* e) { - return UPB_PRIVATE(_upb_MiniTableExtension_GetSubMessage)(e); -} + const upb_MiniTableExtension* e); UPB_API_INLINE void upb_MiniTableExtension_SetSubMessage( - upb_MiniTableExtension* e, const upb_MiniTable* m) { - UPB_PRIVATE(_upb_MiniTableExtension_SetSubMessage)(e, m); -} + upb_MiniTableExtension* e, const upb_MiniTable* m); #ifdef __cplusplus } /* extern "C" */ diff --git a/upb/mini_table/field.h b/upb/mini_table/field.h index 1df96cecc3..dcf9ed3120 100644 --- a/upb/mini_table/field.h +++ b/upb/mini_table/field.h @@ -22,58 +22,32 @@ typedef struct upb_MiniTableField upb_MiniTableField; extern "C" { #endif -UPB_API_INLINE upb_CType upb_MiniTableField_CType(const upb_MiniTableField* f) { - return UPB_PRIVATE(_upb_MiniTableField_CType)(f); -} +UPB_API_INLINE upb_CType upb_MiniTableField_CType(const upb_MiniTableField* f); -UPB_API_INLINE bool upb_MiniTableField_HasPresence( - const upb_MiniTableField* f) { - return UPB_PRIVATE(_upb_MiniTableField_HasPresence)(f); -} +UPB_API_INLINE bool upb_MiniTableField_HasPresence(const upb_MiniTableField* f); -UPB_API_INLINE bool upb_MiniTableField_IsArray(const upb_MiniTableField* f) { - return UPB_PRIVATE(_upb_MiniTableField_IsArray)(f); -} +UPB_API_INLINE bool upb_MiniTableField_IsArray(const upb_MiniTableField* f); UPB_API_INLINE bool upb_MiniTableField_IsClosedEnum( - const upb_MiniTableField* f) { - return UPB_PRIVATE(_upb_MiniTableField_IsClosedEnum)(f); -} + const upb_MiniTableField* f); -UPB_API_INLINE bool upb_MiniTableField_IsExtension( - const upb_MiniTableField* f) { - return UPB_PRIVATE(_upb_MiniTableField_IsExtension)(f); -} +UPB_API_INLINE bool upb_MiniTableField_IsExtension(const upb_MiniTableField* f); -UPB_API_INLINE bool upb_MiniTableField_IsInOneof(const upb_MiniTableField* f) { - return UPB_PRIVATE(_upb_MiniTableField_IsInOneof)(f); -} +UPB_API_INLINE bool upb_MiniTableField_IsInOneof(const upb_MiniTableField* f); -UPB_API_INLINE bool upb_MiniTableField_IsMap(const upb_MiniTableField* f) { - return UPB_PRIVATE(_upb_MiniTableField_IsMap)(f); -} +UPB_API_INLINE bool upb_MiniTableField_IsMap(const upb_MiniTableField* f); -UPB_API_INLINE bool upb_MiniTableField_IsPacked(const upb_MiniTableField* f) { - return UPB_PRIVATE(_upb_MiniTableField_IsPacked)(f); -} +UPB_API_INLINE bool upb_MiniTableField_IsPacked(const upb_MiniTableField* f); -UPB_API_INLINE bool upb_MiniTableField_IsScalar(const upb_MiniTableField* f) { - return UPB_PRIVATE(_upb_MiniTableField_IsScalar)(f); -} +UPB_API_INLINE bool upb_MiniTableField_IsScalar(const upb_MiniTableField* f); UPB_API_INLINE bool upb_MiniTableField_IsSubMessage( - const upb_MiniTableField* f) { - return UPB_PRIVATE(_upb_MiniTableField_IsSubMessage)(f); -} + const upb_MiniTableField* f); -UPB_API_INLINE uint32_t upb_MiniTableField_Number(const upb_MiniTableField* f) { - return UPB_PRIVATE(_upb_MiniTableField_Number)(f); -} +UPB_API_INLINE uint32_t upb_MiniTableField_Number(const upb_MiniTableField* f); UPB_API_INLINE upb_FieldType -upb_MiniTableField_Type(const upb_MiniTableField* f) { - return UPB_PRIVATE(_upb_MiniTableField_Type)(f); -} +upb_MiniTableField_Type(const upb_MiniTableField* f); #ifdef __cplusplus } /* extern "C" */ diff --git a/upb/mini_table/file.h b/upb/mini_table/file.h index bc109eb0eb..07e844afff 100644 --- a/upb/mini_table/file.h +++ b/upb/mini_table/file.h @@ -23,32 +23,19 @@ extern "C" { #endif UPB_API_INLINE const upb_MiniTableEnum* upb_MiniTableFile_Enum( - const upb_MiniTableFile* f, int i) { - return UPB_PRIVATE(_upb_MiniTableFile_Enum)(f, i); -} + const upb_MiniTableFile* f, int i); -UPB_API_INLINE int upb_MiniTableFile_EnumCount(const upb_MiniTableFile* f) { - return UPB_PRIVATE(_upb_MiniTableFile_EnumCount)(f); -} +UPB_API_INLINE int upb_MiniTableFile_EnumCount(const upb_MiniTableFile* f); UPB_API_INLINE const upb_MiniTableExtension* upb_MiniTableFile_Extension( - const upb_MiniTableFile* f, int i) { - return UPB_PRIVATE(_upb_MiniTableFile_Extension)(f, i); -} + const upb_MiniTableFile* f, int i); -UPB_API_INLINE int upb_MiniTableFile_ExtensionCount( - const upb_MiniTableFile* f) { - return UPB_PRIVATE(_upb_MiniTableFile_ExtensionCount)(f); -} +UPB_API_INLINE int upb_MiniTableFile_ExtensionCount(const upb_MiniTableFile* f); UPB_API_INLINE const upb_MiniTable* upb_MiniTableFile_Message( - const upb_MiniTableFile* f, int i) { - return UPB_PRIVATE(_upb_MiniTableFile_Message)(f, i); -} + const upb_MiniTableFile* f, int i); -UPB_API_INLINE int upb_MiniTableFile_MessageCount(const upb_MiniTableFile* f) { - return UPB_PRIVATE(_upb_MiniTableFile_MessageCount)(f); -} +UPB_API_INLINE int upb_MiniTableFile_MessageCount(const upb_MiniTableFile* f); #ifdef __cplusplus } /* extern "C" */ diff --git a/upb/mini_table/internal/enum.h b/upb/mini_table/internal/enum.h index 6f8bec8d1e..87fae6c5ef 100644 --- a/upb/mini_table/internal/enum.h +++ b/upb/mini_table/internal/enum.h @@ -23,7 +23,7 @@ struct upb_MiniTableEnum { extern "C" { #endif -UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableEnum_CheckValue)( +UPB_API_INLINE bool upb_MiniTableEnum_CheckValue( const struct upb_MiniTableEnum* e, uint32_t val) { if (UPB_LIKELY(val < 64)) { const uint64_t mask = diff --git a/upb/mini_table/internal/extension.h b/upb/mini_table/internal/extension.h index ed69e4353d..e326f99997 100644 --- a/upb/mini_table/internal/extension.h +++ b/upb/mini_table/internal/extension.h @@ -10,6 +10,7 @@ #include +#include "upb/base/descriptor_constants.h" #include "upb/mini_table/internal/field.h" #include "upb/mini_table/internal/sub.h" @@ -28,23 +29,22 @@ struct upb_MiniTableExtension { extern "C" { #endif -UPB_INLINE upb_CType UPB_PRIVATE(_upb_MiniTableExtension_CType)( - const struct upb_MiniTableExtension* e) { - return UPB_PRIVATE(_upb_MiniTableField_CType)(&e->UPB_PRIVATE(field)); +UPB_API_INLINE upb_CType +upb_MiniTableExtension_CType(const struct upb_MiniTableExtension* e) { + return upb_MiniTableField_CType(&e->UPB_PRIVATE(field)); } -UPB_INLINE uint32_t UPB_PRIVATE(_upb_MiniTableExtension_Number)( - const struct upb_MiniTableExtension* e) { +UPB_API_INLINE uint32_t +upb_MiniTableExtension_Number(const struct upb_MiniTableExtension* e) { return e->UPB_PRIVATE(field).UPB_ONLYBITS(number); } -UPB_INLINE const struct upb_MiniTable* UPB_PRIVATE( - _upb_MiniTableExtension_GetSubMessage)( +UPB_API_INLINE const struct upb_MiniTable* upb_MiniTableExtension_GetSubMessage( const struct upb_MiniTableExtension* e) { - return UPB_PRIVATE(_upb_MiniTableSub_Message)(e->UPB_PRIVATE(sub)); + return upb_MiniTableSub_Message(e->UPB_PRIVATE(sub)); } -UPB_INLINE void UPB_PRIVATE(_upb_MiniTableExtension_SetSubMessage)( +UPB_API_INLINE void upb_MiniTableExtension_SetSubMessage( struct upb_MiniTableExtension* e, const struct upb_MiniTable* m) { e->UPB_PRIVATE(sub).UPB_PRIVATE(submsg) = m; } diff --git a/upb/mini_table/internal/field.h b/upb/mini_table/internal/field.h index 166463a886..d1ee25b156 100644 --- a/upb/mini_table/internal/field.h +++ b/upb/mini_table/internal/field.h @@ -33,7 +33,7 @@ struct upb_MiniTableField { uint8_t UPB_ONLYBITS(mode); }; -#define kUpb_NoSub ((uint16_t)-1) +#define kUpb_NoSub ((uint16_t) - 1) typedef enum { kUpb_FieldMode_Map = 0, @@ -84,17 +84,17 @@ UPB_PRIVATE(_upb_MiniTableField_GetRep)(const struct upb_MiniTableField* f) { return (upb_FieldRep)(f->UPB_ONLYBITS(mode) >> kUpb_FieldRep_Shift); } -UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsArray)( +UPB_API_INLINE bool upb_MiniTableField_IsArray( const struct upb_MiniTableField* f) { return UPB_PRIVATE(_upb_MiniTableField_Mode)(f) == kUpb_FieldMode_Array; } -UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsMap)( +UPB_API_INLINE bool upb_MiniTableField_IsMap( const struct upb_MiniTableField* f) { return UPB_PRIVATE(_upb_MiniTableField_Mode)(f) == kUpb_FieldMode_Map; } -UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsScalar)( +UPB_API_INLINE bool upb_MiniTableField_IsScalar( const struct upb_MiniTableField* f) { return UPB_PRIVATE(_upb_MiniTableField_Mode)(f) == kUpb_FieldMode_Scalar; } @@ -104,18 +104,18 @@ UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsAlternate)( return (f->UPB_ONLYBITS(mode) & kUpb_LabelFlags_IsAlternate) != 0; } -UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsExtension)( +UPB_API_INLINE bool upb_MiniTableField_IsExtension( const struct upb_MiniTableField* f) { return (f->UPB_ONLYBITS(mode) & kUpb_LabelFlags_IsExtension) != 0; } -UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsPacked)( +UPB_API_INLINE bool upb_MiniTableField_IsPacked( const struct upb_MiniTableField* f) { return (f->UPB_ONLYBITS(mode) & kUpb_LabelFlags_IsPacked) != 0; } -UPB_INLINE upb_FieldType -UPB_PRIVATE(_upb_MiniTableField_Type)(const struct upb_MiniTableField* f) { +UPB_API_INLINE upb_FieldType +upb_MiniTableField_Type(const struct upb_MiniTableField* f) { const upb_FieldType type = (upb_FieldType)f->UPB_PRIVATE(descriptortype); if (UPB_PRIVATE(_upb_MiniTableField_IsAlternate)(f)) { if (type == kUpb_FieldType_Int32) return kUpb_FieldType_Enum; @@ -125,9 +125,9 @@ UPB_PRIVATE(_upb_MiniTableField_Type)(const struct upb_MiniTableField* f) { return type; } -UPB_INLINE upb_CType -UPB_PRIVATE(_upb_MiniTableField_CType)(const struct upb_MiniTableField* f) { - return upb_FieldType_CType(UPB_PRIVATE(_upb_MiniTableField_Type)(f)); +UPB_API_INLINE +upb_CType upb_MiniTableField_CType(const struct upb_MiniTableField* f) { + return upb_FieldType_CType(upb_MiniTableField_Type(f)); } UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_HasHasbit)( @@ -149,33 +149,33 @@ UPB_INLINE size_t UPB_PRIVATE(_upb_MiniTableField_HasbitOffset)( return index / 8; } -UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsClosedEnum)( +UPB_API_INLINE bool upb_MiniTableField_IsClosedEnum( const struct upb_MiniTableField* f) { return f->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Enum; } -UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsInOneof)( +UPB_INLINE bool upb_MiniTableField_IsInOneof( const struct upb_MiniTableField* f) { return f->presence < 0; } -UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsSubMessage)( +UPB_API_INLINE bool upb_MiniTableField_IsSubMessage( const struct upb_MiniTableField* f) { return f->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Message || f->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Group; } -UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_HasPresence)( +UPB_API_INLINE bool upb_MiniTableField_HasPresence( const struct upb_MiniTableField* f) { - if (UPB_PRIVATE(_upb_MiniTableField_IsExtension)(f)) { - return UPB_PRIVATE(_upb_MiniTableField_IsScalar)(f); + if (upb_MiniTableField_IsExtension(f)) { + return upb_MiniTableField_IsScalar(f); } else { return f->presence != 0; } } -UPB_INLINE uint32_t -UPB_PRIVATE(_upb_MiniTableField_Number)(const struct upb_MiniTableField* f) { +UPB_API_INLINE uint32_t +upb_MiniTableField_Number(const struct upb_MiniTableField* f) { return f->UPB_ONLYBITS(number); } @@ -186,7 +186,7 @@ UPB_PRIVATE(_upb_MiniTableField_Offset)(const struct upb_MiniTableField* f) { UPB_INLINE size_t UPB_PRIVATE(_upb_MiniTableField_OneofOffset)( const struct upb_MiniTableField* f) { - UPB_ASSERT(UPB_PRIVATE(_upb_MiniTableField_IsInOneof)(f)); + UPB_ASSERT(upb_MiniTableField_IsInOneof(f)); return ~(ptrdiff_t)f->presence; } @@ -194,7 +194,7 @@ UPB_INLINE void UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)( const struct upb_MiniTableField* f) { UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) == kUpb_FieldRep_NativePointer); - UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_IsArray)(f)); + UPB_ASSUME(upb_MiniTableField_IsArray(f)); UPB_ASSUME(f->presence == 0); } @@ -202,13 +202,13 @@ UPB_INLINE void UPB_PRIVATE(_upb_MiniTableField_CheckIsMap)( const struct upb_MiniTableField* f) { UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) == kUpb_FieldRep_NativePointer); - UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_IsMap)(f)); + UPB_ASSUME(upb_MiniTableField_IsMap(f)); UPB_ASSUME(f->presence == 0); } UPB_INLINE size_t UPB_PRIVATE(_upb_MiniTableField_ElemSizeLg2)( const struct upb_MiniTableField* f) { - const upb_FieldType field_type = UPB_PRIVATE(_upb_MiniTableField_Type)(f); + const upb_FieldType field_type = upb_MiniTableField_Type(f); return UPB_PRIVATE(_upb_FieldType_SizeLg2)(field_type); } diff --git a/upb/mini_table/internal/file.h b/upb/mini_table/internal/file.h index 0afabcf1b3..0e39ec483a 100644 --- a/upb/mini_table/internal/file.h +++ b/upb/mini_table/internal/file.h @@ -24,34 +24,34 @@ struct upb_MiniTableFile { extern "C" { #endif -UPB_INLINE int UPB_PRIVATE(_upb_MiniTableFile_EnumCount)( +UPB_API_INLINE int upb_MiniTableFile_EnumCount( const struct upb_MiniTableFile* f) { return f->UPB_PRIVATE(enum_count); } -UPB_INLINE int UPB_PRIVATE(_upb_MiniTableFile_ExtensionCount)( +UPB_API_INLINE int upb_MiniTableFile_ExtensionCount( const struct upb_MiniTableFile* f) { return f->UPB_PRIVATE(ext_count); } -UPB_INLINE int UPB_PRIVATE(_upb_MiniTableFile_MessageCount)( +UPB_API_INLINE int upb_MiniTableFile_MessageCount( const struct upb_MiniTableFile* f) { return f->UPB_PRIVATE(msg_count); } -UPB_INLINE const struct upb_MiniTableEnum* UPB_PRIVATE(_upb_MiniTableFile_Enum)( +UPB_API_INLINE const struct upb_MiniTableEnum* upb_MiniTableFile_Enum( const struct upb_MiniTableFile* f, int i) { UPB_ASSERT(i < f->UPB_PRIVATE(enum_count)); return f->UPB_PRIVATE(enums)[i]; } -UPB_INLINE const struct upb_MiniTableExtension* UPB_PRIVATE( - _upb_MiniTableFile_Extension)(const struct upb_MiniTableFile* f, int i) { +UPB_API_INLINE const struct upb_MiniTableExtension* upb_MiniTableFile_Extension( + const struct upb_MiniTableFile* f, int i) { UPB_ASSERT(i < f->UPB_PRIVATE(ext_count)); return f->UPB_PRIVATE(exts)[i]; } -UPB_INLINE const struct upb_MiniTable* UPB_PRIVATE(_upb_MiniTableFile_Message)( +UPB_API_INLINE const struct upb_MiniTable* upb_MiniTableFile_Message( const struct upb_MiniTableFile* f, int i) { UPB_ASSERT(i < f->UPB_PRIVATE(msg_count)); return f->UPB_PRIVATE(msgs)[i]; diff --git a/upb/mini_table/internal/message.h b/upb/mini_table/internal/message.h index 20bd1b85d3..2651ea3868 100644 --- a/upb/mini_table/internal/message.h +++ b/upb/mini_table/internal/message.h @@ -75,8 +75,7 @@ UPB_INLINE const struct upb_MiniTable* UPB_PRIVATE(_upb_MiniTable_Empty)(void) { return &UPB_PRIVATE(_kUpb_MiniTable_Empty); } -UPB_INLINE int UPB_PRIVATE(_upb_MiniTable_FieldCount)( - const struct upb_MiniTable* m) { +UPB_API_INLINE int upb_MiniTable_FieldCount(const struct upb_MiniTable* m) { return m->UPB_ONLYBITS(field_count); } @@ -87,8 +86,8 @@ UPB_INLINE bool UPB_PRIVATE(_upb_MiniTable_IsEmpty)( return m == &UPB_PRIVATE(_kUpb_MiniTable_Empty); } -UPB_INLINE const struct upb_MiniTableField* UPB_PRIVATE( - _upb_MiniTable_GetFieldByIndex)(const struct upb_MiniTable* m, uint32_t i) { +UPB_API_INLINE const struct upb_MiniTableField* upb_MiniTable_GetFieldByIndex( + const struct upb_MiniTable* m, uint32_t i) { return &m->UPB_ONLYBITS(fields)[i]; } @@ -97,54 +96,50 @@ UPB_INLINE const union upb_MiniTableSub* UPB_PRIVATE( return &m->UPB_PRIVATE(subs)[i]; } -UPB_INLINE const struct upb_MiniTable* UPB_PRIVATE( - _upb_MiniTable_GetSubMessageTable)(const struct upb_MiniTable* m, - const struct upb_MiniTableField* f) { - UPB_ASSERT(UPB_PRIVATE(_upb_MiniTableField_CType)(f) == kUpb_CType_Message); - const struct upb_MiniTable* ret = UPB_PRIVATE(_upb_MiniTableSub_Message)( +UPB_API_INLINE const struct upb_MiniTable* upb_MiniTable_GetSubMessageTable( + const struct upb_MiniTable* m, const struct upb_MiniTableField* f) { + UPB_ASSERT(upb_MiniTableField_CType(f) == kUpb_CType_Message); + const struct upb_MiniTable* ret = upb_MiniTableSub_Message( m->UPB_PRIVATE(subs)[f->UPB_PRIVATE(submsg_index)]); UPB_ASSUME(ret); return UPB_PRIVATE(_upb_MiniTable_IsEmpty)(ret) ? NULL : ret; } -UPB_INLINE const struct upb_MiniTable* UPB_PRIVATE(_upb_MiniTable_SubMessage)( +UPB_API_INLINE const struct upb_MiniTable* upb_MiniTable_SubMessage( const struct upb_MiniTable* m, const struct upb_MiniTableField* f) { - if (UPB_PRIVATE(_upb_MiniTableField_CType)(f) != kUpb_CType_Message) { + if (upb_MiniTableField_CType(f) != kUpb_CType_Message) { return NULL; } - return UPB_PRIVATE(_upb_MiniTableSub_Message)( + return upb_MiniTableSub_Message( m->UPB_PRIVATE(subs)[f->UPB_PRIVATE(submsg_index)]); } -UPB_INLINE const struct upb_MiniTableEnum* UPB_PRIVATE( - _upb_MiniTable_GetSubEnumTable)(const struct upb_MiniTable* m, - const struct upb_MiniTableField* f) { - UPB_ASSERT(UPB_PRIVATE(_upb_MiniTableField_CType)(f) == kUpb_CType_Enum); - return UPB_PRIVATE(_upb_MiniTableSub_Enum)( +UPB_API_INLINE const struct upb_MiniTableEnum* upb_MiniTable_GetSubEnumTable( + const struct upb_MiniTable* m, const struct upb_MiniTableField* f) { + UPB_ASSERT(upb_MiniTableField_CType(f) == kUpb_CType_Enum); + return upb_MiniTableSub_Enum( m->UPB_PRIVATE(subs)[f->UPB_PRIVATE(submsg_index)]); } -UPB_INLINE const struct upb_MiniTableField* UPB_PRIVATE(_upb_MiniTable_MapKey)( +UPB_API_INLINE const struct upb_MiniTableField* upb_MiniTable_MapKey( const struct upb_MiniTable* m) { - UPB_ASSERT(UPB_PRIVATE(_upb_MiniTable_FieldCount)(m) == 2); - const struct upb_MiniTableField* f = - UPB_PRIVATE(_upb_MiniTable_GetFieldByIndex)(m, 0); - UPB_ASSERT(UPB_PRIVATE(_upb_MiniTableField_Number)(f) == 1); + UPB_ASSERT(upb_MiniTable_FieldCount(m) == 2); + const struct upb_MiniTableField* f = upb_MiniTable_GetFieldByIndex(m, 0); + UPB_ASSERT(upb_MiniTableField_Number(f) == 1); return f; } -UPB_INLINE const struct upb_MiniTableField* UPB_PRIVATE( - _upb_MiniTable_MapValue)(const struct upb_MiniTable* m) { - UPB_ASSERT(UPB_PRIVATE(_upb_MiniTable_FieldCount)(m) == 2); - const struct upb_MiniTableField* f = - UPB_PRIVATE(_upb_MiniTable_GetFieldByIndex)(m, 1); - UPB_ASSERT(UPB_PRIVATE(_upb_MiniTableField_Number)(f) == 2); +UPB_API_INLINE const struct upb_MiniTableField* upb_MiniTable_MapValue( + const struct upb_MiniTable* m) { + UPB_ASSERT(upb_MiniTable_FieldCount(m) == 2); + const struct upb_MiniTableField* f = upb_MiniTable_GetFieldByIndex(m, 1); + UPB_ASSERT(upb_MiniTableField_Number(f) == 2); return f; } -UPB_INLINE bool UPB_PRIVATE(_upb_MiniTable_MessageFieldIsLinked)( +UPB_API_INLINE bool upb_MiniTable_MessageFieldIsLinked( const struct upb_MiniTable* m, const struct upb_MiniTableField* f) { - return UPB_PRIVATE(_upb_MiniTable_GetSubMessageTable)(m, f) != NULL; + return upb_MiniTable_GetSubMessageTable(m, f) != NULL; } // Computes a bitmask in which the |m->required_count| lowest bits are set. diff --git a/upb/mini_table/internal/sub.h b/upb/mini_table/internal/sub.h index 99e35bd33c..967b557dda 100644 --- a/upb/mini_table/internal/sub.h +++ b/upb/mini_table/internal/sub.h @@ -20,26 +20,26 @@ union upb_MiniTableSub { extern "C" { #endif -UPB_INLINE union upb_MiniTableSub UPB_PRIVATE(_upb_MiniTableSub_FromEnum)( +UPB_API_INLINE union upb_MiniTableSub upb_MiniTableSub_FromEnum( const struct upb_MiniTableEnum* subenum) { union upb_MiniTableSub out; out.UPB_PRIVATE(subenum) = subenum; return out; } -UPB_INLINE union upb_MiniTableSub UPB_PRIVATE(_upb_MiniTableSub_FromMessage)( +UPB_API_INLINE union upb_MiniTableSub upb_MiniTableSub_FromMessage( const struct upb_MiniTable* submsg) { union upb_MiniTableSub out; out.UPB_PRIVATE(submsg) = submsg; return out; } -UPB_INLINE const struct upb_MiniTableEnum* UPB_PRIVATE(_upb_MiniTableSub_Enum)( +UPB_API_INLINE const struct upb_MiniTableEnum* upb_MiniTableSub_Enum( const union upb_MiniTableSub sub) { return sub.UPB_PRIVATE(subenum); } -UPB_INLINE const struct upb_MiniTable* UPB_PRIVATE(_upb_MiniTableSub_Message)( +UPB_API_INLINE const struct upb_MiniTable* upb_MiniTableSub_Message( const union upb_MiniTableSub sub) { return sub.UPB_PRIVATE(submsg); } diff --git a/upb/mini_table/message.h b/upb/mini_table/message.h index 486c6d7c53..c5ddb3f785 100644 --- a/upb/mini_table/message.h +++ b/upb/mini_table/message.h @@ -25,51 +25,35 @@ UPB_API const upb_MiniTableField* upb_MiniTable_FindFieldByNumber( const upb_MiniTable* m, uint32_t number); UPB_API_INLINE const upb_MiniTableField* upb_MiniTable_GetFieldByIndex( - const upb_MiniTable* m, uint32_t index) { - return UPB_PRIVATE(_upb_MiniTable_GetFieldByIndex)(m, index); -} + const upb_MiniTable* m, uint32_t index); -UPB_API_INLINE int upb_MiniTable_FieldCount(const upb_MiniTable* m) { - return UPB_PRIVATE(_upb_MiniTable_FieldCount)(m); -} +UPB_API_INLINE int upb_MiniTable_FieldCount(const upb_MiniTable* m); // DEPRECATED: use upb_MiniTable_SubMessage() instead // Returns the MiniTable for a message field, NULL if the field is unlinked. UPB_API_INLINE const upb_MiniTable* upb_MiniTable_GetSubMessageTable( - const upb_MiniTable* m, const upb_MiniTableField* f) { - return UPB_PRIVATE(_upb_MiniTable_GetSubMessageTable)(m, f); -} + const upb_MiniTable* m, const upb_MiniTableField* f); // Returns the MiniTable for a message field if it is a submessage. UPB_API_INLINE const upb_MiniTable* upb_MiniTable_SubMessage( - const upb_MiniTable* m, const upb_MiniTableField* f) { - return UPB_PRIVATE(_upb_MiniTable_SubMessage)(m, f); -} + const upb_MiniTable* m, const upb_MiniTableField* f); // Returns the MiniTableEnum for a message field, NULL if the field is unlinked. UPB_API_INLINE const upb_MiniTableEnum* upb_MiniTable_GetSubEnumTable( - const upb_MiniTable* m, const upb_MiniTableField* f) { - return UPB_PRIVATE(_upb_MiniTable_GetSubEnumTable)(m, f); -} + const upb_MiniTable* m, const upb_MiniTableField* f); // Returns the MiniTableField for the key of a map. UPB_API_INLINE const upb_MiniTableField* upb_MiniTable_MapKey( - const upb_MiniTable* m) { - return UPB_PRIVATE(_upb_MiniTable_MapKey)(m); -} + const upb_MiniTable* m); // Returns the MiniTableField for the value of a map. UPB_API_INLINE const upb_MiniTableField* upb_MiniTable_MapValue( - const upb_MiniTable* m) { - return UPB_PRIVATE(_upb_MiniTable_MapValue)(m); -} + const upb_MiniTable* m); // Returns true if this MiniTable field is linked to a MiniTable for the // sub-message. UPB_API_INLINE bool upb_MiniTable_MessageFieldIsLinked( - const upb_MiniTable* m, const upb_MiniTableField* f) { - return UPB_PRIVATE(_upb_MiniTable_MessageFieldIsLinked)(m, f); -} + const upb_MiniTable* m, const upb_MiniTableField* f); // If this field is in a oneof, returns the first field in the oneof. // diff --git a/upb/mini_table/sub.h b/upb/mini_table/sub.h index c2798a18e8..68c1c20f51 100644 --- a/upb/mini_table/sub.h +++ b/upb/mini_table/sub.h @@ -24,26 +24,18 @@ extern "C" { // Constructors UPB_API_INLINE upb_MiniTableSub -upb_MiniTableSub_FromEnum(const upb_MiniTableEnum* subenum) { - return UPB_PRIVATE(_upb_MiniTableSub_FromEnum)(subenum); -} +upb_MiniTableSub_FromEnum(const upb_MiniTableEnum* subenum); UPB_API_INLINE upb_MiniTableSub -upb_MiniTableSub_FromMessage(const upb_MiniTable* submsg) { - return UPB_PRIVATE(_upb_MiniTableSub_FromMessage)(submsg); -} +upb_MiniTableSub_FromMessage(const upb_MiniTable* submsg); // Getters UPB_API_INLINE const upb_MiniTableEnum* upb_MiniTableSub_Enum( - upb_MiniTableSub sub) { - return UPB_PRIVATE(_upb_MiniTableSub_Enum)(sub); -} + upb_MiniTableSub sub); UPB_API_INLINE const upb_MiniTable* upb_MiniTableSub_Message( - upb_MiniTableSub sub) { - return UPB_PRIVATE(_upb_MiniTableSub_Message)(sub); -} + upb_MiniTableSub sub); #ifdef __cplusplus } /* extern "C" */ diff --git a/upb/wire/decode.c b/upb/wire/decode.c index b7a518b4fa..a40131f9c3 100644 --- a/upb/wire/decode.c +++ b/upb/wire/decode.c @@ -704,7 +704,7 @@ static const char* _upb_Decoder_DecodeToSubMessage( // Set presence if necessary. if (UPB_PRIVATE(_upb_MiniTableField_HasHasbit)(field)) { UPB_PRIVATE(_upb_Message_SetHasbit)(msg, field); - } else if (UPB_PRIVATE(_upb_MiniTableField_IsInOneof)(field)) { + } else if (upb_MiniTableField_IsInOneof(field)) { // Oneof case uint32_t* oneof_case = UPB_PRIVATE(_upb_Message_OneofCasePtr)(msg, field); if (op == kUpb_DecodeOp_SubMessage && diff --git a/upb/wire/internal/reader.h b/upb/wire/internal/reader.h index dbe726149d..4a8916b8b6 100644 --- a/upb/wire/internal/reader.h +++ b/upb/wire/internal/reader.h @@ -44,11 +44,11 @@ UPB_FORCEINLINE const char* UPB_PRIVATE(_upb_WireReader_ReadVarint)( return res.ptr; } -UPB_INLINE uint32_t UPB_PRIVATE(_upb_WireReader_GetFieldNumber)(uint32_t tag) { +UPB_API_INLINE uint32_t upb_WireReader_GetFieldNumber(uint32_t tag) { return tag >> kUpb_WireReader_WireTypeBits; } -UPB_INLINE uint8_t UPB_PRIVATE(_upb_WireReader_GetWireType)(uint32_t tag) { +UPB_API_INLINE uint8_t upb_WireReader_GetWireType(uint32_t tag) { return tag & kUpb_WireReader_WireTypeMask; } diff --git a/upb/wire/reader.h b/upb/wire/reader.h index 37ff32ae09..ad029f965d 100644 --- a/upb/wire/reader.h +++ b/upb/wire/reader.h @@ -42,14 +42,10 @@ UPB_FORCEINLINE const char* upb_WireReader_ReadTag(const char* ptr, } // Given a tag, returns the field number. -UPB_INLINE uint32_t upb_WireReader_GetFieldNumber(uint32_t tag) { - return UPB_PRIVATE(_upb_WireReader_GetFieldNumber)(tag); -} +UPB_API_INLINE uint32_t upb_WireReader_GetFieldNumber(uint32_t tag); // Given a tag, returns the wire type. -UPB_INLINE uint8_t upb_WireReader_GetWireType(uint32_t tag) { - return UPB_PRIVATE(_upb_WireReader_GetWireType)(tag); -} +UPB_API_INLINE uint8_t upb_WireReader_GetWireType(uint32_t tag); UPB_INLINE const char* upb_WireReader_ReadVarint(const char* ptr, uint64_t* val) {