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

Merge pull request #489 from haberman/rename3

Browse Source 
Renamed upb_FieldType_* -> kUpb_FieldType_*
pull/13171/head
Joshua Haberman 3 years ago committed by GitHub
parent 3e55eea0e1 606308c639
commit 4d8af50450
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 185 additions and 185 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. 46
      python/descriptor.c
  2. 4
      python/descriptor_pool.c
  3. 2
      rename.sed
  4. 2
      run_sed.sh
  5. 36
      upb/bindings/lua/def.c
  6. 34
      upb/decode.c
  7. 66
      upb/def.c
  8. 72
      upb/encode.c
  9. 28
      upb/msg.c
  10. 4
      upb/msg_internal.h
  11. 40
      upb/reflection.c
  12. 36
      upb/upb.h

46
python/descriptor.c
Unescape View File

@ -1635,28 +1635,26 @@ bool PyUpb_InitDescriptor(PyObject* m) {
}
}
PyObject* field_desc = (PyObject*)s->descriptor_types[kPyUpb_FieldDescriptor];
return PyUpb_SetIntAttr(field_desc, "LABEL_OPTIONAL", kUpb_Label_Optional) &&
PyUpb_SetIntAttr(field_desc, "LABEL_REPEATED", kUpb_Label_Repeated) &&
PyUpb_SetIntAttr(field_desc, "LABEL_REQUIRED", kUpb_Label_Required) &&
PyUpb_SetIntAttr(field_desc, "TYPE_BOOL", upb_FieldType_Bool) &&
PyUpb_SetIntAttr(field_desc, "TYPE_BYTES", upb_FieldType_Bytes) &&
PyUpb_SetIntAttr(field_desc, "TYPE_DOUBLE", upb_FieldType_Double) &&
PyUpb_SetIntAttr(field_desc, "TYPE_ENUM", upb_FieldType_Enum) &&
PyUpb_SetIntAttr(field_desc, "TYPE_FIXED32", upb_FieldType_Fixed32) &&
PyUpb_SetIntAttr(field_desc, "TYPE_FIXED64", upb_FieldType_Fixed64) &&
PyUpb_SetIntAttr(field_desc, "TYPE_FLOAT", upb_FieldType_Float) &&
PyUpb_SetIntAttr(field_desc, "TYPE_GROUP", upb_FieldType_Group) &&
PyUpb_SetIntAttr(field_desc, "TYPE_INT32", upb_FieldType_Int32) &&
PyUpb_SetIntAttr(field_desc, "TYPE_INT64", upb_FieldType_Int64) &&
PyUpb_SetIntAttr(field_desc, "TYPE_MESSAGE", upb_FieldType_Message) &&
PyUpb_SetIntAttr(field_desc, "TYPE_SFIXED32",
upb_FieldType_SFixed32) &&
PyUpb_SetIntAttr(field_desc, "TYPE_SFIXED64",
upb_FieldType_SFixed64) &&
PyUpb_SetIntAttr(field_desc, "TYPE_SINT32", upb_FieldType_SInt32) &&
PyUpb_SetIntAttr(field_desc, "TYPE_SINT64", upb_FieldType_SInt64) &&
PyUpb_SetIntAttr(field_desc, "TYPE_STRING", upb_FieldType_String) &&
PyUpb_SetIntAttr(field_desc, "TYPE_UINT32", upb_FieldType_UInt32) &&
PyUpb_SetIntAttr(field_desc, "TYPE_UINT64", upb_FieldType_UInt64);
PyObject* fd = (PyObject*)s->descriptor_types[kPyUpb_FieldDescriptor];
return PyUpb_SetIntAttr(fd, "LABEL_OPTIONAL", kUpb_Label_Optional) &&
PyUpb_SetIntAttr(fd, "LABEL_REPEATED", kUpb_Label_Repeated) &&
PyUpb_SetIntAttr(fd, "LABEL_REQUIRED", kUpb_Label_Required) &&
PyUpb_SetIntAttr(fd, "TYPE_BOOL", kUpb_FieldType_Bool) &&
PyUpb_SetIntAttr(fd, "TYPE_BYTES", kUpb_FieldType_Bytes) &&
PyUpb_SetIntAttr(fd, "TYPE_DOUBLE", kUpb_FieldType_Double) &&
PyUpb_SetIntAttr(fd, "TYPE_ENUM", kUpb_FieldType_Enum) &&
PyUpb_SetIntAttr(fd, "TYPE_FIXED32", kUpb_FieldType_Fixed32) &&
PyUpb_SetIntAttr(fd, "TYPE_FIXED64", kUpb_FieldType_Fixed64) &&
PyUpb_SetIntAttr(fd, "TYPE_FLOAT", kUpb_FieldType_Float) &&
PyUpb_SetIntAttr(fd, "TYPE_GROUP", kUpb_FieldType_Group) &&
PyUpb_SetIntAttr(fd, "TYPE_INT32", kUpb_FieldType_Int32) &&
PyUpb_SetIntAttr(fd, "TYPE_INT64", kUpb_FieldType_Int64) &&
PyUpb_SetIntAttr(fd, "TYPE_MESSAGE", kUpb_FieldType_Message) &&
PyUpb_SetIntAttr(fd, "TYPE_SFIXED32", kUpb_FieldType_SFixed32) &&
PyUpb_SetIntAttr(fd, "TYPE_SFIXED64", kUpb_FieldType_SFixed64) &&
PyUpb_SetIntAttr(fd, "TYPE_SINT32", kUpb_FieldType_SInt32) &&
PyUpb_SetIntAttr(fd, "TYPE_SINT64", kUpb_FieldType_SInt64) &&
PyUpb_SetIntAttr(fd, "TYPE_STRING", kUpb_FieldType_String) &&
PyUpb_SetIntAttr(fd, "TYPE_UINT32", kUpb_FieldType_UInt32) &&
PyUpb_SetIntAttr(fd, "TYPE_UINT64", kUpb_FieldType_UInt64);
}

