diff --git a/python/descriptor.c b/python/descriptor.c index 7149bb12b5..6286d89b6e 100644 --- a/python/descriptor.c +++ b/python/descriptor.c @@ -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); } diff --git a/python/descriptor_pool.c b/python/descriptor_pool.c index dcb9bc169a..5d7608f774 100644 --- a/python/descriptor_pool.c +++ b/python/descriptor_pool.c @@ -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); diff --git a/rename.sed b/rename.sed index 2648c0029c..771bf74ae2 100644 --- a/rename.sed +++ b/rename.sed @@ -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; diff --git a/run_sed.sh b/run_sed.sh index 20225f6307..ecf872b022 100644 --- a/run_sed.sh +++ b/run_sed.sh @@ -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 diff --git a/upb/bindings/lua/def.c b/upb/bindings/lua/def.c index a9de403618..6716b26a72 100644 --- a/upb/bindings/lua/def.c +++ b/upb/bindings/lua/def.c @@ -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); diff --git a/upb/decode.c b/upb/decode.c index ed84d43b5f..fc903c79d7 100644 --- a/upb/decode.c +++ b/upb/decode.c @@ -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; diff --git a/upb/def.c b/upb/def.c index 25d0b68a27..d8db187c7e 100644 --- a/upb/def.c +++ b/upb/def.c @@ -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)) { diff --git a/upb/encode.c b/upb/encode.c index d5b6cc3759..f03124d230 100644 --- a/upb/encode.c +++ b/upb/encode.c @@ -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; diff --git a/upb/msg.c b/upb/msg.c index ca4e3b391c..3734fc5491 100644 --- a/upb/msg.c +++ b/upb/msg.c @@ -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: diff --git a/upb/msg_internal.h b/upb/msg_internal.h index 257154d084..88c17108f1 100644 --- a/upb/msg_internal.h +++ b/upb/msg_internal.h @@ -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; diff --git a/upb/reflection.c b/upb/reflection.c index 3ff3f559e1..dca1ec25a6 100644 --- a/upb/reflection.c +++ b/upb/reflection.c @@ -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; } } diff --git a/upb/upb.h b/upb/upb.h index d626cc1dff..12aecb46cb 100644 --- a/upb/upb.h +++ b/upb/upb.h @@ -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)