Chiebot-Mirror
/
protobuf
mirror of https://github.com/protocolbuffers/protobuf.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

upb: lock down MiniTableField

Browse Source 
PiperOrigin-RevId: 586171362
pull/14827/head
Eric Salo 1 year ago committed by Copybara-Service
parent 9af27995e9
commit 19ef3a58cf
17 changed files with 254 additions and 170 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 109
      upb/message/accessors.h
  2. 12
      upb/message/copy.c
  3. 17
      upb/message/internal/accessors.h
  4. 2
      upb/message/promote.c
  5. 4
      upb/mini_descriptor/decode.c
  6. 8
      upb/mini_descriptor/internal/encode_test.cc
  7. 60
      upb/mini_table/field.h
  8. 116
      upb/mini_table/internal/field.h
  9. 10
      upb/mini_table/message.c
  10. 2
      upb/reflection/BUILD
  11. 12
      upb/reflection/message.c
  12. 6
      upb/wire/decode.c
  13. 7
      upb/wire/encode.c
  14. 1
      upb_generator/BUILD
  15. 9
      upb_generator/common.cc
  16. 10
      upb_generator/protoc-gen-upb.cc
  17. 39
      upb_generator/protoc-gen-upb_minitable.cc

109
upb/message/accessors.h
Unescape View File