4
python/descriptor_pool.c
Unescape View File

@ -514,8 +514,8 @@ static PyObject* PyUpb_DescriptorPool_FindMethodByName(PyObject* _self,
upb_DefPool_FindServiceByNameWithSize(self->symtab, name, parent_size);
if (parent == NULL && self->db) {
if (!PyUpb_DescriptorPool_TryLoadSymbol(self, arg)) return NULL;
parent = upb_DefPool_FindServiceByNameWithSize(self->symtab, name,
parent_size);
parent =
upb_DefPool_FindServiceByNameWithSize(self->symtab, name, parent_size);
}
if (!parent) goto err;
const upb_MethodDef* m = upb_ServiceDef_FindMethodByName(parent, child);

2
rename.sed
Unescape View File

@ -333,6 +333,8 @@ s/_upb_be_swap32/_upb_BigEndian_Swap32/g;
s/_upb_be_swap64/_upb_BigEndian_Swap64/g;
s/_upb_lg2ceil/_upb_Log2Ceiling/g;
s/_upb_lg2ceilsize/_upb_Log2CeilingSize/g;
s/upb_FieldType_/kUpb_FieldType_/g;
s/kUpb_FieldType([A-Z])/kUpb_FieldType_\1/g;
s/upb_msgval/upb_MessageValue/g;
s/upb_mutmsgval/upb_MutableMessageValue/g;

2
run_sed.sh
Unescape View File

@ -1,5 +1,5 @@
shopt -s globstar
sed -i -f rename.sed **/*.c **/*.cc **/*.h **/*.hpp **/*.py
sed -E -i -f rename.sed **/*.c **/*.cc **/*.h **/*.hpp **/*.py
# Since sed can't handle multi-line patterns:
perl -i -pe 'BEGIN{undef $/;} s/\bupb_decode\(([^,\)]+),([^,]+),([^,]+),([^,]+),([^,\)]+)\)/upb_Decode(\1, \2, \3, \4, NULL, 0, \5)/smg' **/*.c **/*.cc **/*.h **/*.hpp

36
upb/bindings/lua/def.c
Unescape View File

@ -915,24 +915,24 @@ void lupb_def_registertypes(lua_State* L) {
lupb_setfieldi(L, "TYPE_UINT32", kUpb_CType_UInt32);
lupb_setfieldi(L, "TYPE_ENUM", kUpb_CType_Enum);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_DOUBLE", upb_FieldType_Double);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_FLOAT", upb_FieldType_Float);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_INT64", upb_FieldType_Int64);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_UINT64", upb_FieldType_UInt64);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_INT32", upb_FieldType_Int32);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_FIXED64", upb_FieldType_Fixed64);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_FIXED32", upb_FieldType_Fixed32);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_BOOL", upb_FieldType_Bool);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_STRING", upb_FieldType_String);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_GROUP", upb_FieldType_Group);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_MESSAGE", upb_FieldType_Message);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_BYTES", upb_FieldType_Bytes);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_UINT32", upb_FieldType_UInt32);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_ENUM", upb_FieldType_Enum);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_SFIXED32", upb_FieldType_SFixed32);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_SFIXED64", upb_FieldType_SFixed64);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_SINT32", upb_FieldType_SInt32);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_SINT64", upb_FieldType_SInt64);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_DOUBLE", kUpb_FieldType_Double);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_FLOAT", kUpb_FieldType_Float);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_INT64", kUpb_FieldType_Int64);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_UINT64", kUpb_FieldType_UInt64);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_INT32", kUpb_FieldType_Int32);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_FIXED64", kUpb_FieldType_Fixed64);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_FIXED32", kUpb_FieldType_Fixed32);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_BOOL", kUpb_FieldType_Bool);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_STRING", kUpb_FieldType_String);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_GROUP", kUpb_FieldType_Group);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_MESSAGE", kUpb_FieldType_Message);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_BYTES", kUpb_FieldType_Bytes);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_UINT32", kUpb_FieldType_UInt32);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_ENUM", kUpb_FieldType_Enum);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_SFIXED32", kUpb_FieldType_SFixed32);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_SFIXED64", kUpb_FieldType_SFixed64);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_SINT32", kUpb_FieldType_SInt32);
lupb_setfieldi(L, "DESCRIPTOR_TYPE_SINT64", kUpb_FieldType_SInt64);
lupb_setfieldi(L, "SYNTAX_PROTO2", kUpb_Syntax_Proto2);
lupb_setfieldi(L, "SYNTAX_PROTO3", kUpb_Syntax_Proto3);

