Protocol Buffers - Google's data interchange format (grpc依赖)
https://developers.google.com/protocol-buffers/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1138 lines
40 KiB
1138 lines
40 KiB
// Protocol Buffers - Google's data interchange format |
|
// Copyright 2023 Google LLC. All rights reserved. |
|
// https://developers.google.com/protocol-buffers/ |
|
// |
|
// Redistribution and use in source and binary forms, with or without |
|
// modification, are permitted provided that the following conditions are |
|
// met: |
|
// |
|
// * Redistributions of source code must retain the above copyright |
|
// notice, this list of conditions and the following disclaimer. |
|
// * Redistributions in binary form must reproduce the above |
|
// copyright notice, this list of conditions and the following disclaimer |
|
// in the documentation and/or other materials provided with the |
|
// distribution. |
|
// * Neither the name of Google LLC nor the names of its |
|
// contributors may be used to endorse or promote products derived from |
|
// this software without specific prior written permission. |
|
// |
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
|
|
#include <algorithm> |
|
#include <cmath> |
|
#include <cstddef> |
|
#include <cstdint> |
|
#include <cstdio> |
|
#include <cstdlib> |
|
#include <limits> |
|
#include <map> |
|
#include <memory> |
|
#include <string> |
|
#include <utility> |
|
#include <vector> |
|
|
|
#include "absl/container/flat_hash_map.h" |
|
#include "absl/container/flat_hash_set.h" |
|
#include "absl/log/absl_check.h" |
|
#include "absl/log/absl_log.h" |
|
#include "absl/strings/escaping.h" |
|
#include "absl/strings/str_replace.h" |
|
#include "absl/strings/string_view.h" |
|
#include "absl/strings/substitute.h" |
|
#include "upb/upb/base/descriptor_constants.h" |
|
#include "upb/upb/base/string_view.h" |
|
#include "upb/upb/reflection/def.hpp" |
|
#include "upb/upb/wire/types.h" |
|
#include "upb/upbc/common.h" |
|
#include "upb/upbc/file_layout.h" |
|
#include "upb/upbc/names.h" |
|
#include "upb/upbc/plugin.h" |
|
|
|
// Must be last. |
|
#include "upb/upb/port/def.inc" |
|
|
|
namespace upbc { |
|
namespace { |
|
|
|
struct Options { |
|
bool bootstrap = false; |
|
}; |
|
|
|
std::string SourceFilename(upb::FileDefPtr file) { |
|
return StripExtension(file.name()) + ".upb.c"; |
|
} |
|
|
|
std::string MessageInitName(upb::MessageDefPtr descriptor) { |
|
return absl::StrCat(MessageName(descriptor), "_msg_init"); |
|
} |
|
|
|
std::string MessageMiniTableRef(upb::MessageDefPtr descriptor, |
|
const Options& options) { |
|
if (options.bootstrap) { |
|
return absl::StrCat(MessageInitName(descriptor), "()"); |
|
} else { |
|
return absl::StrCat("&", MessageInitName(descriptor)); |
|
} |
|
} |
|
|
|
std::string EnumInitName(upb::EnumDefPtr descriptor) { |
|
return ToCIdent(descriptor.full_name()) + "_enum_init"; |
|
} |
|
|
|
std::string EnumMiniTableRef(upb::EnumDefPtr descriptor, |
|
const Options& options) { |
|
if (options.bootstrap) { |
|
return absl::StrCat(EnumInitName(descriptor), "()"); |
|
} else { |
|
return absl::StrCat("&", EnumInitName(descriptor)); |
|
} |
|
} |
|
|
|
std::string ExtensionIdentBase(upb::FieldDefPtr ext) { |
|
assert(ext.is_extension()); |
|
std::string ext_scope; |
|
if (ext.extension_scope()) { |
|
return MessageName(ext.extension_scope()); |
|
} else { |
|
return ToCIdent(ext.file().package()); |
|
} |
|
} |
|
|
|
std::string ExtensionLayout(upb::FieldDefPtr ext) { |
|
return absl::StrCat(ExtensionIdentBase(ext), "_", ext.name(), "_ext"); |
|
} |
|
|
|
std::string EnumValueSymbol(upb::EnumValDefPtr value) { |
|
return ToCIdent(value.full_name()); |
|
} |
|
|
|
std::string CTypeInternal(upb::FieldDefPtr field, bool is_const) { |
|
std::string maybe_const = is_const ? "const " : ""; |
|
switch (field.ctype()) { |
|
case kUpb_CType_Message: { |
|
std::string maybe_struct = |
|
field.file() != field.message_type().file() ? "struct " : ""; |
|
return maybe_const + maybe_struct + MessageName(field.message_type()) + |
|
"*"; |
|
} |
|
case kUpb_CType_Bool: |
|
return "bool"; |
|
case kUpb_CType_Float: |
|
return "float"; |
|
case kUpb_CType_Int32: |
|
case kUpb_CType_Enum: |
|
return "int32_t"; |
|
case kUpb_CType_UInt32: |
|
return "uint32_t"; |
|
case kUpb_CType_Double: |
|
return "double"; |
|
case kUpb_CType_Int64: |
|
return "int64_t"; |
|
case kUpb_CType_UInt64: |
|
return "uint64_t"; |
|
case kUpb_CType_String: |
|
case kUpb_CType_Bytes: |
|
return "upb_StringView"; |
|
default: |
|
abort(); |
|
} |
|
} |
|
|
|
std::string FloatToCLiteral(float value) { |
|
if (value == std::numeric_limits<float>::infinity()) { |
|
return "kUpb_FltInfinity"; |
|
} else if (value == -std::numeric_limits<float>::infinity()) { |
|
return "-kUpb_FltInfinity"; |
|
} else if (std::isnan(value)) { |
|
return "kUpb_NaN"; |
|
} else { |
|
return absl::StrCat(value); |
|
} |
|
} |
|
|
|
std::string DoubleToCLiteral(double value) { |
|
if (value == std::numeric_limits<double>::infinity()) { |
|
return "kUpb_Infinity"; |
|
} else if (value == -std::numeric_limits<double>::infinity()) { |
|
return "-kUpb_Infinity"; |
|
} else if (std::isnan(value)) { |
|
return "kUpb_NaN"; |
|
} else { |
|
return absl::StrCat(value); |
|
} |
|
} |
|
|
|
// Escape trigraphs by escaping question marks to \? |
|
std::string EscapeTrigraphs(absl::string_view to_escape) { |
|
return absl::StrReplaceAll(to_escape, {{"?", "\\?"}}); |
|
} |
|
|
|
std::string FieldDefault(upb::FieldDefPtr field) { |
|
switch (field.ctype()) { |
|
case kUpb_CType_Message: |
|
return "NULL"; |
|
case kUpb_CType_Bytes: |
|
case kUpb_CType_String: { |
|
upb_StringView str = field.default_value().str_val; |
|
return absl::Substitute("upb_StringView_FromString(\"$0\")", |
|
EscapeTrigraphs(absl::CEscape( |
|
absl::string_view(str.data, str.size)))); |
|
} |
|
case kUpb_CType_Int32: |
|
return absl::Substitute("(int32_t)$0", field.default_value().int32_val); |
|
case kUpb_CType_Int64: |
|
if (field.default_value().int64_val == INT64_MIN) { |
|
// Special-case to avoid: |
|
// integer literal is too large to be represented in a signed integer |
|
// type, interpreting as unsigned |
|
// [-Werror,-Wimplicitly-unsigned-literal] |
|
// int64_t default_val = (int64_t)-9223372036854775808ll; |
|
// |
|
// More info here: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52661 |
|
return "INT64_MIN"; |
|
} else { |
|
return absl::Substitute("(int64_t)$0ll", |
|
field.default_value().int64_val); |
|
} |
|
case kUpb_CType_UInt32: |
|
return absl::Substitute("(uint32_t)$0u", |
|
field.default_value().uint32_val); |
|
case kUpb_CType_UInt64: |
|
return absl::Substitute("(uint64_t)$0ull", |
|
field.default_value().uint64_val); |
|
case kUpb_CType_Float: |
|
return FloatToCLiteral(field.default_value().float_val); |
|
case kUpb_CType_Double: |
|
return DoubleToCLiteral(field.default_value().double_val); |
|
case kUpb_CType_Bool: |
|
return field.default_value().bool_val ? "true" : "false"; |
|
case kUpb_CType_Enum: |
|
// Use a number instead of a symbolic name so that we don't require |
|
// this enum's header to be included. |
|
return absl::StrCat(field.default_value().int32_val); |
|
} |
|
ABSL_ASSERT(false); |
|
return "XXX"; |
|
} |
|
|
|
std::string CType(upb::FieldDefPtr field) { |
|
return CTypeInternal(field, false); |
|
} |
|
|
|
std::string CTypeConst(upb::FieldDefPtr field) { |
|
return CTypeInternal(field, true); |
|
} |
|
|
|
std::string MapKeyCType(upb::FieldDefPtr map_field) { |
|
return CType(map_field.message_type().map_key()); |
|
} |
|
|
|
std::string MapValueCType(upb::FieldDefPtr map_field) { |
|
return CType(map_field.message_type().map_value()); |
|
} |
|
|
|
std::string MapKeySize(upb::FieldDefPtr map_field, absl::string_view expr) { |
|
return map_field.message_type().map_key().ctype() == kUpb_CType_String |
|
? "0" |
|
: absl::StrCat("sizeof(", expr, ")"); |
|
} |
|
|
|
std::string MapValueSize(upb::FieldDefPtr map_field, absl::string_view expr) { |
|
return map_field.message_type().map_value().ctype() == kUpb_CType_String |
|
? "0" |
|
: absl::StrCat("sizeof(", expr, ")"); |
|
} |
|
|
|
std::string FieldInitializer(const DefPoolPair& pools, upb::FieldDefPtr field, |
|
const Options& options); |
|
|
|
void DumpEnumValues(upb::EnumDefPtr desc, Output& output) { |
|
std::vector<upb::EnumValDefPtr> values; |
|
values.reserve(desc.value_count()); |
|
for (int i = 0; i < desc.value_count(); i++) { |
|
values.push_back(desc.value(i)); |
|
} |
|
std::sort(values.begin(), values.end(), |
|
[](upb::EnumValDefPtr a, upb::EnumValDefPtr b) { |
|
return a.number() < b.number(); |
|
}); |
|
|
|
for (size_t i = 0; i < values.size(); i++) { |
|
auto value = values[i]; |
|
output(" $0 = $1", EnumValueSymbol(value), value.number()); |
|
if (i != values.size() - 1) { |
|
output(","); |
|
} |
|
output("\n"); |
|
} |
|
} |
|
|
|
std::string GetFieldRep(const DefPoolPair& pools, upb::FieldDefPtr field) { |
|
return upbc::GetFieldRep(pools.GetField32(field), pools.GetField64(field)); |
|
} |
|
|
|
void GenerateExtensionInHeader(const DefPoolPair& pools, upb::FieldDefPtr ext, |
|
Output& output) { |
|
output( |
|
R"cc( |
|
UPB_INLINE bool $0_has_$1(const struct $2* msg) { |
|
return _upb_Message_HasExtensionField(msg, &$3); |
|
} |
|
)cc", |
|
ExtensionIdentBase(ext), ext.name(), MessageName(ext.containing_type()), |
|
ExtensionLayout(ext)); |
|
|
|
output( |
|
R"cc( |
|
UPB_INLINE void $0_clear_$1(struct $2* msg) { |
|
_upb_Message_ClearExtensionField(msg, &$3); |
|
} |
|
)cc", |
|
ExtensionIdentBase(ext), ext.name(), MessageName(ext.containing_type()), |
|
ExtensionLayout(ext)); |
|
|
|
if (ext.IsSequence()) { |
|
// TODO(b/259861668): We need generated accessors for repeated extensions. |
|
} else { |
|
output( |
|
R"cc( |
|
UPB_INLINE $0 $1_$2(const struct $3* msg) { |
|
const upb_MiniTableExtension* ext = &$4; |
|
UPB_ASSUME(!upb_IsRepeatedOrMap(&ext->field)); |
|
UPB_ASSUME(_upb_MiniTableField_GetRep(&ext->field) == $5); |
|
$0 default_val = $6; |
|
$0 ret; |
|
_upb_Message_GetExtensionField(msg, ext, &default_val, &ret); |
|
return ret; |
|
} |
|
)cc", |
|
CTypeConst(ext), ExtensionIdentBase(ext), ext.name(), |
|
MessageName(ext.containing_type()), ExtensionLayout(ext), |
|
GetFieldRep(pools, ext), FieldDefault(ext)); |
|
output( |
|
R"cc( |
|
UPB_INLINE void $1_set_$2(struct $3* msg, $0 val, upb_Arena* arena) { |
|
const upb_MiniTableExtension* ext = &$4; |
|
UPB_ASSUME(!upb_IsRepeatedOrMap(&ext->field)); |
|
UPB_ASSUME(_upb_MiniTableField_GetRep(&ext->field) == $5); |
|
bool ok = _upb_Message_SetExtensionField(msg, ext, &val, arena); |
|
UPB_ASSERT(ok); |
|
} |
|
)cc", |
|
CTypeConst(ext), ExtensionIdentBase(ext), ext.name(), |
|
MessageName(ext.containing_type()), ExtensionLayout(ext), |
|
GetFieldRep(pools, ext)); |
|
} |
|
} |
|
|
|
void GenerateMessageFunctionsInHeader(upb::MessageDefPtr message, |
|
const Options& options, Output& output) { |
|
// TODO(b/235839510): The generated code here does not check the return values |
|
// from upb_Encode(). How can we even fix this without breaking other things? |
|
output( |
|
R"cc( |
|
UPB_INLINE $0* $0_new(upb_Arena* arena) { |
|
return ($0*)_upb_Message_New($1, arena); |
|
} |
|
UPB_INLINE $0* $0_parse(const char* buf, size_t size, upb_Arena* arena) { |
|
$0* ret = $0_new(arena); |
|
if (!ret) return NULL; |
|
if (upb_Decode(buf, size, ret, $1, NULL, 0, arena) != kUpb_DecodeStatus_Ok) { |
|
return NULL; |
|
} |
|
return ret; |
|
} |
|
UPB_INLINE $0* $0_parse_ex(const char* buf, size_t size, |
|
const upb_ExtensionRegistry* extreg, |
|
int options, upb_Arena* arena) { |
|
$0* ret = $0_new(arena); |
|
if (!ret) return NULL; |
|
if (upb_Decode(buf, size, ret, $1, extreg, options, arena) != |
|
kUpb_DecodeStatus_Ok) { |
|
return NULL; |
|
} |
|
return ret; |
|
} |
|
UPB_INLINE char* $0_serialize(const $0* msg, upb_Arena* arena, size_t* len) { |
|
char* ptr; |
|
(void)upb_Encode(msg, $1, 0, arena, &ptr, len); |
|
return ptr; |
|
} |
|
UPB_INLINE char* $0_serialize_ex(const $0* msg, int options, |
|
upb_Arena* arena, size_t* len) { |
|
char* ptr; |
|
(void)upb_Encode(msg, $1, options, arena, &ptr, len); |
|
return ptr; |
|
} |
|
)cc", |
|
MessageName(message), MessageMiniTableRef(message, options)); |
|
} |
|
|
|
void GenerateOneofInHeader(upb::OneofDefPtr oneof, const DefPoolPair& pools, |
|
absl::string_view msg_name, const Options& options, |
|
Output& output) { |
|
std::string fullname = ToCIdent(oneof.full_name()); |
|
output("typedef enum {\n"); |
|
for (int j = 0; j < oneof.field_count(); j++) { |
|
upb::FieldDefPtr field = oneof.field(j); |
|
output(" $0_$1 = $2,\n", fullname, field.name(), field.number()); |
|
} |
|
output( |
|
" $0_NOT_SET = 0\n" |
|
"} $0_oneofcases;\n", |
|
fullname); |
|
output( |
|
R"cc( |
|
UPB_INLINE $0_oneofcases $1_$2_case(const $1* msg) { |
|
const upb_MiniTableField field = $3; |
|
return ($0_oneofcases)upb_Message_WhichOneofFieldNumber(msg, &field); |
|
} |
|
)cc", |
|
fullname, msg_name, oneof.name(), |
|
FieldInitializer(pools, oneof.field(0), options)); |
|
} |
|
|
|
void GenerateHazzer(upb::FieldDefPtr field, const DefPoolPair& pools, |
|
absl::string_view msg_name, |
|
const NameToFieldDefMap& field_names, |
|
const Options& options, Output& output) { |
|
std::string resolved_name = ResolveFieldName(field, field_names); |
|
if (field.has_presence()) { |
|
output( |
|
R"cc( |
|
UPB_INLINE bool $0_has_$1(const $0* msg) { |
|
const upb_MiniTableField field = $2; |
|
return _upb_Message_HasNonExtensionField(msg, &field); |
|
} |
|
)cc", |
|
msg_name, resolved_name, FieldInitializer(pools, field, options)); |
|
} else if (field.IsMap()) { |
|
// Do nothing. |
|
} else if (field.IsSequence()) { |
|
// TODO(b/259616267): remove. |
|
output( |
|
R"cc( |
|
UPB_INLINE bool $0_has_$1(const $0* msg) { |
|
size_t size; |
|
$0_$1(msg, &size); |
|
return size != 0; |
|
} |
|
)cc", |
|
msg_name, resolved_name); |
|
} |
|
} |
|
|
|
void GenerateClear(upb::FieldDefPtr field, const DefPoolPair& pools, |
|
absl::string_view msg_name, |
|
const NameToFieldDefMap& field_names, const Options& options, |
|
Output& output) { |
|
if (field == field.containing_type().map_key() || |
|
field == field.containing_type().map_value()) { |
|
// Cannot be cleared. |
|
return; |
|
} |
|
std::string resolved_name = ResolveFieldName(field, field_names); |
|
output( |
|
R"cc( |
|
UPB_INLINE void $0_clear_$1($0* msg) { |
|
const upb_MiniTableField field = $2; |
|
_upb_Message_ClearNonExtensionField(msg, &field); |
|
} |
|
)cc", |
|
msg_name, resolved_name, FieldInitializer(pools, field, options)); |
|
} |
|
|
|
void GenerateMapGetters(upb::FieldDefPtr field, const DefPoolPair& pools, |
|
absl::string_view msg_name, |
|
const NameToFieldDefMap& field_names, |
|
const Options& options, Output& output) { |
|
std::string resolved_name = ResolveFieldName(field, field_names); |
|
output( |
|
R"cc( |
|
UPB_INLINE size_t $0_$1_size(const $0* msg) { |
|
const upb_MiniTableField field = $2; |
|
const upb_Map* map = upb_Message_GetMap(msg, &field); |
|
return map ? _upb_Map_Size(map) : 0; |
|
} |
|
)cc", |
|
msg_name, resolved_name, FieldInitializer(pools, field, options)); |
|
output( |
|
R"cc( |
|
UPB_INLINE bool $0_$1_get(const $0* msg, $2 key, $3* val) { |
|
const upb_MiniTableField field = $4; |
|
const upb_Map* map = upb_Message_GetMap(msg, &field); |
|
if (!map) return false; |
|
return _upb_Map_Get(map, &key, $5, val, $6); |
|
} |
|
)cc", |
|
msg_name, resolved_name, MapKeyCType(field), MapValueCType(field), |
|
FieldInitializer(pools, field, options), MapKeySize(field, "key"), |
|
MapValueSize(field, "*val")); |
|
output( |
|
R"cc( |
|
UPB_INLINE $0 $1_$2_next(const $1* msg, size_t* iter) { |
|
const upb_MiniTableField field = $3; |
|
const upb_Map* map = upb_Message_GetMap(msg, &field); |
|
if (!map) return NULL; |
|
return ($0)_upb_map_next(map, iter); |
|
} |
|
)cc", |
|
CTypeConst(field), msg_name, resolved_name, |
|
FieldInitializer(pools, field, options)); |
|
} |
|
|
|
void GenerateMapEntryGetters(upb::FieldDefPtr field, absl::string_view msg_name, |
|
Output& output) { |
|
output( |
|
R"cc( |
|
UPB_INLINE $0 $1_$2(const $1* msg) { |
|
$3 ret; |
|
_upb_msg_map_$2(msg, &ret, $4); |
|
return ret; |
|
} |
|
)cc", |
|
CTypeConst(field), msg_name, field.name(), CType(field), |
|
field.ctype() == kUpb_CType_String ? "0" : "sizeof(ret)"); |
|
} |
|
|
|
void GenerateRepeatedGetters(upb::FieldDefPtr field, const DefPoolPair& pools, |
|
absl::string_view msg_name, |
|
const NameToFieldDefMap& field_names, |
|
const Options& options, Output& output) { |
|
// Generate getter returning first item and size. |
|
// |
|
// Example: |
|
// UPB_INLINE const struct Bar* const* name(const Foo* msg, size_t* size) |
|
output( |
|
R"cc( |
|
UPB_INLINE $0 const* $1_$2(const $1* msg, size_t* size) { |
|
const upb_MiniTableField field = $3; |
|
const upb_Array* arr = upb_Message_GetArray(msg, &field); |
|
if (arr) { |
|
if (size) *size = arr->size; |
|
return ($0 const*)_upb_array_constptr(arr); |
|
} else { |
|
if (size) *size = 0; |
|
return NULL; |
|
} |
|
} |
|
)cc", |
|
CTypeConst(field), // $0 |
|
msg_name, // $1 |
|
ResolveFieldName(field, field_names), // $2 |
|
FieldInitializer(pools, field, options) // #3 |
|
); |
|
// Generate private getter returning array or NULL for immutable and upb_Array |
|
// for mutable. |
|
// |
|
// Example: |
|
// UPB_INLINE const upb_Array* _name_upbarray(size_t* size) |
|
// UPB_INLINE upb_Array* _name_mutable_upbarray(size_t* size) |
|
output( |
|
R"cc( |
|
UPB_INLINE const upb_Array* _$1_$2_$4(const $1* msg, size_t* size) { |
|
const upb_MiniTableField field = $3; |
|
const upb_Array* arr = upb_Message_GetArray(msg, &field); |
|
if (size) { |
|
*size = arr ? arr->size : 0; |
|
} |
|
return arr; |
|
} |
|
UPB_INLINE upb_Array* _$1_$2_$5(const $1* msg, size_t* size, upb_Arena* arena) { |
|
const upb_MiniTableField field = $3; |
|
upb_Array* arr = upb_Message_GetOrCreateMutableArray( |
|
(upb_Message*)msg, &field, arena); |
|
if (size) { |
|
*size = arr ? arr->size : 0; |
|
} |
|
return arr; |
|
} |
|
)cc", |
|
CTypeConst(field), // $0 |
|
msg_name, // $1 |
|
ResolveFieldName(field, field_names), // $2 |
|
FieldInitializer(pools, field, options), // $3 |
|
kRepeatedFieldArrayGetterPostfix, // $4 |
|
kRepeatedFieldMutableArrayGetterPostfix // $5 |
|
); |
|
} |
|
|
|
void GenerateScalarGetters(upb::FieldDefPtr field, const DefPoolPair& pools, |
|
absl::string_view msg_name, |
|
const NameToFieldDefMap& field_names, |
|
const Options& Options, Output& output) { |
|
std::string field_name = ResolveFieldName(field, field_names); |
|
output( |
|
R"cc( |
|
UPB_INLINE $0 $1_$2(const $1* msg) { |
|
$0 default_val = $3; |
|
$0 ret; |
|
const upb_MiniTableField field = $4; |
|
_upb_Message_GetNonExtensionField(msg, &field, &default_val, &ret); |
|
return ret; |
|
} |
|
)cc", |
|
CTypeConst(field), msg_name, field_name, FieldDefault(field), |
|
FieldInitializer(pools, field, Options)); |
|
} |
|
|
|
void GenerateGetters(upb::FieldDefPtr field, const DefPoolPair& pools, |
|
absl::string_view msg_name, |
|
const NameToFieldDefMap& field_names, |
|
const Options& options, Output& output) { |
|
if (field.IsMap()) { |
|
GenerateMapGetters(field, pools, msg_name, field_names, options, output); |
|
} else if (UPB_DESC(MessageOptions_map_entry)( |
|
field.containing_type().options())) { |
|
GenerateMapEntryGetters(field, msg_name, output); |
|
} else if (field.IsSequence()) { |
|
GenerateRepeatedGetters(field, pools, msg_name, field_names, options, |
|
output); |
|
} else { |
|
GenerateScalarGetters(field, pools, msg_name, field_names, options, output); |
|
} |
|
} |
|
|
|
void GenerateMapSetters(upb::FieldDefPtr field, const DefPoolPair& pools, |
|
absl::string_view msg_name, |
|
const NameToFieldDefMap& field_names, |
|
const Options& options, Output& output) { |
|
std::string resolved_name = ResolveFieldName(field, field_names); |
|
output( |
|
R"cc( |
|
UPB_INLINE void $0_$1_clear($0* msg) { |
|
const upb_MiniTableField field = $2; |
|
upb_Map* map = (upb_Map*)upb_Message_GetMap(msg, &field); |
|
if (!map) return; |
|
_upb_Map_Clear(map); |
|
} |
|
)cc", |
|
msg_name, resolved_name, FieldInitializer(pools, field, options)); |
|
output( |
|
R"cc( |
|
UPB_INLINE bool $0_$1_set($0* msg, $2 key, $3 val, upb_Arena* a) { |
|
const upb_MiniTableField field = $4; |
|
upb_Map* map = _upb_Message_GetOrCreateMutableMap(msg, &field, $5, $6, a); |
|
return _upb_Map_Insert(map, &key, $5, &val, $6, a) != |
|
kUpb_MapInsertStatus_OutOfMemory; |
|
} |
|
)cc", |
|
msg_name, resolved_name, MapKeyCType(field), MapValueCType(field), |
|
FieldInitializer(pools, field, options), MapKeySize(field, "key"), |
|
MapValueSize(field, "val")); |
|
output( |
|
R"cc( |
|
UPB_INLINE bool $0_$1_delete($0* msg, $2 key) { |
|
const upb_MiniTableField field = $3; |
|
upb_Map* map = (upb_Map*)upb_Message_GetMap(msg, &field); |
|
if (!map) return false; |
|
return _upb_Map_Delete(map, &key, $4, NULL); |
|
} |
|
)cc", |
|
msg_name, resolved_name, MapKeyCType(field), |
|
FieldInitializer(pools, field, options), MapKeySize(field, "key")); |
|
output( |
|
R"cc( |
|
UPB_INLINE $0 $1_$2_nextmutable($1* msg, size_t* iter) { |
|
const upb_MiniTableField field = $3; |
|
upb_Map* map = (upb_Map*)upb_Message_GetMap(msg, &field); |
|
if (!map) return NULL; |
|
return ($0)_upb_map_next(map, iter); |
|
} |
|
)cc", |
|
CType(field), msg_name, resolved_name, |
|
FieldInitializer(pools, field, options)); |
|
} |
|
|
|
void GenerateRepeatedSetters(upb::FieldDefPtr field, const DefPoolPair& pools, |
|
absl::string_view msg_name, |
|
const NameToFieldDefMap& field_names, |
|
const Options& options, Output& output) { |
|
std::string resolved_name = ResolveFieldName(field, field_names); |
|
output( |
|
R"cc( |
|
UPB_INLINE $0* $1_mutable_$2($1* msg, size_t* size) { |
|
upb_MiniTableField field = $3; |
|
upb_Array* arr = upb_Message_GetMutableArray(msg, &field); |
|
if (arr) { |
|
if (size) *size = arr->size; |
|
return ($0*)_upb_array_ptr(arr); |
|
} else { |
|
if (size) *size = 0; |
|
return NULL; |
|
} |
|
} |
|
)cc", |
|
CType(field), msg_name, resolved_name, |
|
FieldInitializer(pools, field, options)); |
|
output( |
|
R"cc( |
|
UPB_INLINE $0* $1_resize_$2($1* msg, size_t size, upb_Arena* arena) { |
|
upb_MiniTableField field = $3; |
|
return ($0*)upb_Message_ResizeArrayUninitialized(msg, &field, size, arena); |
|
} |
|
)cc", |
|
CType(field), msg_name, resolved_name, |
|
FieldInitializer(pools, field, options)); |
|
if (field.ctype() == kUpb_CType_Message) { |
|
output( |
|
R"cc( |
|
UPB_INLINE struct $0* $1_add_$2($1* msg, upb_Arena* arena) { |
|
upb_MiniTableField field = $4; |
|
upb_Array* arr = upb_Message_GetOrCreateMutableArray(msg, &field, arena); |
|
if (!arr || !_upb_Array_ResizeUninitialized(arr, arr->size + 1, arena)) { |
|
return NULL; |
|
} |
|
struct $0* sub = (struct $0*)_upb_Message_New($3, arena); |
|
if (!arr || !sub) return NULL; |
|
_upb_Array_Set(arr, arr->size - 1, &sub, sizeof(sub)); |
|
return sub; |
|
} |
|
)cc", |
|
MessageName(field.message_type()), msg_name, resolved_name, |
|
MessageMiniTableRef(field.message_type(), options), |
|
FieldInitializer(pools, field, options)); |
|
} else { |
|
output( |
|
R"cc( |
|
UPB_INLINE bool $1_add_$2($1* msg, $0 val, upb_Arena* arena) { |
|
upb_MiniTableField field = $3; |
|
upb_Array* arr = upb_Message_GetOrCreateMutableArray(msg, &field, arena); |
|
if (!arr || !_upb_Array_ResizeUninitialized(arr, arr->size + 1, arena)) { |
|
return false; |
|
} |
|
_upb_Array_Set(arr, arr->size - 1, &val, sizeof(val)); |
|
return true; |
|
} |
|
)cc", |
|
CType(field), msg_name, resolved_name, |
|
FieldInitializer(pools, field, options)); |
|
} |
|
} |
|
|
|
void GenerateNonRepeatedSetters(upb::FieldDefPtr field, |
|
const DefPoolPair& pools, |
|
absl::string_view msg_name, |
|
const NameToFieldDefMap& field_names, |
|
const Options& options, Output& output) { |
|
if (field == field.containing_type().map_key()) { |
|
// Key cannot be mutated. |
|
return; |
|
} |
|
|
|
std::string field_name = ResolveFieldName(field, field_names); |
|
|
|
if (field == field.containing_type().map_value()) { |
|
output(R"cc( |
|
UPB_INLINE void $0_set_$1($0 *msg, $2 value) { |
|
_upb_msg_map_set_value(msg, &value, $3); |
|
} |
|
)cc", |
|
msg_name, field_name, CType(field), |
|
field.ctype() == kUpb_CType_String ? "0" |
|
: "sizeof(" + CType(field) + ")"); |
|
} else { |
|
output(R"cc( |
|
UPB_INLINE void $0_set_$1($0 *msg, $2 value) { |
|
const upb_MiniTableField field = $3; |
|
_upb_Message_SetNonExtensionField(msg, &field, &value); |
|
} |
|
)cc", |
|
msg_name, field_name, CType(field), |
|
FieldInitializer(pools, field, options)); |
|
} |
|
|
|
// Message fields also have a Msg_mutable_foo() accessor that will create |
|
// the sub-message if it doesn't already exist. |
|
if (field.ctype() == kUpb_CType_Message && |
|
!UPB_DESC(MessageOptions_map_entry)(field.containing_type().options())) { |
|
output( |
|
R"cc( |
|
UPB_INLINE struct $0* $1_mutable_$2($1* msg, upb_Arena* arena) { |
|
struct $0* sub = (struct $0*)$1_$2(msg); |
|
if (sub == NULL) { |
|
sub = (struct $0*)_upb_Message_New($3, arena); |
|
if (sub) $1_set_$2(msg, sub); |
|
} |
|
return sub; |
|
} |
|
)cc", |
|
MessageName(field.message_type()), msg_name, field_name, |
|
MessageMiniTableRef(field.message_type(), options)); |
|
} |
|
} |
|
|
|
void GenerateSetters(upb::FieldDefPtr field, const DefPoolPair& pools, |
|
absl::string_view msg_name, |
|
const NameToFieldDefMap& field_names, |
|
const Options& options, Output& output) { |
|
if (field.IsMap()) { |
|
GenerateMapSetters(field, pools, msg_name, field_names, options, output); |
|
} else if (field.IsSequence()) { |
|
GenerateRepeatedSetters(field, pools, msg_name, field_names, options, |
|
output); |
|
} else { |
|
GenerateNonRepeatedSetters(field, pools, msg_name, field_names, options, |
|
output); |
|
} |
|
} |
|
|
|
void GenerateMessageInHeader(upb::MessageDefPtr message, |
|
const DefPoolPair& pools, const Options& options, |
|
Output& output) { |
|
output("/* $0 */\n\n", message.full_name()); |
|
std::string msg_name = ToCIdent(message.full_name()); |
|
if (!UPB_DESC(MessageOptions_map_entry)(message.options())) { |
|
GenerateMessageFunctionsInHeader(message, options, output); |
|
} |
|
|
|
for (int i = 0; i < message.real_oneof_count(); i++) { |
|
GenerateOneofInHeader(message.oneof(i), pools, msg_name, options, output); |
|
} |
|
|
|
auto field_names = CreateFieldNameMap(message); |
|
for (auto field : FieldNumberOrder(message)) { |
|
GenerateClear(field, pools, msg_name, field_names, options, output); |
|
GenerateGetters(field, pools, msg_name, field_names, options, output); |
|
GenerateHazzer(field, pools, msg_name, field_names, options, output); |
|
} |
|
|
|
output("\n"); |
|
|
|
for (auto field : FieldNumberOrder(message)) { |
|
GenerateSetters(field, pools, msg_name, field_names, options, output); |
|
} |
|
|
|
output("\n"); |
|
} |
|
|
|
void ForwardDeclareMiniTableInit(upb::MessageDefPtr message, |
|
const Options& options, Output& output) { |
|
if (options.bootstrap) { |
|
output("extern const upb_MiniTable* $0();\n", MessageInitName(message)); |
|
} else { |
|
output("extern const upb_MiniTable $0;\n", MessageInitName(message)); |
|
} |
|
} |
|
|
|
void WriteHeader(const DefPoolPair& pools, upb::FileDefPtr file, |
|
const Options& options, Output& output) { |
|
EmitFileWarning(file.name(), output); |
|
output( |
|
"#ifndef $0_UPB_H_\n" |
|
"#define $0_UPB_H_\n\n" |
|
"#include \"upb/upb/generated_code_support.h\"\n", |
|
ToPreproc(file.name())); |
|
|
|
for (int i = 0; i < file.public_dependency_count(); i++) { |
|
if (i == 0) { |
|
output("/* Public Imports. */\n"); |
|
} |
|
output("#include \"$0\"\n", CApiHeaderFilename(file.public_dependency(i))); |
|
if (i == file.public_dependency_count() - 1) { |
|
output("\n"); |
|
} |
|
} |
|
|
|
output( |
|
"// Must be last. \n" |
|
"#include \"upb/upb/port/def.inc\"\n" |
|
"\n" |
|
"#ifdef __cplusplus\n" |
|
"extern \"C\" {\n" |
|
"#endif\n" |
|
"\n"); |
|
|
|
const std::vector<upb::MessageDefPtr> this_file_messages = |
|
SortedMessages(file); |
|
const std::vector<upb::FieldDefPtr> this_file_exts = SortedExtensions(file); |
|
|
|
// Forward-declare types defined in this file. |
|
for (auto message : this_file_messages) { |
|
output("typedef struct $0 $0;\n", ToCIdent(message.full_name())); |
|
} |
|
for (auto message : this_file_messages) { |
|
ForwardDeclareMiniTableInit(message, options, output); |
|
} |
|
for (auto ext : this_file_exts) { |
|
output("extern const upb_MiniTableExtension $0;\n", ExtensionLayout(ext)); |
|
} |
|
|
|
// Forward-declare types not in this file, but used as submessages. |
|
// Order by full name for consistent ordering. |
|
std::map<std::string, upb::MessageDefPtr> forward_messages; |
|
|
|
for (auto message : this_file_messages) { |
|
for (int i = 0; i < message.field_count(); i++) { |
|
upb::FieldDefPtr field = message.field(i); |
|
if (field.ctype() == kUpb_CType_Message && |
|
field.file() != field.message_type().file()) { |
|
forward_messages[field.message_type().full_name()] = |
|
field.message_type(); |
|
} |
|
} |
|
} |
|
for (auto ext : this_file_exts) { |
|
if (ext.file() != ext.containing_type().file()) { |
|
forward_messages[ext.containing_type().full_name()] = |
|
ext.containing_type(); |
|
} |
|
} |
|
for (const auto& pair : forward_messages) { |
|
output("struct $0;\n", MessageName(pair.second)); |
|
} |
|
for (const auto& pair : forward_messages) { |
|
ForwardDeclareMiniTableInit(pair.second, options, output); |
|
} |
|
|
|
if (!this_file_messages.empty()) { |
|
output("\n"); |
|
} |
|
|
|
std::vector<upb::EnumDefPtr> this_file_enums = SortedEnums(file); |
|
|
|
for (auto enumdesc : this_file_enums) { |
|
output("typedef enum {\n"); |
|
DumpEnumValues(enumdesc, output); |
|
output("} $0;\n\n", ToCIdent(enumdesc.full_name())); |
|
} |
|
|
|
output("\n"); |
|
|
|
if (file.syntax() == kUpb_Syntax_Proto2) { |
|
for (const auto enumdesc : this_file_enums) { |
|
if (options.bootstrap) { |
|
output("extern const upb_MiniTableEnum* $0();\n", EnumInit(enumdesc)); |
|
} else { |
|
output("extern const upb_MiniTableEnum $0;\n", EnumInit(enumdesc)); |
|
} |
|
} |
|
} |
|
|
|
output("\n"); |
|
for (auto message : this_file_messages) { |
|
GenerateMessageInHeader(message, pools, options, output); |
|
} |
|
|
|
for (auto ext : this_file_exts) { |
|
GenerateExtensionInHeader(pools, ext, output); |
|
} |
|
|
|
output("extern const upb_MiniTableFile $0;\n\n", FileLayoutName(file)); |
|
|
|
if (absl::string_view(file.name()) == "google/protobuf/descriptor.proto" || |
|
absl::string_view(file.name()) == "net/proto2/proto/descriptor.proto") { |
|
// This is gratuitously inefficient with how many times it rebuilds |
|
// MessageLayout objects for the same message. But we only do this for one |
|
// proto (descriptor.proto) so we don't worry about it. |
|
upb::MessageDefPtr max32_message; |
|
upb::MessageDefPtr max64_message; |
|
size_t max32 = 0; |
|
size_t max64 = 0; |
|
for (const auto message : this_file_messages) { |
|
if (absl::EndsWith(message.name(), "Options")) { |
|
size_t size32 = pools.GetMiniTable32(message)->size; |
|
size_t size64 = pools.GetMiniTable64(message)->size; |
|
if (size32 > max32) { |
|
max32 = size32; |
|
max32_message = message; |
|
} |
|
if (size64 > max64) { |
|
max64 = size64; |
|
max64_message = message; |
|
} |
|
} |
|
} |
|
|
|
output("/* Max size 32 is $0 */\n", max32_message.full_name()); |
|
output("/* Max size 64 is $0 */\n", max64_message.full_name()); |
|
output("#define _UPB_MAXOPT_SIZE UPB_SIZE($0, $1)\n\n", max32, max64); |
|
} |
|
|
|
output( |
|
"#ifdef __cplusplus\n" |
|
"} /* extern \"C\" */\n" |
|
"#endif\n" |
|
"\n" |
|
"#include \"upb/upb/port/undef.inc\"\n" |
|
"\n" |
|
"#endif /* $0_UPB_H_ */\n", |
|
ToPreproc(file.name())); |
|
} |
|
|
|
std::string FieldInitializer(upb::FieldDefPtr field, |
|
const upb_MiniTableField* field64, |
|
const upb_MiniTableField* field32, |
|
const Options& options) { |
|
if (options.bootstrap) { |
|
ABSL_CHECK(!field.is_extension()); |
|
return absl::Substitute( |
|
"*upb_MiniTable_FindFieldByNumber($0, $1)", |
|
MessageMiniTableRef(field.containing_type(), options), field.number()); |
|
} else { |
|
return upbc::FieldInitializer(field, field64, field32); |
|
} |
|
} |
|
|
|
std::string FieldInitializer(const DefPoolPair& pools, upb::FieldDefPtr field, |
|
const Options& options) { |
|
return FieldInitializer(field, pools.GetField64(field), |
|
pools.GetField32(field), options); |
|
} |
|
|
|
void WriteMessageMiniDescriptorInitializer(upb::MessageDefPtr msg, |
|
const Options& options, |
|
Output& output) { |
|
Output resolve_calls; |
|
for (int i = 0; i < msg.field_count(); i++) { |
|
upb::FieldDefPtr field = msg.field(i); |
|
if (!field.message_type() && !field.enum_subdef()) continue; |
|
if (field.message_type()) { |
|
resolve_calls( |
|
"upb_MiniTable_SetSubMessage(mini_table, " |
|
"(upb_MiniTableField*)upb_MiniTable_FindFieldByNumber(mini_table, " |
|
"$0), $1);\n ", |
|
field.number(), MessageMiniTableRef(field.message_type(), options)); |
|
} else if (field.enum_subdef() && field.enum_subdef().is_closed()) { |
|
resolve_calls( |
|
"upb_MiniTable_SetSubEnum(mini_table, " |
|
"(upb_MiniTableField*)upb_MiniTable_FindFieldByNumber(mini_table, " |
|
"$0), $1);\n ", |
|
field.number(), EnumMiniTableRef(field.enum_subdef(), options)); |
|
} |
|
} |
|
|
|
output( |
|
R"cc( |
|
const upb_MiniTable* $0() { |
|
static upb_MiniTable* mini_table = NULL; |
|
static const char* mini_descriptor = "$1"; |
|
if (mini_table) return mini_table; |
|
mini_table = |
|
upb_MiniTable_Build(mini_descriptor, strlen(mini_descriptor), |
|
upb_BootstrapArena(), NULL); |
|
$2return mini_table; |
|
} |
|
)cc", |
|
MessageInitName(msg), msg.MiniDescriptorEncode(), resolve_calls.output()); |
|
output("\n"); |
|
} |
|
|
|
void WriteEnumMiniDescriptorInitializer(upb::EnumDefPtr enum_def, |
|
const Options& options, |
|
Output& output) { |
|
output( |
|
R"cc( |
|
const upb_MiniTableEnum* $0() { |
|
static const upb_MiniTableEnum* mini_table = NULL; |
|
static const char* mini_descriptor = "$1"; |
|
if (mini_table) return mini_table; |
|
mini_table = |
|
upb_MiniTableEnum_Build(mini_descriptor, strlen(mini_descriptor), |
|
upb_BootstrapArena(), NULL); |
|
return mini_table; |
|
} |
|
)cc", |
|
EnumInitName(enum_def), enum_def.MiniDescriptorEncode()); |
|
output("\n"); |
|
} |
|
|
|
void WriteMiniDescriptorSource(const DefPoolPair& pools, upb::FileDefPtr file, |
|
const Options& options, Output& output) { |
|
output( |
|
"#include <stddef.h>\n" |
|
"#include \"upb/upb/generated_code_support.h\"\n" |
|
"#include \"$0\"\n\n", |
|
CApiHeaderFilename(file)); |
|
|
|
for (int i = 0; i < file.dependency_count(); i++) { |
|
output("#include \"$0\"\n", CApiHeaderFilename(file.dependency(i))); |
|
} |
|
|
|
output( |
|
R"cc( |
|
static upb_Arena* upb_BootstrapArena() { |
|
static upb_Arena* arena = NULL; |
|
if (!arena) arena = upb_Arena_New(); |
|
return arena; |
|
} |
|
)cc"); |
|
|
|
output("\n"); |
|
|
|
for (const auto msg : SortedMessages(file)) { |
|
WriteMessageMiniDescriptorInitializer(msg, options, output); |
|
} |
|
|
|
for (const auto msg : SortedEnums(file)) { |
|
WriteEnumMiniDescriptorInitializer(msg, options, output); |
|
} |
|
} |
|
|
|
void GenerateFile(const DefPoolPair& pools, upb::FileDefPtr file, |
|
const Options& options, Plugin* plugin) { |
|
Output h_output; |
|
WriteHeader(pools, file, options, h_output); |
|
plugin->AddOutputFile(CApiHeaderFilename(file), h_output.output()); |
|
|
|
if (options.bootstrap) { |
|
Output c_output; |
|
WriteMiniDescriptorSource(pools, file, options, c_output); |
|
plugin->AddOutputFile(SourceFilename(file), c_output.output()); |
|
} else { |
|
// TODO: remove once we can figure out how to make both Blaze and Bazel |
|
// happy with header-only libraries. |
|
plugin->AddOutputFile(SourceFilename(file), "\n"); |
|
} |
|
} |
|
|
|
bool ParseOptions(Plugin* plugin, Options* options) { |
|
for (const auto& pair : ParseGeneratorParameter(plugin->parameter())) { |
|
if (pair.first == "bootstrap_upb") { |
|
options->bootstrap = true; |
|
} else { |
|
plugin->SetError(absl::Substitute("Unknown parameter: $0", pair.first)); |
|
return false; |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
|
|
absl::string_view ToStringView(upb_StringView str) { |
|
return absl::string_view(str.data, str.size); |
|
} |
|
|
|
} // namespace |
|
|
|
} // namespace upbc |
|
|
|
int main(int argc, char** argv) { |
|
upbc::DefPoolPair pools; |
|
upbc::Plugin plugin; |
|
upbc::Options options; |
|
if (!ParseOptions(&plugin, &options)) return 0; |
|
plugin.GenerateFilesRaw([&](const UPB_DESC(FileDescriptorProto) * file_proto, |
|
bool generate) { |
|
upb::Status status; |
|
upb::FileDefPtr file = pools.AddFile(file_proto, &status); |
|
if (!file) { |
|
absl::string_view name = |
|
upbc::ToStringView(UPB_DESC(FileDescriptorProto_name)(file_proto)); |
|
ABSL_LOG(FATAL) << "Couldn't add file " << name |
|
<< " to DefPool: " << status.error_message(); |
|
} |
|
if (generate) GenerateFile(pools, file, options, &plugin); |
|
}); |
|
return 0; |
|
}
|
|
|