@ -105,8 +105,9 @@ UPB_API_INLINE bool upb_Message_GetBool(const upb_Message* msg,
const upb_MiniTableField* field,
bool default_val) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Bool);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_1Byte);
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
kUpb_FieldRep_1Byte);
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
upb_MessageValue def;
def.bool_val = default_val;
return upb_Message_GetField(msg, field, def).bool_val;
@ -116,8 +117,9 @@ UPB_API_INLINE bool upb_Message_SetBool(upb_Message* msg,
const upb_MiniTableField* field,
bool value, upb_Arena* a) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Bool);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_1Byte);
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
kUpb_FieldRep_1Byte);
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
upb_MessageValue val;
val.bool_val = value;
return upb_Message_SetField(msg, field, val, a);
@ -128,8 +130,9 @@ UPB_API_INLINE int32_t upb_Message_GetInt32(const upb_Message* msg,
int32_t default_val) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Int32 ||
upb_MiniTableField_CType(field) == kUpb_CType_Enum);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_4Byte);
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
kUpb_FieldRep_4Byte);
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
upb_MessageValue def;
def.int32_val = default_val;
@ -141,8 +144,9 @@ UPB_API_INLINE bool upb_Message_SetInt32(upb_Message* msg,
int32_t value, upb_Arena* a) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Int32 ||
upb_MiniTableField_CType(field) == kUpb_CType_Enum);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_4Byte);
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
kUpb_FieldRep_4Byte);
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
upb_MessageValue val;
val.int32_val = value;
return upb_Message_SetField(msg, field, val, a);
@ -152,8 +156,9 @@ UPB_API_INLINE uint32_t upb_Message_GetUInt32(const upb_Message* msg,
const upb_MiniTableField* field,
uint32_t default_val) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_UInt32);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_4Byte);
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
kUpb_FieldRep_4Byte);
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
upb_MessageValue def;
def.uint32_val = default_val;
@ -164,8 +169,9 @@ UPB_API_INLINE bool upb_Message_SetUInt32(upb_Message* msg,
const upb_MiniTableField* field,
uint32_t value, upb_Arena* a) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_UInt32);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_4Byte);
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
kUpb_FieldRep_4Byte);
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
upb_MessageValue val;
val.uint32_val = value;
return upb_Message_SetField(msg, field, val, a);
@ -175,8 +181,9 @@ UPB_API_INLINE void upb_Message_SetClosedEnum(
upb_Message* msg, const upb_MiniTable* msg_mini_table,
const upb_MiniTableField* field, int32_t value) {
UPB_ASSERT(upb_MiniTableField_IsClosedEnum(field));
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_4Byte);
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
kUpb_FieldRep_4Byte);
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
UPB_ASSERT(upb_MiniTableEnum_CheckValue(
upb_MiniTable_GetSubEnumTable(msg_mini_table, field), value));
_upb_Message_SetNonExtensionField(msg, field, &value);
@ -186,8 +193,9 @@ UPB_API_INLINE int64_t upb_Message_GetInt64(const upb_Message* msg,
const upb_MiniTableField* field,
int64_t default_val) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Int64);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_8Byte);
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
kUpb_FieldRep_8Byte);
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
upb_MessageValue def;
def.int64_val = default_val;
@ -198,8 +206,9 @@ UPB_API_INLINE bool upb_Message_SetInt64(upb_Message* msg,
const upb_MiniTableField* field,
int64_t value, upb_Arena* a) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Int64);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_8Byte);
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
kUpb_FieldRep_8Byte);
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
upb_MessageValue val;
val.int64_val = value;
return upb_Message_SetField(msg, field, val, a);
@ -209,8 +218,9 @@ UPB_API_INLINE uint64_t upb_Message_GetUInt64(const upb_Message* msg,
const upb_MiniTableField* field,
uint64_t default_val) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_UInt64);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_8Byte);
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
kUpb_FieldRep_8Byte);
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
upb_MessageValue def;
def.uint64_val = default_val;
@ -221,8 +231,9 @@ UPB_API_INLINE bool upb_Message_SetUInt64(upb_Message* msg,
const upb_MiniTableField* field,
uint64_t value, upb_Arena* a) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_UInt64);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_8Byte);
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
kUpb_FieldRep_8Byte);
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
upb_MessageValue val;
val.uint64_val = value;
return upb_Message_SetField(msg, field, val, a);
@ -232,8 +243,9 @@ UPB_API_INLINE float upb_Message_GetFloat(const upb_Message* msg,
const upb_MiniTableField* field,
float default_val) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Float);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_4Byte);
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
kUpb_FieldRep_4Byte);
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
upb_MessageValue def;
def.float_val = default_val;
@ -244,8 +256,9 @@ UPB_API_INLINE bool upb_Message_SetFloat(upb_Message* msg,
const upb_MiniTableField* field,
float value, upb_Arena* a) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Float);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_4Byte);
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
kUpb_FieldRep_4Byte);
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
upb_MessageValue val;
val.float_val = value;
return upb_Message_SetField(msg, field, val, a);
@ -255,8 +268,9 @@ UPB_API_INLINE double upb_Message_GetDouble(const upb_Message* msg,
const upb_MiniTableField* field,
double default_val) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Double);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_8Byte);
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
kUpb_FieldRep_8Byte);
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
upb_MessageValue def;
def.double_val = default_val;
@ -267,8 +281,9 @@ UPB_API_INLINE bool upb_Message_SetDouble(upb_Message* msg,
const upb_MiniTableField* field,
double value, upb_Arena* a) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Double);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_8Byte);
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
kUpb_FieldRep_8Byte);
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
upb_MessageValue val;
val.double_val = value;
return upb_Message_SetField(msg, field, val, a);
@ -279,8 +294,9 @@ upb_Message_GetString(const upb_Message* msg, const upb_MiniTableField* field,
upb_StringView default_val) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_String ||
upb_MiniTableField_CType(field) == kUpb_CType_Bytes);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_StringView);
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
kUpb_FieldRep_StringView);
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
upb_MessageValue def;
def.str_val = default_val;
@ -292,8 +308,9 @@ UPB_API_INLINE bool upb_Message_SetString(upb_Message* msg,
upb_StringView value, upb_Arena* a) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_String ||
upb_MiniTableField_CType(field) == kUpb_CType_Bytes);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_StringView);
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
kUpb_FieldRep_StringView);
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
upb_MessageValue val;
val.str_val = value;
return upb_Message_SetField(msg, field, val, a);
@ -303,9 +320,9 @@ UPB_API_INLINE upb_TaggedMessagePtr upb_Message_GetTaggedMessagePtr(
const upb_Message* msg, const upb_MiniTableField* field,
upb_Message* default_val) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Message);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) ==
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte));
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
upb_TaggedMessagePtr tagged;
_upb_Message_GetNonExtensionField(msg, field, &default_val, &tagged);
return tagged;
@ -326,9 +343,9 @@ UPB_API_INLINE void _upb_Message_SetTaggedMessagePtr(
upb_Message* msg, const upb_MiniTable* mini_table,
const upb_MiniTableField* field, upb_TaggedMessagePtr sub_message) {
UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Message);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) ==
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte));
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
UPB_ASSUME(upb_MiniTableField_IsScalar(field));
UPB_ASSERT(mini_table->subs[field->UPB_PRIVATE(submsg_index)].submsg);
_upb_Message_SetNonExtensionField(msg, field, &sub_message);
}
@ -360,7 +377,7 @@ UPB_API_INLINE upb_Message* upb_Message_GetOrCreateMutableMessage(
UPB_API_INLINE const upb_Array* upb_Message_GetArray(
const upb_Message* msg, const upb_MiniTableField* field) {
_upb_MiniTableField_CheckIsArray(field);
UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(field);
upb_Array* ret;
const upb_Array* default_val = NULL;
_upb_Message_GetNonExtensionField(msg, field, &default_val, &ret);
@ -369,20 +386,20 @@ UPB_API_INLINE const upb_Array* upb_Message_GetArray(
UPB_API_INLINE upb_Array* upb_Message_GetMutableArray(
upb_Message* msg, const upb_MiniTableField* field) {
_upb_MiniTableField_CheckIsArray(field);
UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(field);
return (upb_Array*)upb_Message_GetArray(msg, field);
}
UPB_API_INLINE upb_Array* upb_Message_GetOrCreateMutableArray(
upb_Message* msg, const upb_MiniTableField* field, upb_Arena* arena) {
UPB_ASSERT(arena);
_upb_MiniTableField_CheckIsArray(field);
UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(field);
upb_Array* array = upb_Message_GetMutableArray(msg, field);
if (!array) {
array = UPB_PRIVATE(_upb_Array_New)(arena, 4,
_upb_MiniTableField_ElemSizeLg2(field));
array = UPB_PRIVATE(_upb_Array_New)(
arena, 4, UPB_PRIVATE(_upb_MiniTableField_ElemSizeLg2)(field));
// Check again due to: https://godbolt.org/z/7WfaoKG1r
_upb_MiniTableField_CheckIsArray(field);
UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(field);
upb_MessageValue val;
val.array_val = array;
upb_Message_SetField(msg, field, val, arena);
@ -393,7 +410,7 @@ UPB_API_INLINE upb_Array* upb_Message_GetOrCreateMutableArray(
UPB_API_INLINE void* upb_Message_ResizeArrayUninitialized(
upb_Message* msg, const upb_MiniTableField* field, size_t size,
upb_Arena* arena) {
_upb_MiniTableField_CheckIsArray(field);
UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(field);
upb_Array* arr = upb_Message_GetOrCreateMutableArray(msg, field, arena);
if (!arr || !_upb_Array_ResizeUninitialized(arr, size, arena)) return NULL;
return _upb_array_ptr(arr);
@ -401,7 +418,7 @@ UPB_API_INLINE void* upb_Message_ResizeArrayUninitialized(
UPB_API_INLINE const upb_Map* upb_Message_GetMap(
const upb_Message* msg, const upb_MiniTableField* field) {
_upb_MiniTableField_CheckIsMap(field);
UPB_PRIVATE(_upb_MiniTableField_CheckIsMap)(field);
_upb_Message_AssertMapIsUntagged(msg, field);
upb_Map* ret;
const upb_Map* default_val = NULL;

12
upb/message/copy.c
Unescape View File

@ -33,10 +33,6 @@
// Must be last.
#include "upb/port/def.inc"
static bool upb_MessageField_IsMap(const upb_MiniTableField* field) {
return upb_FieldMode_Get(field) == kUpb_FieldMode_Map;
}
static upb_StringView upb_Clone_StringView(upb_StringView str,
upb_Arena* arena) {
if (str.size == 0) {
@ -164,7 +160,7 @@ static bool upb_Message_Array_DeepClone(const upb_Array* array,
const upb_MiniTable* mini_table,
const upb_MiniTableField* field,
upb_Message* clone, upb_Arena* arena) {
_upb_MiniTableField_CheckIsArray(field);
UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(field);
upb_Array* cloned_array = upb_Array_DeepClone(
array, upb_MiniTableField_CType(field),
upb_MiniTableField_CType(field) == kUpb_CType_Message &&
@ -197,7 +193,7 @@ upb_Message* _upb_Message_Copy(upb_Message* dst, const upb_Message* src,
memcpy(dst, src, mini_table->size);
for (size_t i = 0; i < mini_table->field_count; ++i) {
const upb_MiniTableField* field = &mini_table->fields[i];
if (!upb_MiniTableField_IsRepeatedOrMap(field)) {
if (upb_MiniTableField_IsScalar(field)) {
switch (upb_MiniTableField_CType(field)) {
case kUpb_CType_Message: {
upb_TaggedMessagePtr tagged =
@ -237,7 +233,7 @@ upb_Message* _upb_Message_Copy(upb_Message* dst, const upb_Message* src,
break;
}
} else {
if (upb_MessageField_IsMap(field)) {
if (upb_MiniTableField_IsMap(field)) {
const upb_Map* map = upb_Message_GetMap(src, field);
if (map != NULL) {
if (!upb_Message_Map_DeepClone(map, mini_table, field, dst, arena)) {
@ -264,7 +260,7 @@ upb_Message* _upb_Message_Copy(upb_Message* dst, const upb_Message* src,
upb_Message_Extension* dst_ext =
_upb_Message_GetOrCreateExtension(dst, msg_ext->ext, arena);
if (!dst_ext) return NULL;
if (!upb_MiniTableField_IsRepeatedOrMap(field)) {
if (upb_MiniTableField_IsScalar(field)) {
if (!upb_Clone_ExtensionValue(msg_ext->ext, msg_ext, dst_ext, arena)) {
return NULL;
}

17
upb/message/internal/accessors.h
Unescape View File

@ -148,7 +148,7 @@ UPB_INLINE void _upb_Message_SetPresence(upb_Message* msg,
UPB_INLINE bool _upb_MiniTable_ValueIsNonZero(const void* default_val,
const upb_MiniTableField* field) {
char zero[16] = {0};
switch (_upb_MiniTableField_GetRep(field)) {
switch (UPB_PRIVATE(_upb_MiniTableField_GetRep)(field)) {
case kUpb_FieldRep_1Byte:
return memcmp(&zero, default_val, 1) != 0;
case kUpb_FieldRep_4Byte:
@ -165,7 +165,7 @@ UPB_INLINE bool _upb_MiniTable_ValueIsNonZero(const void* default_val,
UPB_INLINE void _upb_MiniTable_CopyFieldData(void* to, const void* from,
const upb_MiniTableField* field) {
switch (_upb_MiniTableField_GetRep(field)) {
switch (UPB_PRIVATE(_upb_MiniTableField_GetRep)(field)) {
case kUpb_FieldRep_1Byte:
memcpy(to, from, 1);
return;
@ -201,8 +201,9 @@ UPB_INLINE void _upb_MiniTable_CopyFieldData(void* to, const void* from,
// const upb_MiniTableField* field,
// bool value, upb_Arena* a) {
// UPB_ASSUME(field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Bool);
// UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(field));
// UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_1Byte);
// UPB_ASSUME(upb_MiniTableField_IsScalar(field));
// UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
// kUpb_FieldRep_1Byte);
// upb_Message_SetField(msg, field, &value, a);
// }
//
@ -269,7 +270,7 @@ UPB_INLINE void _upb_Message_GetExtensionField(
// is unset (as message fields do have presence).
UPB_INLINE upb_MutableMessageValue _upb_Message_GetMutableField(
const upb_Message* msg, const upb_MiniTableField* field) {
UPB_ASSUME(upb_MiniTableField_IsRepeatedOrMap(field) ||
UPB_ASSUME(!upb_MiniTableField_IsScalar(field) ||
upb_MiniTableField_IsSubMessage(field));
upb_MutableMessageValue default_val;
@ -335,7 +336,7 @@ UPB_INLINE void _upb_Message_ClearNonExtensionField(
UPB_INLINE void _upb_Message_AssertMapIsUntagged(
const upb_Message* msg, const upb_MiniTableField* field) {
UPB_UNUSED(msg);
_upb_MiniTableField_CheckIsMap(field);
UPB_PRIVATE(_upb_MiniTableField_CheckIsMap)(field);
#ifndef NDEBUG
upb_TaggedMessagePtr default_val = 0;
upb_TaggedMessagePtr tagged;
@ -347,7 +348,7 @@ UPB_INLINE void _upb_Message_AssertMapIsUntagged(
UPB_INLINE upb_Map* _upb_Message_GetOrCreateMutableMap(
upb_Message* msg, const upb_MiniTableField* field, size_t key_size,
size_t val_size, upb_Arena* arena) {
_upb_MiniTableField_CheckIsMap(field);
UPB_PRIVATE(_upb_MiniTableField_CheckIsMap)(field);
_upb_Message_AssertMapIsUntagged(msg, field);
upb_Map* map = NULL;
upb_Map* default_map_value = NULL;
@ -355,7 +356,7 @@ UPB_INLINE upb_Map* _upb_Message_GetOrCreateMutableMap(
if (!map) {
map = _upb_Map_New(arena, key_size, val_size);
// Check again due to: https://godbolt.org/z/7WfaoKG1r
_upb_MiniTableField_CheckIsMap(field);
UPB_PRIVATE(_upb_MiniTableField_CheckIsMap)(field);
_upb_Message_SetNonExtensionField(msg, field, &map);
}
return map;

2
upb/message/promote.c
Unescape View File

@ -329,7 +329,7 @@ upb_UnknownToMessage_Status upb_MiniTable_PromoteUnknownToMap(
UPB_ASSERT(map_entry_mini_table);
UPB_ASSERT(map_entry_mini_table);
UPB_ASSERT(map_entry_mini_table->field_count == 2);
UPB_ASSERT(upb_FieldMode_Get(field) == kUpb_FieldMode_Map);
UPB_ASSERT(upb_MiniTableField_IsMap(field));
// Find all unknowns with given field number and parse.
upb_FindUnknownRet unknown;
while (1) {

4
upb/mini_descriptor/decode.c
Unescape View File

@ -638,7 +638,7 @@ static void upb_MtDecoder_ValidateEntryField(upb_MtDecoder* d,
name, expected_num, (int)f->number);
}
if (upb_MiniTableField_IsRepeatedOrMap(f)) {
if (!upb_MiniTableField_IsScalar(f)) {
upb_MdDecoder_ErrorJmp(
&d->base, "map %s cannot be repeated or map, or be in oneof", name);
}
@ -816,7 +816,7 @@ static const char* upb_MtDecoder_DoBuildMiniTableExtension(
if (!upb_MiniTableField_IsSubMessage(f)) return NULL;
// Extensions of MessageSet must be non-repeating.
if ((f->mode & kUpb_FieldMode_Mask) == kUpb_FieldMode_Array) return NULL;
if (upb_MiniTableField_IsArray(f)) return NULL;
}
ext->UPB_PRIVATE(extendee) = extendee;

8
upb/mini_descriptor/internal/encode_test.cc
Unescape View File

@ -65,7 +65,7 @@ TEST_P(MiniTableTest, AllScalarTypes) {
for (int i = 0; i < 16; i++) {
const upb_MiniTableField* f = &table->fields[i];
EXPECT_EQ(i + 1, f->number);
EXPECT_EQ(kUpb_FieldMode_Scalar, f->mode & kUpb_FieldMode_Mask);
EXPECT_TRUE(upb_MiniTableField_IsScalar(f));
EXPECT_TRUE(offsets.insert(f->offset).second);
EXPECT_TRUE(f->offset < table->size);
}
@ -91,7 +91,7 @@ TEST_P(MiniTableTest, AllRepeatedTypes) {
for (int i = 0; i < 16; i++) {
const upb_MiniTableField* f = &table->fields[i];
EXPECT_EQ(i + 1, f->number);
EXPECT_EQ(kUpb_FieldMode_Array, f->mode & kUpb_FieldMode_Mask);
EXPECT_TRUE(upb_MiniTableField_IsArray(f));
EXPECT_TRUE(offsets.insert(f->offset).second);
EXPECT_TRUE(f->offset < table->size);
}
@ -120,7 +120,7 @@ TEST_P(MiniTableTest, Skips) {
const upb_MiniTableField* f = &table->fields[i];
EXPECT_EQ(field_numbers[i], f->number);
EXPECT_EQ(kUpb_FieldType_Float, upb_MiniTableField_Type(f));
EXPECT_EQ(kUpb_FieldMode_Scalar, f->mode & kUpb_FieldMode_Mask);
EXPECT_TRUE(upb_MiniTableField_IsScalar(f));
EXPECT_TRUE(offsets.insert(f->offset).second);
EXPECT_TRUE(f->offset < table->size);
}
@ -149,7 +149,7 @@ TEST_P(MiniTableTest, AllScalarTypesOneof) {
for (int i = 0; i < 16; i++) {
const upb_MiniTableField* f = &table->fields[i];
EXPECT_EQ(i + 1, f->number);
EXPECT_EQ(kUpb_FieldMode_Scalar, f->mode & kUpb_FieldMode_Mask);
EXPECT_TRUE(upb_MiniTableField_IsScalar(f));
// For a oneof all fields have the same offset.
EXPECT_EQ(table->fields[0].offset, f->offset);
// All presence fields should point to the same oneof case offset.

60
upb/mini_table/field.h
Unescape View File

@ -8,8 +8,6 @@
#ifndef UPB_MINI_TABLE_FIELD_H_
#define UPB_MINI_TABLE_FIELD_H_
#include <stddef.h>
#include "upb/base/descriptor_constants.h"
#include "upb/mini_table/internal/field.h"
@ -22,57 +20,53 @@ typedef struct upb_MiniTableField upb_MiniTableField;
extern "C" {
#endif
UPB_API_INLINE upb_FieldType
upb_MiniTableField_Type(const upb_MiniTableField* f) {
if (f->mode & kUpb_LabelFlags_IsAlternate) {
if (f->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Int32) {
return kUpb_FieldType_Enum;
} else if (f->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Bytes) {
return kUpb_FieldType_String;
} else {
UPB_ASSERT(false);
}
}
return (upb_FieldType)f->UPB_PRIVATE(descriptortype);
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) {
return upb_FieldType_CType(upb_MiniTableField_Type(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_IsArray(const upb_MiniTableField* f) {
return UPB_PRIVATE(_upb_MiniTableField_IsArray)(f);
}
UPB_API_INLINE bool upb_MiniTableField_IsClosedEnum(
const upb_MiniTableField* field) {
return field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Enum;
const upb_MiniTableField* f) {
return UPB_PRIVATE(_upb_MiniTableField_IsClosedEnum)(f);
}
UPB_API_INLINE bool upb_MiniTableField_IsExtension(
const upb_MiniTableField* f) {
return f->mode & kUpb_LabelFlags_IsExtension;
return UPB_PRIVATE(_upb_MiniTableField_IsExtension)(f);
}
UPB_API_INLINE bool upb_MiniTableField_IsInOneof(const upb_MiniTableField* f) {
return f->presence < 0;
return UPB_PRIVATE(_upb_MiniTableField_IsInOneof)(f);
}
UPB_API_INLINE bool upb_MiniTableField_IsRepeatedOrMap(
const upb_MiniTableField* f) {
// This works because upb_FieldMode has no value 3.
return !(f->mode & kUpb_FieldMode_Scalar);
UPB_API_INLINE bool upb_MiniTableField_IsMap(const upb_MiniTableField* f) {
return UPB_PRIVATE(_upb_MiniTableField_IsMap)(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_IsScalar(const upb_MiniTableField* f) {
return UPB_PRIVATE(_upb_MiniTableField_IsScalar)(f);
}
UPB_API_INLINE bool upb_MiniTableField_IsSubMessage(
const upb_MiniTableField* f) {
return f->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Message ||
f->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Group;
return UPB_PRIVATE(_upb_MiniTableField_IsSubMessage)(f);
}
UPB_API_INLINE bool upb_MiniTableField_HasPresence(
const upb_MiniTableField* f) {
if (upb_MiniTableField_IsExtension(f)) {
return !upb_MiniTableField_IsRepeatedOrMap(f);
} else {
return f->presence != 0;
}
UPB_API_INLINE upb_FieldType
upb_MiniTableField_Type(const upb_MiniTableField* f) {
return UPB_PRIVATE(_upb_MiniTableField_Type)(f);
}
#ifdef __cplusplus

116
upb/mini_table/internal/field.h
Unescape View File

@ -20,7 +20,7 @@
struct upb_MiniTableField {
uint32_t number;
uint16_t offset;
int16_t presence; // If >0, hasbit_index. If <0, ~oneof_index
int16_t presence; // If >0, hasbit_index. If <0, ~oneof_index
// Indexes into `upb_MiniTable.subs`
// Will be set to `kUpb_NoSub` if `descriptortype` != MESSAGE/GROUP/ENUM
@ -69,38 +69,110 @@ typedef enum {
#define kUpb_FieldRep_Shift 6
UPB_INLINE upb_FieldRep
_upb_MiniTableField_GetRep(const struct upb_MiniTableField* field) {
return (upb_FieldRep)(field->mode >> kUpb_FieldRep_Shift);
}
#ifdef __cplusplus
extern "C" {
#endif
UPB_INLINE upb_FieldMode
upb_FieldMode_Get(const struct upb_MiniTableField* field) {
return (upb_FieldMode)(field->mode & 3);
UPB_PRIVATE(_upb_MiniTableField_Mode)(const struct upb_MiniTableField* f) {
return (upb_FieldMode)(f->mode & kUpb_FieldMode_Mask);
}
UPB_INLINE upb_FieldRep
UPB_PRIVATE(_upb_MiniTableField_GetRep)(const struct upb_MiniTableField* f) {
return (upb_FieldRep)(f->mode >> kUpb_FieldRep_Shift);
}
UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsArray)(
const struct upb_MiniTableField* f) {
return (f->mode & kUpb_FieldMode_Mask) == kUpb_FieldMode_Array;
}
UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsMap)(
const struct upb_MiniTableField* f) {
return (f->mode & kUpb_FieldMode_Mask) == kUpb_FieldMode_Map;
}
UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsScalar)(
const struct upb_MiniTableField* f) {
return (f->mode & kUpb_FieldMode_Mask) == kUpb_FieldMode_Scalar;
}
UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsAlternate)(
const struct upb_MiniTableField* f) {
return (f->mode & kUpb_LabelFlags_IsAlternate) != 0;
}
UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsExtension)(
const struct upb_MiniTableField* f) {
return (f->mode & kUpb_LabelFlags_IsExtension) != 0;
}
UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsPacked)(
const struct upb_MiniTableField* f) {
return (f->mode & kUpb_LabelFlags_IsPacked) != 0;
}
UPB_INLINE upb_FieldType
UPB_PRIVATE(_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;
if (type == kUpb_FieldType_Bytes) return kUpb_FieldType_String;
UPB_ASSERT(false);
}
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_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsClosedEnum)(
const struct upb_MiniTableField* f) {
return f->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Enum;
}
UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_IsInOneof)(
const struct upb_MiniTableField* f) {
return f->presence < 0;
}
UPB_INLINE bool UPB_PRIVATE(_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)(
const struct upb_MiniTableField* f) {
if (UPB_PRIVATE(_upb_MiniTableField_IsExtension)(f)) {
return UPB_PRIVATE(_upb_MiniTableField_IsScalar)(f);
} else {
return f->presence != 0;
}
}
UPB_INLINE void _upb_MiniTableField_CheckIsArray(
const struct upb_MiniTableField* field) {
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_NativePointer);
UPB_ASSUME(upb_FieldMode_Get(field) == kUpb_FieldMode_Array);
UPB_ASSUME(field->presence == 0);
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(f->presence == 0);
}
UPB_INLINE void _upb_MiniTableField_CheckIsMap(
const struct upb_MiniTableField* field) {
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_NativePointer);
UPB_ASSUME(upb_FieldMode_Get(field) == kUpb_FieldMode_Map);
UPB_ASSUME(field->presence == 0);
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(f->presence == 0);
}
UPB_INLINE size_t
_upb_MiniTableField_ElemSizeLg2(const struct upb_MiniTableField* field) {
return upb_FieldType_SizeLg2(
(upb_FieldType)field->UPB_PRIVATE(descriptortype));
UPB_INLINE size_t UPB_PRIVATE(_upb_MiniTableField_ElemSizeLg2)(
const struct upb_MiniTableField* f) {
return upb_FieldType_SizeLg2((upb_FieldType)f->UPB_PRIVATE(descriptortype));
}
#ifdef __cplusplus

10
upb/mini_table/message.c
Unescape View File

@ -8,8 +8,10 @@
#include "upb/mini_table/message.h"
#include <inttypes.h>
#include <stddef.h>
#include <stdint.h>
#include "upb/mem/arena.h"
#include "upb/mini_table/field.h"
#include "upb/mini_table/internal/message.h"
// Must be last.
@ -44,13 +46,9 @@ const upb_MiniTableField* upb_MiniTable_FindFieldByNumber(
return NULL;
}
static bool upb_MiniTable_Is_Oneof(const upb_MiniTableField* f) {
return f->presence < 0;
}
const upb_MiniTableField* upb_MiniTable_GetOneof(const upb_MiniTable* m,
const upb_MiniTableField* f) {
if (UPB_UNLIKELY(!upb_MiniTable_Is_Oneof(f))) {
if (UPB_UNLIKELY(!upb_MiniTableField_IsInOneof(f))) {
return NULL;
}
const upb_MiniTableField* ptr = &m->fields[0];

2
upb/reflection/BUILD
Unescape View File

@ -135,7 +135,9 @@ bootstrap_cc_library(
"//upb:mem",
"//upb:message",
"//upb:message_accessors",
"//upb:message_accessors_internal",
"//upb:message_copy",
"//upb:message_internal",
"//upb:message_value",
"//upb:mini_descriptor",
"//upb:mini_descriptor_internal",

12
upb/reflection/message.c
Unescape View File

@ -7,17 +7,21 @@
#include "upb/reflection/message.h"
#include <stdint.h>
#include <string.h>
#include "upb/hash/common.h"
#include "upb/mem/arena.h"
#include "upb/message/accessors.h"
#include "upb/message/array.h"
#include "upb/message/internal/accessors.h"
#include "upb/message/internal/extension.h"
#include "upb/message/internal/message.h"
#include "upb/message/map.h"
#include "upb/message/message.h"
#include "upb/mini_table/field.h"
#include "upb/mini_table/internal/field.h"
#include "upb/reflection/def.h"
#include "upb/reflection/def_pool.h"
#include "upb/reflection/def_type.h"
#include "upb/reflection/internal/field_def.h"
#include "upb/reflection/message_def.h"
#include "upb/reflection/oneof_def.h"
@ -119,7 +123,7 @@ bool upb_Message_Next(const upb_Message* msg, const upb_MessageDef* m,
if (upb_MiniTableField_HasPresence(field)) {
if (!upb_Message_HasFieldByDef(msg, f)) continue;
} else {
switch (upb_FieldMode_Get(field)) {
switch (UPB_PRIVATE(_upb_MiniTableField_Mode)(field)) {
case kUpb_FieldMode_Map:
if (!val.map_val || upb_Map_Size(val.map_val) == 0) continue;
break;

6
upb/wire/decode.c
Unescape View File

@ -597,8 +597,8 @@ static const char* _upb_Decoder_DecodeToMap(upb_Decoder* d, const char* ptr,
UPB_ASSERT(entry);
UPB_ASSERT(entry->field_count == 2);
UPB_ASSERT(!upb_MiniTableField_IsRepeatedOrMap(&entry->fields[0]));
UPB_ASSERT(!upb_MiniTableField_IsRepeatedOrMap(&entry->fields[1]));
UPB_ASSERT(upb_MiniTableField_IsScalar(&entry->fields[0]));
UPB_ASSERT(upb_MiniTableField_IsScalar(&entry->fields[1]));
if (!map) {
map = _upb_Decoder_CreateMap(d, entry);
@ -1043,7 +1043,7 @@ int _upb_Decoder_GetDelimitedOp(upb_Decoder* d, const upb_MiniTable* mt,
};
int ndx = field->UPB_PRIVATE(descriptortype);
if (upb_FieldMode_Get(field) == kUpb_FieldMode_Array) ndx += kRepeatedBase;
if (upb_MiniTableField_IsArray(field)) ndx += kRepeatedBase;
int op = kDelimitedOps[ndx];
if (op == kUpb_DecodeOp_SubMessage) {

7
upb/wire/encode.c
Unescape View File

@ -26,6 +26,7 @@
#include "upb/message/internal/map.h"
#include "upb/message/internal/map_entry.h"
#include "upb/message/internal/map_sorter.h"
#include "upb/message/map.h"
#include "upb/message/message.h"
#include "upb/message/tagged_ptr.h"
#include "upb/mini_table/extension.h"
@ -307,7 +308,7 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
const upb_MiniTableSub* subs,
const upb_MiniTableField* f) {
const upb_Array* arr = *UPB_PTR_AT(msg, f->offset, upb_Array*);
bool packed = f->mode & kUpb_LabelFlags_IsPacked;
bool packed = upb_MiniTableField_IsPacked(f);
size_t pre_len = e->limit - e->ptr;
if (arr == NULL || arr->size == 0) {
@ -461,7 +462,7 @@ static bool encode_shouldencode(upb_encstate* e, const upb_Message* msg,
if (f->presence == 0) {
// Proto3 presence or map/array.
const void* mem = UPB_PTR_AT(msg, f->offset, void);
switch (_upb_MiniTableField_GetRep(f)) {
switch (UPB_PRIVATE(_upb_MiniTableField_GetRep)(f)) {
case kUpb_FieldRep_1Byte: {
char ch;
memcpy(&ch, mem, 1);
@ -496,7 +497,7 @@ static bool encode_shouldencode(upb_encstate* e, const upb_Message* msg,
static void encode_field(upb_encstate* e, const upb_Message* msg,
const upb_MiniTableSub* subs,
const upb_MiniTableField* field) {
switch (upb_FieldMode_Get(field)) {
switch (UPB_PRIVATE(_upb_MiniTableField_Mode)(field)) {
case kUpb_FieldMode_Array:
encode_array(e, msg, subs, field);
break;

1
upb_generator/BUILD
Unescape View File

@ -306,6 +306,7 @@ bootstrap_cc_binary(
deps = [
"//upb:base",
"//upb:mem",
"//upb:mini_table",
"//upb:mini_table_internal",
"//upb:port",
"//upb:wire_types",

9
upb_generator/common.cc
Unescape View File

@ -140,15 +140,18 @@ std::string GetModeInit(const upb_MiniTableField* field32,
std::string GetFieldRep(const upb_MiniTableField* field32,
const upb_MiniTableField* field64) {
switch (_upb_MiniTableField_GetRep(field32)) {
const auto rep32 = UPB_PRIVATE(_upb_MiniTableField_GetRep)(field32);
const auto rep64 = UPB_PRIVATE(_upb_MiniTableField_GetRep)(field64);
switch (rep32) {
case kUpb_FieldRep_1Byte:
return "kUpb_FieldRep_1Byte";
break;
case kUpb_FieldRep_4Byte: {
if (_upb_MiniTableField_GetRep(field64) == kUpb_FieldRep_4Byte) {
if (rep64 == kUpb_FieldRep_4Byte) {
return "kUpb_FieldRep_4Byte";
} else {
assert(_upb_MiniTableField_GetRep(field64) == kUpb_FieldRep_8Byte);
assert(rep64 == kUpb_FieldRep_8Byte);
return "UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte)";
}
break;

10
upb_generator/protoc-gen-upb.cc
Unescape View File

@ -282,8 +282,9 @@ void GenerateExtensionInHeader(const DefPoolPair& pools, upb::FieldDefPtr ext,
R"cc(
UPB_INLINE $0 $1_$2(const struct $3* msg) {
const upb_MiniTableExtension* ext = &$4;
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(&ext->UPB_PRIVATE(field)));
UPB_ASSUME(_upb_MiniTableField_GetRep(&ext->UPB_PRIVATE(field)) == $5);
UPB_ASSUME(upb_MiniTableField_IsScalar(&ext->UPB_PRIVATE(field)));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(
&ext->UPB_PRIVATE(field)) == $5);
$0 default_val = $6;
$0 ret;
_upb_Message_GetExtensionField(msg, ext, &default_val, &ret);
@ -297,8 +298,9 @@ void GenerateExtensionInHeader(const DefPoolPair& pools, upb::FieldDefPtr ext,
R"cc(
UPB_INLINE void $1_set_$2(struct $3* msg, $0 val, upb_Arena* arena) {
const upb_MiniTableExtension* ext = &$4;
UPB_ASSUME(!upb_MiniTableField_IsRepeatedOrMap(&ext->UPB_PRIVATE(field)));
UPB_ASSUME(_upb_MiniTableField_GetRep(&ext->UPB_PRIVATE(field)) == $5);
UPB_ASSUME(upb_MiniTableField_IsScalar(&ext->UPB_PRIVATE(field)));
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(
&ext->UPB_PRIVATE(field)) == $5);
bool ok = _upb_Message_SetExtensionField(msg, ext, &val, arena);
UPB_ASSERT(ok);
}

39
upb_generator/protoc-gen-upb_minitable.cc
Unescape View File

@ -5,6 +5,8 @@
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
#include <string.h>
#include <algorithm>
#include <cstddef>
#include <cstdint>
@ -17,18 +19,20 @@
#include "absl/log/absl_check.h"
#include "absl/log/absl_log.h"
#include "absl/strings/escaping.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_replace.h"
#include "absl/strings/string_view.h"
#include "absl/strings/substitute.h"
#include "upb/base/descriptor_constants.h"
#include "upb/base/status.hpp"
#include "upb/base/string_view.h"
#include "upb/mini_table/enum.h"
#include "upb/mini_table/field.h"
#include "upb/mini_table/internal/field.h"
#include "upb/mini_table/message.h"
#include "upb/reflection/def.hpp"
#include "upb/wire/types.h"
#include "upb_generator/common.h"
#include "upb_generator/file_layout.h"
#include "upb_generator/names.h"
#include "upb_generator/plugin.h"
// Must be last.
@ -62,7 +66,7 @@ std::string SourceFilename(upb::FileDefPtr file) {
}
std::string ExtensionIdentBase(upb::FieldDefPtr ext) {
assert(ext.is_extension());
UPB_ASSERT(ext.is_extension());
std::string ext_scope;
if (ext.extension_scope()) {
return MessageName(ext.extension_scope());
@ -263,23 +267,12 @@ bool TryFillTableEntry(const DefPoolPair& pools, upb::FieldDefPtr field,
return false; // Not supported yet.
}
switch (upb_FieldMode_Get(mt_f)) {
case kUpb_FieldMode_Map:
return false; // Not supported yet (ever?).
case kUpb_FieldMode_Array:
if (mt_f->mode & kUpb_LabelFlags_IsPacked) {
cardinality = "p";
} else {
cardinality = "r";
}
break;
case kUpb_FieldMode_Scalar:
if (mt_f->presence < 0) {
cardinality = "o";
} else {
cardinality = "s";
}
break;
if (upb_MiniTableField_IsArray(mt_f)) {
cardinality = upb_MiniTableField_IsPacked(mt_f) ? "p" : "r";
} else if (upb_MiniTableField_IsScalar(mt_f)) {
cardinality = upb_MiniTableField_IsInOneof(mt_f) ? "o" : "s";
} else {
return false; // Not supported yet (ever?).
}
uint64_t expected_tag = GetEncodedTag(field);
@ -453,12 +446,12 @@ void WriteMessage(upb::MessageDefPtr message, const DefPoolPair& pools,
}
std::vector<TableEntry> table;
uint8_t table_mask = -1;
uint8_t table_mask = ~0;
table = FastDecodeTable(message, pools);
if (table.size() > 1) {
assert((table.size() & (table.size() - 1)) == 0);
UPB_ASSERT((table.size() & (table.size() - 1)) == 0);
table_mask = (table.size() - 1) << 3;
}

Write Preview
Loading…
Cancel
Save