34
upb/decode.c
Unescape View File

@ -83,13 +83,13 @@ static const uint8_t desctype_to_mapsize[] = {
8, /* SINT64 */
};
static const unsigned FIXED32_OK_MASK = (1 << upb_FieldType_Float) |
(1 << upb_FieldType_Fixed32) |
(1 << upb_FieldType_SFixed32);
static const unsigned FIXED32_OK_MASK = (1 << kUpb_FieldType_Float) |
(1 << kUpb_FieldType_Fixed32) |
(1 << kUpb_FieldType_SFixed32);
static const unsigned FIXED64_OK_MASK = (1 << upb_FieldType_Double) |
(1 << upb_FieldType_Fixed64) |
(1 << upb_FieldType_SFixed64);
static const unsigned FIXED64_OK_MASK = (1 << kUpb_FieldType_Double) |
(1 << kUpb_FieldType_Fixed64) |
(1 << kUpb_FieldType_SFixed64);
/* Three fake field types for MessageSet. */
#define TYPE_MSGSET_ITEM 19
@ -275,22 +275,22 @@ static void decode_munge_int32(wireval* val) {
static void decode_munge(int type, wireval* val) {
switch (type) {
case upb_FieldType_Bool:
case kUpb_FieldType_Bool:
val->bool_val = val->uint64_val != 0;
break;
case upb_FieldType_SInt32: {
case kUpb_FieldType_SInt32: {
uint32_t n = val->uint64_val;
val->uint32_val = (n >> 1) ^ -(int32_t)(n & 1);
break;
}
case upb_FieldType_SInt64: {
case kUpb_FieldType_SInt64: {
uint64_t n = val->uint64_val;
val->uint64_val = (n >> 1) ^ -(int64_t)(n & 1);
break;
}
case upb_FieldType_Int32:
case upb_FieldType_UInt32:
case upb_FieldType_Enum:
case kUpb_FieldType_Int32:
case kUpb_FieldType_UInt32:
case kUpb_FieldType_Enum:
decode_munge_int32(val);
break;
}
@ -572,7 +572,7 @@ static const char* decode_toarray(upb_Decoder* d, const char* ptr,
*UPB_PTR_AT(_upb_array_ptr(arr), arr->len * sizeof(void*), upb_Message*) =
submsg;
arr->len++;
if (UPB_UNLIKELY(field->descriptortype == upb_FieldType_Group)) {
if (UPB_UNLIKELY(field->descriptortype == kUpb_FieldType_Group)) {
return decode_togroup(d, ptr, submsg, subs, field);
} else {
return decode_tosubmsg(d, ptr, submsg, subs, field, val->size);
@ -620,8 +620,8 @@ static const char* decode_tomap(upb_Decoder* d, const char* ptr,
/* Parse map entry. */
memset(&ent, 0, sizeof(ent));
if (entry->fields[1].descriptortype == upb_FieldType_Message ||
entry->fields[1].descriptortype == upb_FieldType_Group) {
if (entry->fields[1].descriptortype == kUpb_FieldType_Message ||
entry->fields[1].descriptortype == kUpb_FieldType_Group) {
/* Create proactively to handle the case where it doesn't appear. */
ent.v.val =
upb_value_ptr(_upb_Message_New(entry->subs[0].submsg, &d->arena));
@ -666,7 +666,7 @@ static const char* decode_tomsg(upb_Decoder* d, const char* ptr,
submsg = decode_newsubmsg(d, subs, field);
*submsgp = submsg;
}
if (UPB_UNLIKELY(type == upb_FieldType_Group)) {
if (UPB_UNLIKELY(type == kUpb_FieldType_Group)) {
ptr = decode_togroup(d, ptr, submsg, subs, field);
} else {
ptr = decode_tosubmsg(d, ptr, submsg, subs, field, val->size);
@ -863,7 +863,7 @@ static const char* decode_wireval(upb_Decoder* d, const char* ptr,
}
case kUpb_WireType_StartGroup:
val->uint32_val = field->number;
if (field->descriptortype == upb_FieldType_Group) {
if (field->descriptortype == kUpb_FieldType_Group) {
*op = OP_SUBMSG;
} else if (field->descriptortype == TYPE_MSGSET_ITEM) {
*op = OP_MSGSET_ITEM;

66
upb/def.c
Unescape View File

@ -472,34 +472,34 @@ const char* upb_FieldDef_FullName(const upb_FieldDef* f) {
upb_CType upb_FieldDef_CType(const upb_FieldDef* f) {
switch (f->type_) {
case upb_FieldType_Double:
case kUpb_FieldType_Double:
return kUpb_CType_Double;
case upb_FieldType_Float:
case kUpb_FieldType_Float:
return kUpb_CType_Float;
case upb_FieldType_Int64:
case upb_FieldType_SInt64:
case upb_FieldType_SFixed64:
case kUpb_FieldType_Int64:
case kUpb_FieldType_SInt64:
case kUpb_FieldType_SFixed64:
return kUpb_CType_Int64;
case upb_FieldType_Int32:
case upb_FieldType_SFixed32:
case upb_FieldType_SInt32:
case kUpb_FieldType_Int32:
case kUpb_FieldType_SFixed32:
case kUpb_FieldType_SInt32:
return kUpb_CType_Int32;
case upb_FieldType_UInt64:
case upb_FieldType_Fixed64:
case kUpb_FieldType_UInt64:
case kUpb_FieldType_Fixed64:
return kUpb_CType_UInt64;
case upb_FieldType_UInt32:
case upb_FieldType_Fixed32:
case kUpb_FieldType_UInt32:
case kUpb_FieldType_Fixed32:
return kUpb_CType_UInt32;
case upb_FieldType_Enum:
case kUpb_FieldType_Enum:
return kUpb_CType_Enum;
case upb_FieldType_Bool:
case kUpb_FieldType_Bool:
return kUpb_CType_Bool;
case upb_FieldType_String:
case kUpb_FieldType_String:
return kUpb_CType_String;
case upb_FieldType_Bytes:
case kUpb_FieldType_Bytes:
return kUpb_CType_Bytes;
case upb_FieldType_Group:
case upb_FieldType_Message:
case kUpb_FieldType_Group:
case kUpb_FieldType_Message:
return kUpb_CType_Message;
}
UPB_UNREACHABLE();
@ -1381,11 +1381,11 @@ static uint8_t map_descriptortype(const upb_FieldDef* f) {
uint8_t type = upb_FieldDef_Type(f);
/* See TableDescriptorType() in upbc/generator.cc for details and
* rationale of these exceptions. */
if (type == upb_FieldType_String && f->file->syntax == kUpb_Syntax_Proto2) {
return upb_FieldType_Bytes;
} else if (type == upb_FieldType_Enum &&
if (type == kUpb_FieldType_String && f->file->syntax == kUpb_Syntax_Proto2) {
return kUpb_FieldType_Bytes;
} else if (type == kUpb_FieldType_Enum &&
f->sub.enumdef->file->syntax == kUpb_Syntax_Proto3) {
return upb_FieldType_Int32;
return kUpb_FieldType_Int32;
}
return type;
}
@ -2188,9 +2188,9 @@ static void create_fielddef(
if (has_type) {
switch (f->type_) {
case upb_FieldType_Message:
case upb_FieldType_Group:
case upb_FieldType_Enum:
case kUpb_FieldType_Message:
case kUpb_FieldType_Group:
case kUpb_FieldType_Enum:
if (!has_type_name) {
symtab_errf(ctx, "field of type %d requires type name (%s)",
(int)f->type_, full_name);
@ -2272,7 +2272,7 @@ static void create_fielddef(
}
}
if (f->type_ < upb_FieldType_Double || f->type_ > upb_FieldType_SInt64) {
if (f->type_ < kUpb_FieldType_Double || f->type_ > kUpb_FieldType_SInt64) {
symtab_errf(ctx, "invalid type for field %s (%d)", f->full_name, f->type_);
}
@ -2660,25 +2660,25 @@ static void resolve_subdef(symtab_addctx* ctx, const char* prefix,
switch (type) {
case UPB_DEFTYPE_ENUM:
f->sub.enumdef = def;
f->type_ = upb_FieldType_Enum;
f->type_ = kUpb_FieldType_Enum;
break;
case UPB_DEFTYPE_MSG:
f->sub.msgdef = def;
f->type_ = upb_FieldType_Message; // It appears there is no way of
// this being a group.
f->type_ = kUpb_FieldType_Message; // It appears there is no way of
// this being a group.
break;
default:
symtab_errf(ctx, "Couldn't resolve type name for field %s",
f->full_name);
}
}
case upb_FieldType_Message:
case upb_FieldType_Group:
case kUpb_FieldType_Message:
case kUpb_FieldType_Group:
UPB_ASSERT(has_name);
f->sub.msgdef =
symtab_resolve(ctx, f->full_name, prefix, name, UPB_DEFTYPE_MSG);
break;
case upb_FieldType_Enum:
case kUpb_FieldType_Enum:
UPB_ASSERT(has_name);
f->sub.enumdef =
symtab_resolve(ctx, f->full_name, prefix, name, UPB_DEFTYPE_ENUM);
@ -2790,7 +2790,7 @@ static void resolve_msgdef(symtab_addctx* ctx, upb_MessageDef* m) {
m->in_message_set = false;
if (m->nested_ext_count == 1) {
const upb_FieldDef* ext = &m->nested_exts[0];
if (ext->type_ == upb_FieldType_Message &&
if (ext->type_ == kUpb_FieldType_Message &&
ext->label_ == kUpb_Label_Optional && ext->sub.msgdef == m &&
google_protobuf_MessageOptions_message_set_wire_format(
ext->msgdef->opts)) {

72
upb/encode.c
Unescape View File

@ -216,39 +216,39 @@ static void encode_scalar(upb_encstate* e, const void* _field_mem,
}
switch (f->descriptortype) {
case upb_FieldType_Double:
case kUpb_FieldType_Double:
CASE(double, double, kUpb_WireType_64Bit, val);
case upb_FieldType_Float:
case kUpb_FieldType_Float:
CASE(float, float, kUpb_WireType_32Bit, val);
case upb_FieldType_Int64:
case upb_FieldType_UInt64:
case kUpb_FieldType_Int64:
case kUpb_FieldType_UInt64:
CASE(uint64_t, varint, kUpb_WireType_Varint, val);
case upb_FieldType_UInt32:
case kUpb_FieldType_UInt32:
CASE(uint32_t, varint, kUpb_WireType_Varint, val);
case upb_FieldType_Int32:
case upb_FieldType_Enum:
case kUpb_FieldType_Int32:
case kUpb_FieldType_Enum:
CASE(int32_t, varint, kUpb_WireType_Varint, (int64_t)val);
case upb_FieldType_SFixed64:
case upb_FieldType_Fixed64:
case kUpb_FieldType_SFixed64:
case kUpb_FieldType_Fixed64:
CASE(uint64_t, fixed64, kUpb_WireType_64Bit, val);
case upb_FieldType_Fixed32:
case upb_FieldType_SFixed32:
case kUpb_FieldType_Fixed32:
case kUpb_FieldType_SFixed32:
CASE(uint32_t, fixed32, kUpb_WireType_32Bit, val);
case upb_FieldType_Bool:
case kUpb_FieldType_Bool:
CASE(bool, varint, kUpb_WireType_Varint, val);
case upb_FieldType_SInt32:
case kUpb_FieldType_SInt32:
CASE(int32_t, varint, kUpb_WireType_Varint, encode_zz32(val));
case upb_FieldType_SInt64:
case kUpb_FieldType_SInt64:
CASE(int64_t, varint, kUpb_WireType_Varint, encode_zz64(val));
case upb_FieldType_String:
case upb_FieldType_Bytes: {
case kUpb_FieldType_String:
case kUpb_FieldType_Bytes: {
upb_StringView view = *(upb_StringView*)field_mem;
encode_bytes(e, view.data, view.size);
encode_varint(e, view.size);
wire_type = kUpb_WireType_Delimited;
break;
}
case upb_FieldType_Group: {
case kUpb_FieldType_Group: {
size_t size;
void* submsg = *(void**)field_mem;
const upb_MiniTable* subm = subs[f->submsg_index].submsg;
@ -262,7 +262,7 @@ static void encode_scalar(upb_encstate* e, const void* _field_mem,
e->depth++;
break;
}
case upb_FieldType_Message: {
case kUpb_FieldType_Message: {
size_t size;
void* submsg = *(void**)field_mem;
const upb_MiniTable* subm = subs[f->submsg_index].submsg;
@ -311,36 +311,36 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
#define TAG(wire_type) (packed ? 0 : (f->number << 3 | wire_type))
switch (f->descriptortype) {
case upb_FieldType_Double:
case kUpb_FieldType_Double:
encode_fixedarray(e, arr, sizeof(double), TAG(kUpb_WireType_64Bit));
break;
case upb_FieldType_Float:
case kUpb_FieldType_Float:
encode_fixedarray(e, arr, sizeof(float), TAG(kUpb_WireType_32Bit));
break;
case upb_FieldType_SFixed64:
case upb_FieldType_Fixed64:
case kUpb_FieldType_SFixed64:
case kUpb_FieldType_Fixed64:
encode_fixedarray(e, arr, sizeof(uint64_t), TAG(kUpb_WireType_64Bit));
break;
case upb_FieldType_Fixed32:
case upb_FieldType_SFixed32:
case kUpb_FieldType_Fixed32:
case kUpb_FieldType_SFixed32:
encode_fixedarray(e, arr, sizeof(uint32_t), TAG(kUpb_WireType_32Bit));
break;
case upb_FieldType_Int64:
case upb_FieldType_UInt64:
case kUpb_FieldType_Int64:
case kUpb_FieldType_UInt64:
VARINT_CASE(uint64_t, *ptr);
case upb_FieldType_UInt32:
case kUpb_FieldType_UInt32:
VARINT_CASE(uint32_t, *ptr);
case upb_FieldType_Int32:
case upb_FieldType_Enum:
case kUpb_FieldType_Int32:
case kUpb_FieldType_Enum:
VARINT_CASE(int32_t, (int64_t)*ptr);
case upb_FieldType_Bool:
case kUpb_FieldType_Bool:
VARINT_CASE(bool, *ptr);
case upb_FieldType_SInt32:
case kUpb_FieldType_SInt32:
VARINT_CASE(int32_t, encode_zz32(*ptr));
case upb_FieldType_SInt64:
case kUpb_FieldType_SInt64:
VARINT_CASE(int64_t, encode_zz64(*ptr));
case upb_FieldType_String:
case upb_FieldType_Bytes: {
case kUpb_FieldType_String:
case kUpb_FieldType_Bytes: {
const upb_StringView* start = _upb_array_constptr(arr);
const upb_StringView* ptr = start + arr->len;
do {
@ -351,7 +351,7 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
} while (ptr != start);
return;
}
case upb_FieldType_Group: {
case kUpb_FieldType_Group: {
const void* const* start = _upb_array_constptr(arr);
const void* const* ptr = start + arr->len;
const upb_MiniTable* subm = subs[f->submsg_index].submsg;
@ -366,7 +366,7 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
e->depth++;
return;
}
case upb_FieldType_Message: {
case kUpb_FieldType_Message: {
const void* const* start = _upb_array_constptr(arr);
const void* const* ptr = start + arr->len;
const upb_MiniTable* subm = subs[f->submsg_index].submsg;

28
upb/msg.c
Unescape View File

@ -334,30 +334,30 @@ bool _upb_mapsorter_pushmap(_upb_mapsorter* s, upb_FieldType key_type,
int (*compar)(const void*, const void*);
switch (key_type) {
case upb_FieldType_Int64:
case upb_FieldType_SFixed64:
case upb_FieldType_SInt64:
case kUpb_FieldType_Int64:
case kUpb_FieldType_SFixed64:
case kUpb_FieldType_SInt64:
compar = _upb_mapsorter_cmpi64;
break;
case upb_FieldType_UInt64:
case upb_FieldType_Fixed64:
case kUpb_FieldType_UInt64:
case kUpb_FieldType_Fixed64:
compar = _upb_mapsorter_cmpu64;
break;
case upb_FieldType_Int32:
case upb_FieldType_SInt32:
case upb_FieldType_SFixed32:
case upb_FieldType_Enum:
case kUpb_FieldType_Int32:
case kUpb_FieldType_SInt32:
case kUpb_FieldType_SFixed32:
case kUpb_FieldType_Enum:
compar = _upb_mapsorter_cmpi32;
break;
case upb_FieldType_UInt32:
case upb_FieldType_Fixed32:
case kUpb_FieldType_UInt32:
case kUpb_FieldType_Fixed32:
compar = _upb_mapsorter_cmpu32;
break;
case upb_FieldType_Bool:
case kUpb_FieldType_Bool:
compar = _upb_mapsorter_cmpbool;
break;
case upb_FieldType_String:
case upb_FieldType_Bytes:
case kUpb_FieldType_String:
case kUpb_FieldType_Bytes:
compar = _upb_mapsorter_cmpstr;
break;
default:

4
upb/msg_internal.h
Unescape View File

@ -108,8 +108,8 @@ UPB_INLINE bool upb_IsRepeatedOrMap(const upb_MiniTable_Field* field) {
}
UPB_INLINE bool upb_IsSubMessage(const upb_MiniTable_Field* field) {
return field->descriptortype == upb_FieldType_Message ||
field->descriptortype == upb_FieldType_Group;
return field->descriptortype == kUpb_FieldType_Message ||
field->descriptortype == kUpb_FieldType_Group;
}
struct upb_Decoder;

40
upb/reflection.c
Unescape View File

@ -36,24 +36,24 @@
static size_t get_field_size(const upb_MiniTable_Field* f) {
static unsigned char sizes[] = {
0, /* 0 */
8, /* upb_FieldType_Double */
4, /* upb_FieldType_Float */
8, /* upb_FieldType_Int64 */
8, /* upb_FieldType_UInt64 */
4, /* upb_FieldType_Int32 */
8, /* upb_FieldType_Fixed64 */
4, /* upb_FieldType_Fixed32 */
1, /* upb_FieldType_Bool */
sizeof(upb_StringView), /* upb_FieldType_String */
sizeof(void*), /* upb_FieldType_Group */
sizeof(void*), /* upb_FieldType_Message */
sizeof(upb_StringView), /* upb_FieldType_Bytes */
4, /* upb_FieldType_UInt32 */
4, /* upb_FieldType_Enum */
4, /* upb_FieldType_SFixed32 */
8, /* upb_FieldType_SFixed64 */
4, /* upb_FieldType_SInt32 */
8, /* upb_FieldType_SInt64 */
8, /* kUpb_FieldType_Double */
4, /* kUpb_FieldType_Float */
8, /* kUpb_FieldType_Int64 */
8, /* kUpb_FieldType_UInt64 */
4, /* kUpb_FieldType_Int32 */
8, /* kUpb_FieldType_Fixed64 */
4, /* kUpb_FieldType_Fixed32 */
1, /* kUpb_FieldType_Bool */
sizeof(upb_StringView), /* kUpb_FieldType_String */
sizeof(void*), /* kUpb_FieldType_Group */
sizeof(void*), /* kUpb_FieldType_Message */
sizeof(upb_StringView), /* kUpb_FieldType_Bytes */
4, /* kUpb_FieldType_UInt32 */
4, /* kUpb_FieldType_Enum */
4, /* kUpb_FieldType_SFixed32 */
8, /* kUpb_FieldType_SFixed64 */
4, /* kUpb_FieldType_SInt32 */
8, /* kUpb_FieldType_SInt64 */
};
return upb_IsRepeatedOrMap(f) ? sizeof(void*) : sizes[f->descriptortype];
}
@ -121,8 +121,8 @@ bool upb_Message_Has(const upb_Message* msg, const upb_FieldDef* f) {
} else if (field->presence > 0) {
return _upb_hasbit_field(msg, field);
} else {
UPB_ASSERT(field->descriptortype == upb_FieldType_Message ||
field->descriptortype == upb_FieldType_Group);
UPB_ASSERT(field->descriptortype == kUpb_FieldType_Message ||
field->descriptortype == kUpb_FieldType_Group);
return _upb_Message_Getraw(msg, f).msg_val != NULL;
}
}

36
upb/upb.h
Unescape View File

@ -276,24 +276,24 @@ typedef enum {
/* Descriptor types, as defined in descriptor.proto. */
typedef enum {
upb_FieldType_Double = 1,
upb_FieldType_Float = 2,
upb_FieldType_Int64 = 3,
upb_FieldType_UInt64 = 4,
upb_FieldType_Int32 = 5,
upb_FieldType_Fixed64 = 6,
upb_FieldType_Fixed32 = 7,
upb_FieldType_Bool = 8,
upb_FieldType_String = 9,
upb_FieldType_Group = 10,
upb_FieldType_Message = 11,
upb_FieldType_Bytes = 12,
upb_FieldType_UInt32 = 13,
upb_FieldType_Enum = 14,
upb_FieldType_SFixed32 = 15,
upb_FieldType_SFixed64 = 16,
upb_FieldType_SInt32 = 17,
upb_FieldType_SInt64 = 18
kUpb_FieldType_Double = 1,
kUpb_FieldType_Float = 2,
kUpb_FieldType_Int64 = 3,
kUpb_FieldType_UInt64 = 4,
kUpb_FieldType_Int32 = 5,
kUpb_FieldType_Fixed64 = 6,
kUpb_FieldType_Fixed32 = 7,
kUpb_FieldType_Bool = 8,
kUpb_FieldType_String = 9,
kUpb_FieldType_Group = 10,
kUpb_FieldType_Message = 11,
kUpb_FieldType_Bytes = 12,
kUpb_FieldType_UInt32 = 13,
kUpb_FieldType_Enum = 14,
kUpb_FieldType_SFixed32 = 15,
kUpb_FieldType_SFixed64 = 16,
kUpb_FieldType_SInt32 = 17,
kUpb_FieldType_SInt64 = 18
} upb_FieldType;
#define kUpb_Map_Begin ((size_t)-1)

Write Preview
Loading…
Cancel
Save