4456 lines
153 KiB
C++
4456 lines
153 KiB
C++
// Protocol Buffers - Google's data interchange format
|
|
// Copyright 2008 Google Inc. 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 Inc. 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.
|
|
|
|
// Author: kenton@google.com (Kenton Varda)
|
|
// Based on original Protocol Buffers design by
|
|
// Sanjay Ghemawat, Jeff Dean, and others.
|
|
|
|
#include <google/protobuf/compiler/cpp/cpp_message.h>
|
|
|
|
#include <algorithm>
|
|
#include <google/protobuf/stubs/hash.h>
|
|
#include <map>
|
|
#include <memory>
|
|
#ifndef _SHARED_PTR_H
|
|
#include <google/protobuf/stubs/shared_ptr.h>
|
|
#endif
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include <google/protobuf/compiler/cpp/cpp_enum.h>
|
|
#include <google/protobuf/compiler/cpp/cpp_extension.h>
|
|
#include <google/protobuf/compiler/cpp/cpp_field.h>
|
|
#include <google/protobuf/compiler/cpp/cpp_helpers.h>
|
|
#include <google/protobuf/compiler/cpp/cpp_padding_optimizer.h>
|
|
#include <google/protobuf/io/coded_stream.h>
|
|
#include <google/protobuf/io/printer.h>
|
|
#include <google/protobuf/descriptor.pb.h>
|
|
#include <google/protobuf/generated_message_table_driven.h>
|
|
#include <google/protobuf/generated_message_util.h>
|
|
#include <google/protobuf/map_entry_lite.h>
|
|
#include <google/protobuf/wire_format.h>
|
|
#include <google/protobuf/stubs/strutil.h>
|
|
#include <google/protobuf/stubs/substitute.h>
|
|
|
|
|
|
namespace google {
|
|
namespace protobuf {
|
|
namespace compiler {
|
|
namespace cpp {
|
|
|
|
using internal::WireFormat;
|
|
using internal::WireFormatLite;
|
|
|
|
namespace {
|
|
|
|
template <class T>
|
|
void PrintFieldComment(io::Printer* printer, const T* field) {
|
|
// Print the field's (or oneof's) proto-syntax definition as a comment.
|
|
// We don't want to print group bodies so we cut off after the first
|
|
// line.
|
|
DebugStringOptions options;
|
|
options.elide_group_body = true;
|
|
options.elide_oneof_body = true;
|
|
string def = field->DebugStringWithOptions(options);
|
|
printer->Print("// $def$\n",
|
|
"def", def.substr(0, def.find_first_of('\n')));
|
|
}
|
|
|
|
struct FieldOrderingByNumber {
|
|
inline bool operator()(const FieldDescriptor* a,
|
|
const FieldDescriptor* b) const {
|
|
return a->number() < b->number();
|
|
}
|
|
};
|
|
|
|
// Sort the fields of the given Descriptor by number into a new[]'d array
|
|
// and return it.
|
|
std::vector<const FieldDescriptor*> SortFieldsByNumber(
|
|
const Descriptor* descriptor) {
|
|
std::vector<const FieldDescriptor*> fields(descriptor->field_count());
|
|
for (int i = 0; i < descriptor->field_count(); i++) {
|
|
fields[i] = descriptor->field(i);
|
|
}
|
|
std::sort(fields.begin(), fields.end(), FieldOrderingByNumber());
|
|
return fields;
|
|
}
|
|
|
|
// Functor for sorting extension ranges by their "start" field number.
|
|
struct ExtensionRangeSorter {
|
|
bool operator()(const Descriptor::ExtensionRange* left,
|
|
const Descriptor::ExtensionRange* right) const {
|
|
return left->start < right->start;
|
|
}
|
|
};
|
|
|
|
bool IsPOD(const FieldDescriptor* field) {
|
|
if (field->is_repeated() || field->is_extension()) return false;
|
|
switch (field->cpp_type()) {
|
|
case internal::WireFormatLite::CPPTYPE_ENUM:
|
|
case internal::WireFormatLite::CPPTYPE_INT32:
|
|
case internal::WireFormatLite::CPPTYPE_INT64:
|
|
case internal::WireFormatLite::CPPTYPE_UINT32:
|
|
case internal::WireFormatLite::CPPTYPE_UINT64:
|
|
case internal::WireFormatLite::CPPTYPE_FLOAT:
|
|
case internal::WireFormatLite::CPPTYPE_DOUBLE:
|
|
case internal::WireFormatLite::CPPTYPE_BOOL:
|
|
return true;
|
|
case internal::WireFormatLite::CPPTYPE_STRING:
|
|
return false;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Helper for the code that emits the SharedCtor() method.
|
|
bool CanConstructByZeroing(const FieldDescriptor* field,
|
|
const Options& options) {
|
|
bool ret = CanInitializeByZeroing(field);
|
|
|
|
// Non-repeated, non-lazy message fields are simply raw pointers, so we can
|
|
// use memset to initialize these in SharedCtor. We cannot use this in
|
|
// Clear, as we need to potentially delete the existing value.
|
|
ret = ret ||
|
|
(!field->is_repeated() &&
|
|
field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE);
|
|
return ret;
|
|
}
|
|
|
|
// Emits an if-statement with a condition that evaluates to true if |field| is
|
|
// considered non-default (will be sent over the wire), for message types
|
|
// without true field presence. Should only be called if
|
|
// !HasFieldPresence(message_descriptor).
|
|
bool EmitFieldNonDefaultCondition(io::Printer* printer,
|
|
const string& prefix,
|
|
const FieldDescriptor* field) {
|
|
// Merge and serialize semantics: primitive fields are merged/serialized only
|
|
// if non-zero (numeric) or non-empty (string).
|
|
if (!field->is_repeated() && !field->containing_oneof()) {
|
|
if (field->cpp_type() == FieldDescriptor::CPPTYPE_STRING) {
|
|
printer->Print(
|
|
"if ($prefix$$name$().size() > 0) {\n",
|
|
"prefix", prefix,
|
|
"name", FieldName(field));
|
|
} else if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
|
|
// Message fields still have has_$name$() methods.
|
|
printer->Print(
|
|
"if ($prefix$has_$name$()) {\n",
|
|
"prefix", prefix,
|
|
"name", FieldName(field));
|
|
} else {
|
|
printer->Print(
|
|
"if ($prefix$$name$() != 0) {\n",
|
|
"prefix", prefix,
|
|
"name", FieldName(field));
|
|
}
|
|
printer->Indent();
|
|
return true;
|
|
} else if (field->containing_oneof()) {
|
|
printer->Print(
|
|
"if (has_$name$()) {\n",
|
|
"name", FieldName(field));
|
|
printer->Indent();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Does the given field have a has_$name$() method?
|
|
bool HasHasMethod(const FieldDescriptor* field) {
|
|
if (HasFieldPresence(field->file())) {
|
|
// In proto1/proto2, every field has a has_$name$() method.
|
|
return true;
|
|
}
|
|
// For message types without true field presence, only fields with a message
|
|
// type have a has_$name$() method.
|
|
return field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE;
|
|
}
|
|
|
|
// Collects map entry message type information.
|
|
void CollectMapInfo(const Descriptor* descriptor,
|
|
std::map<string, string>* variables) {
|
|
GOOGLE_CHECK(IsMapEntryMessage(descriptor));
|
|
std::map<string, string>& vars = *variables;
|
|
const FieldDescriptor* key = descriptor->FindFieldByName("key");
|
|
const FieldDescriptor* val = descriptor->FindFieldByName("value");
|
|
vars["key_cpp"] = PrimitiveTypeName(key->cpp_type());
|
|
switch (val->cpp_type()) {
|
|
case FieldDescriptor::CPPTYPE_MESSAGE:
|
|
vars["val_cpp"] = FieldMessageTypeName(val);
|
|
break;
|
|
case FieldDescriptor::CPPTYPE_ENUM:
|
|
vars["val_cpp"] = ClassName(val->enum_type(), true);
|
|
break;
|
|
default:
|
|
vars["val_cpp"] = PrimitiveTypeName(val->cpp_type());
|
|
}
|
|
vars["key_wire_type"] = "::google::protobuf::internal::WireFormatLite::TYPE_" +
|
|
ToUpper(DeclaredTypeMethodName(key->type()));
|
|
vars["val_wire_type"] = "::google::protobuf::internal::WireFormatLite::TYPE_" +
|
|
ToUpper(DeclaredTypeMethodName(val->type()));
|
|
if (descriptor->file()->syntax() != FileDescriptor::SYNTAX_PROTO3 &&
|
|
val->type() == FieldDescriptor::TYPE_ENUM) {
|
|
const EnumValueDescriptor* default_value = val->default_value_enum();
|
|
vars["default_enum_value"] = Int32ToString(default_value->number());
|
|
} else {
|
|
vars["default_enum_value"] = "0";
|
|
}
|
|
}
|
|
|
|
// Does the given field have a private (internal helper only) has_$name$()
|
|
// method?
|
|
bool HasPrivateHasMethod(const FieldDescriptor* field) {
|
|
// Only for oneofs in message types with no field presence. has_$name$(),
|
|
// based on the oneof case, is still useful internally for generated code.
|
|
return (!HasFieldPresence(field->file()) &&
|
|
field->containing_oneof() != NULL);
|
|
}
|
|
|
|
|
|
bool TableDrivenParsingEnabled(
|
|
const Descriptor* descriptor, const Options& options) {
|
|
if (!options.table_driven_parsing) {
|
|
return false;
|
|
}
|
|
|
|
// Consider table-driven parsing. We only do this if:
|
|
// - We have has_bits for fields. This avoids a check on every field we set
|
|
// when are present (the common case).
|
|
if (!HasFieldPresence(descriptor->file())) {
|
|
return false;
|
|
}
|
|
|
|
const double table_sparseness = 0.5;
|
|
int max_field_number = 0;
|
|
for (int i = 0; i < descriptor->field_count(); i++) {
|
|
const FieldDescriptor* field = descriptor->field(i);
|
|
if (max_field_number < field->number()) {
|
|
max_field_number = field->number();
|
|
}
|
|
|
|
// - There are no weak fields.
|
|
if (field->options().weak()) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// - There range of field numbers is "small"
|
|
if (max_field_number >= (2 << 14)) {
|
|
return false;
|
|
}
|
|
|
|
// - Field numbers are relatively dense within the actual number of fields.
|
|
// We check for strictly greater than in the case where there are no fields
|
|
// (only extensions) so max_field_number == descriptor->field_count() == 0.
|
|
if (max_field_number * table_sparseness > descriptor->field_count()) {
|
|
return false;
|
|
}
|
|
|
|
// - This is not a MapEntryMessage.
|
|
if (IsMapEntryMessage(descriptor)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void SetUnknkownFieldsVariable(const Descriptor* descriptor,
|
|
const Options& options,
|
|
std::map<string, string>* variables) {
|
|
if (UseUnknownFieldSet(descriptor->file(), options)) {
|
|
(*variables)["unknown_fields_type"] = "::google::protobuf::UnknownFieldSet";
|
|
} else {
|
|
(*variables)["unknown_fields_type"] = "::std::string";
|
|
}
|
|
if (AlwaysPreserveUnknownFields(descriptor)) {
|
|
(*variables)["have_unknown_fields"] =
|
|
"_internal_metadata_.have_unknown_fields()";
|
|
(*variables)["unknown_fields"] = "_internal_metadata_.unknown_fields()";
|
|
} else {
|
|
(*variables)["have_unknown_fields"] =
|
|
"(_internal_metadata_.have_unknown_fields() && "
|
|
" ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())";
|
|
(*variables)["unknown_fields"] =
|
|
"(::google::protobuf::internal::GetProto3PreserveUnknownsDefault()"
|
|
" ? _internal_metadata_.unknown_fields()"
|
|
" : _internal_metadata_.default_instance())";
|
|
}
|
|
(*variables)["mutable_unknown_fields"] =
|
|
"_internal_metadata_.mutable_unknown_fields()";
|
|
}
|
|
|
|
bool IsCrossFileMapField(const FieldDescriptor* field) {
|
|
if (!field->is_map()) {
|
|
return false;
|
|
}
|
|
|
|
const Descriptor* d = field->message_type();
|
|
const FieldDescriptor* value = d->FindFieldByNumber(2);
|
|
|
|
return IsCrossFileMessage(value);
|
|
}
|
|
|
|
bool IsCrossFileMaybeMap(const FieldDescriptor* field) {
|
|
if (IsCrossFileMapField(field)) {
|
|
return true;
|
|
}
|
|
|
|
return IsCrossFileMessage(field);
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
// ===================================================================
|
|
|
|
MessageGenerator::MessageGenerator(const Descriptor* descriptor,
|
|
int index_in_file_messages,
|
|
const Options& options,
|
|
SCCAnalyzer* scc_analyzer)
|
|
: descriptor_(descriptor),
|
|
index_in_file_messages_(index_in_file_messages),
|
|
classname_(ClassName(descriptor, false)),
|
|
options_(options),
|
|
field_generators_(descriptor, options),
|
|
max_has_bit_index_(0),
|
|
enum_generators_(
|
|
new google::protobuf::scoped_ptr<EnumGenerator>[descriptor->enum_type_count()]),
|
|
extension_generators_(new google::protobuf::scoped_ptr<
|
|
ExtensionGenerator>[descriptor->extension_count()]),
|
|
use_dependent_base_(false),
|
|
num_weak_fields_(0),
|
|
message_layout_helper_(new PaddingOptimizer()),
|
|
scc_analyzer_(scc_analyzer) {
|
|
// Compute optimized field order to be used for layout and initialization
|
|
// purposes.
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
const FieldDescriptor* field = descriptor_->field(i);
|
|
if (field->options().weak()) {
|
|
num_weak_fields_++;
|
|
} else if (!field->containing_oneof()) {
|
|
optimized_order_.push_back(field);
|
|
}
|
|
}
|
|
|
|
message_layout_helper_->OptimizeLayout(&optimized_order_, options_);
|
|
|
|
if (HasFieldPresence(descriptor_->file())) {
|
|
// We use -1 as a sentinel.
|
|
has_bit_indices_.resize(descriptor_->field_count(), -1);
|
|
for (int i = 0; i < optimized_order_.size(); i++) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
// Skip fields that do not have has bits.
|
|
if (field->is_repeated()) {
|
|
continue;
|
|
}
|
|
|
|
has_bit_indices_[field->index()] = max_has_bit_index_++;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < descriptor->enum_type_count(); i++) {
|
|
enum_generators_[i].reset(
|
|
new EnumGenerator(descriptor->enum_type(i), options));
|
|
}
|
|
|
|
for (int i = 0; i < descriptor->extension_count(); i++) {
|
|
extension_generators_[i].reset(
|
|
new ExtensionGenerator(descriptor->extension(i), options));
|
|
}
|
|
|
|
num_required_fields_ = 0;
|
|
for (int i = 0; i < descriptor->field_count(); i++) {
|
|
if (descriptor->field(i)->is_required()) {
|
|
++num_required_fields_;
|
|
}
|
|
if (options.proto_h && IsFieldDependent(descriptor->field(i))) {
|
|
use_dependent_base_ = true;
|
|
}
|
|
}
|
|
if (options.proto_h && descriptor->oneof_decl_count() > 0) {
|
|
// Always make oneofs dependent.
|
|
use_dependent_base_ = true;
|
|
}
|
|
|
|
table_driven_ = TableDrivenParsingEnabled(descriptor_, options_);
|
|
|
|
scc_name_ =
|
|
ClassName(scc_analyzer_->GetSCC(descriptor_)->GetRepresentative(), false);
|
|
}
|
|
|
|
MessageGenerator::~MessageGenerator() {}
|
|
|
|
size_t MessageGenerator::HasBitsSize() const {
|
|
size_t sizeof_has_bits = (max_has_bit_index_ + 31) / 32 * 4;
|
|
if (sizeof_has_bits == 0) {
|
|
// Zero-size arrays aren't technically allowed, and MSVC in particular
|
|
// doesn't like them. We still need to declare these arrays to make
|
|
// other code compile. Since this is an uncommon case, we'll just declare
|
|
// them with size 1 and waste some space. Oh well.
|
|
sizeof_has_bits = 4;
|
|
}
|
|
|
|
return sizeof_has_bits;
|
|
}
|
|
|
|
void MessageGenerator::AddGenerators(
|
|
std::vector<EnumGenerator*>* enum_generators,
|
|
std::vector<ExtensionGenerator*>* extension_generators) {
|
|
for (int i = 0; i < descriptor_->enum_type_count(); i++) {
|
|
enum_generators->push_back(enum_generators_[i].get());
|
|
}
|
|
for (int i = 0; i < descriptor_->extension_count(); i++) {
|
|
extension_generators->push_back(extension_generators_[i].get());
|
|
}
|
|
}
|
|
|
|
void MessageGenerator::FillMessageForwardDeclarations(
|
|
std::map<string, const Descriptor*>* class_names) {
|
|
(*class_names)[classname_] = descriptor_;
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateDependentFieldAccessorDeclarations(io::Printer* printer) {
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
const FieldDescriptor* field = descriptor_->field(i);
|
|
|
|
PrintFieldComment(printer, field);
|
|
|
|
std::map<string, string> vars;
|
|
SetCommonFieldVariables(field, &vars, options_);
|
|
|
|
// Generate type-specific accessor declarations.
|
|
field_generators_.get(field).GenerateDependentAccessorDeclarations(printer);
|
|
printer->Print("\n");
|
|
}
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateFieldAccessorDeclarations(io::Printer* printer) {
|
|
// optimized_fields_ does not contain fields where
|
|
// field->containing_oneof() != NULL
|
|
// so we need to iterate over those as well.
|
|
//
|
|
// We place the non-oneof fields in optimized_order_, as that controls the
|
|
// order of the _has_bits_ entries and we want GDB's pretty printers to be
|
|
// able to infer these indices from the k[FIELDNAME]FieldNumber order.
|
|
std::vector<const FieldDescriptor*> ordered_fields;
|
|
ordered_fields.reserve(descriptor_->field_count());
|
|
|
|
ordered_fields.insert(
|
|
ordered_fields.begin(), optimized_order_.begin(), optimized_order_.end());
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
const FieldDescriptor* field = descriptor_->field(i);
|
|
if (field->containing_oneof() == NULL && !field->options().weak()) {
|
|
continue;
|
|
}
|
|
ordered_fields.push_back(field);
|
|
}
|
|
|
|
for (int i = 0; i < ordered_fields.size(); i++) {
|
|
const FieldDescriptor* field = ordered_fields[i];
|
|
|
|
PrintFieldComment(printer, field);
|
|
|
|
std::map<string, string> vars;
|
|
SetCommonFieldVariables(field, &vars, options_);
|
|
vars["constant_name"] = FieldConstantName(field);
|
|
|
|
bool dependent_field = use_dependent_base_ && IsFieldDependent(field);
|
|
if (dependent_field &&
|
|
field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
|
|
!field->is_map()) {
|
|
// If this field is dependent, the dependent base class determines
|
|
// the message type from the derived class (which is a template
|
|
// parameter). This typedef is for that:
|
|
printer->Print(
|
|
"private:\n"
|
|
"typedef $field_type$ $dependent_type$;\n"
|
|
"public:\n",
|
|
"field_type", FieldMessageTypeName(field),
|
|
"dependent_type", DependentTypeName(field));
|
|
}
|
|
|
|
if (field->is_repeated()) {
|
|
printer->Print(vars, "$deprecated_attr$int ${$$name$_size$}$() const;\n");
|
|
printer->Annotate("{", "}", field);
|
|
} else if (HasHasMethod(field)) {
|
|
printer->Print(vars, "$deprecated_attr$bool ${$has_$name$$}$() const;\n");
|
|
printer->Annotate("{", "}", field);
|
|
} else if (HasPrivateHasMethod(field)) {
|
|
printer->Print(vars,
|
|
"private:\n"
|
|
"bool ${$has_$name$$}$() const;\n"
|
|
"public:\n");
|
|
printer->Annotate("{", "}", field);
|
|
}
|
|
|
|
printer->Print(vars, "$deprecated_attr$void ${$clear_$name$$}$();\n");
|
|
printer->Annotate("{", "}", field);
|
|
printer->Print(vars,
|
|
"$deprecated_attr$static const int $constant_name$ = "
|
|
"$number$;\n");
|
|
printer->Annotate("constant_name", field);
|
|
|
|
// Generate type-specific accessor declarations.
|
|
field_generators_.get(field).GenerateAccessorDeclarations(printer);
|
|
|
|
printer->Print("\n");
|
|
}
|
|
|
|
if (descriptor_->extension_range_count() > 0) {
|
|
// Generate accessors for extensions. We just call a macro located in
|
|
// extension_set.h since the accessors about 80 lines of static code.
|
|
printer->Print(
|
|
"GOOGLE_PROTOBUF_EXTENSION_ACCESSORS($classname$)\n",
|
|
"classname", classname_);
|
|
}
|
|
|
|
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
|
|
printer->Print(
|
|
"$camel_oneof_name$Case $oneof_name$_case() const;\n",
|
|
"camel_oneof_name",
|
|
UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), true),
|
|
"oneof_name", descriptor_->oneof_decl(i)->name());
|
|
}
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateDependentFieldAccessorDefinitions(io::Printer* printer) {
|
|
if (!use_dependent_base_) return;
|
|
|
|
printer->Print("// $classname$\n\n", "classname",
|
|
DependentBaseClassTemplateName(descriptor_));
|
|
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
const FieldDescriptor* field = descriptor_->field(i);
|
|
|
|
if (field->options().weak()) continue;
|
|
|
|
PrintFieldComment(printer, field);
|
|
// Generate type-specific accessors.
|
|
field_generators_.get(field)
|
|
.GenerateDependentInlineAccessorDefinitions(printer);
|
|
|
|
printer->Print("\n");
|
|
}
|
|
|
|
// Generate has_$name$() and clear_has_$name$() functions for oneofs
|
|
// Similar to other has-bits, these must always be in the header if we
|
|
// are using a dependent base class.
|
|
GenerateOneofHasBits(printer);
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateSingularFieldHasBits(const FieldDescriptor* field,
|
|
std::map<string, string> vars,
|
|
io::Printer* printer) {
|
|
if (field->options().weak()) {
|
|
printer->Print(
|
|
vars,
|
|
"inline bool $classname$::has_$name$() const {\n"
|
|
" return _weak_field_map_.Has($number$);\n"
|
|
"}\n");
|
|
return;
|
|
}
|
|
if (HasFieldPresence(descriptor_->file())) {
|
|
// N.B.: without field presence, we do not use has-bits or generate
|
|
// has_$name$() methods.
|
|
int has_bit_index = has_bit_indices_[field->index()];
|
|
GOOGLE_CHECK_GE(has_bit_index, 0);
|
|
|
|
vars["has_array_index"] = SimpleItoa(has_bit_index / 32);
|
|
vars["has_mask"] = StrCat(strings::Hex(1u << (has_bit_index % 32),
|
|
strings::ZERO_PAD_8));
|
|
printer->Print(vars,
|
|
"inline bool $classname$::has_$name$() const {\n"
|
|
" return (_has_bits_[$has_array_index$] & 0x$has_mask$u) != 0;\n"
|
|
"}\n"
|
|
"inline void $classname$::set_has_$name$() {\n"
|
|
" _has_bits_[$has_array_index$] |= 0x$has_mask$u;\n"
|
|
"}\n"
|
|
"inline void $classname$::clear_has_$name$() {\n"
|
|
" _has_bits_[$has_array_index$] &= ~0x$has_mask$u;\n"
|
|
"}\n");
|
|
} else {
|
|
// Message fields have a has_$name$() method.
|
|
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
|
|
bool is_lazy = false;
|
|
if (is_lazy) {
|
|
printer->Print(vars,
|
|
"inline bool $classname$::has_$name$() const {\n"
|
|
" return !$name$_.IsCleared();\n"
|
|
"}\n");
|
|
} else {
|
|
printer->Print(
|
|
vars,
|
|
"inline bool $classname$::has_$name$() const {\n"
|
|
" return this != internal_default_instance() && $name$_ != NULL;\n"
|
|
"}\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateOneofHasBits(io::Printer* printer) {
|
|
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
|
|
std::map<string, string> vars;
|
|
vars["oneof_name"] = descriptor_->oneof_decl(i)->name();
|
|
vars["oneof_index"] = SimpleItoa(descriptor_->oneof_decl(i)->index());
|
|
vars["cap_oneof_name"] =
|
|
ToUpper(descriptor_->oneof_decl(i)->name());
|
|
vars["classname"] = classname_;
|
|
printer->Print(
|
|
vars,
|
|
"inline bool $classname$::has_$oneof_name$() const {\n"
|
|
" return $oneof_name$_case() != $cap_oneof_name$_NOT_SET;\n"
|
|
"}\n"
|
|
"inline void $classname$::clear_has_$oneof_name$() {\n"
|
|
" _oneof_case_[$oneof_index$] = $cap_oneof_name$_NOT_SET;\n"
|
|
"}\n");
|
|
}
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateOneofMemberHasBits(const FieldDescriptor* field,
|
|
const std::map<string, string>& vars,
|
|
io::Printer* printer) {
|
|
// Singular field in a oneof
|
|
// N.B.: Without field presence, we do not use has-bits or generate
|
|
// has_$name$() methods, but oneofs still have set_has_$name$().
|
|
// Oneofs also have has_$name$() but only as a private helper
|
|
// method, so that generated code is slightly cleaner (vs. comparing
|
|
// _oneof_case_[index] against a constant everywhere).
|
|
printer->Print(vars,
|
|
"inline bool $classname$::has_$name$() const {\n"
|
|
" return $oneof_name$_case() == k$field_name$;\n"
|
|
"}\n");
|
|
printer->Print(vars,
|
|
"inline void $classname$::set_has_$name$() {\n"
|
|
" _oneof_case_[$oneof_index$] = k$field_name$;\n"
|
|
"}\n");
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateFieldClear(const FieldDescriptor* field,
|
|
const std::map<string, string>& vars,
|
|
bool is_inline,
|
|
io::Printer* printer) {
|
|
// Generate clear_$name$().
|
|
if (is_inline) {
|
|
printer->Print("inline ");
|
|
}
|
|
printer->Print(vars,
|
|
"void $classname$::clear_$name$() {\n");
|
|
|
|
printer->Indent();
|
|
|
|
if (field->containing_oneof()) {
|
|
// Clear this field only if it is the active field in this oneof,
|
|
// otherwise ignore
|
|
printer->Print(vars,
|
|
"if (has_$name$()) {\n");
|
|
printer->Indent();
|
|
field_generators_.get(field)
|
|
.GenerateClearingCode(printer);
|
|
printer->Print(vars,
|
|
"clear_has_$oneof_name$();\n");
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
} else {
|
|
field_generators_.get(field)
|
|
.GenerateClearingCode(printer);
|
|
if (HasFieldPresence(descriptor_->file())) {
|
|
if (!field->is_repeated() && !field->options().weak()) {
|
|
printer->Print(vars, "clear_has_$name$();\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateFieldAccessorDefinitions(io::Printer* printer) {
|
|
printer->Print("// $classname$\n\n", "classname", classname_);
|
|
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
const FieldDescriptor* field = descriptor_->field(i);
|
|
|
|
PrintFieldComment(printer, field);
|
|
|
|
std::map<string, string> vars;
|
|
SetCommonFieldVariables(field, &vars, options_);
|
|
if (use_dependent_base_ && IsFieldDependent(field)) {
|
|
vars["tmpl"] = "template<class T>\n";
|
|
vars["dependent_classname"] =
|
|
DependentBaseClassTemplateName(descriptor_) + "<T>";
|
|
vars["this_message"] = "reinterpret_cast<T*>(this)->";
|
|
vars["this_const_message"] = "reinterpret_cast<const T*>(this)->";
|
|
} else {
|
|
vars["tmpl"] = "";
|
|
vars["dependent_classname"] = vars["classname"];
|
|
vars["this_message"] = "";
|
|
vars["this_const_message"] = "";
|
|
}
|
|
|
|
// Generate has_$name$() or $name$_size().
|
|
if (field->is_repeated()) {
|
|
printer->Print(vars,
|
|
"inline int $classname$::$name$_size() const {\n"
|
|
" return $name$_.size();\n"
|
|
"}\n");
|
|
} else if (field->containing_oneof()) {
|
|
vars["field_name"] = UnderscoresToCamelCase(field->name(), true);
|
|
vars["oneof_name"] = field->containing_oneof()->name();
|
|
vars["oneof_index"] = SimpleItoa(field->containing_oneof()->index());
|
|
GenerateOneofMemberHasBits(field, vars, printer);
|
|
} else {
|
|
// Singular field.
|
|
GenerateSingularFieldHasBits(field, vars, printer);
|
|
}
|
|
|
|
if (!IsCrossFileMaybeMap(field)) {
|
|
GenerateFieldClear(field, vars, true, printer);
|
|
}
|
|
|
|
// Generate type-specific accessors.
|
|
field_generators_.get(field).GenerateInlineAccessorDefinitions(printer);
|
|
|
|
printer->Print("\n");
|
|
}
|
|
|
|
if (!use_dependent_base_) {
|
|
// Generate has_$name$() and clear_has_$name$() functions for oneofs
|
|
// If we aren't using a dependent base, they can be with the other functions
|
|
// that are #ifdef-guarded.
|
|
GenerateOneofHasBits(printer);
|
|
}
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateDependentBaseClassDefinition(io::Printer* printer) {
|
|
if (!use_dependent_base_) {
|
|
return;
|
|
}
|
|
|
|
std::map<string, string> vars;
|
|
vars["classname"] = DependentBaseClassTemplateName(descriptor_);
|
|
vars["full_name"] = descriptor_->full_name();
|
|
vars["superclass"] = SuperClassName(descriptor_, options_);
|
|
|
|
printer->Print(vars,
|
|
"template <class T>\n"
|
|
"class $classname$ : public $superclass$ "
|
|
"/* @@protoc_insertion_point(dep_base_class_definition:$full_name$) */ {\n"
|
|
" public:\n");
|
|
printer->Indent();
|
|
|
|
printer->Print(vars,
|
|
"$classname$() {}\n"
|
|
"virtual ~$classname$() {}\n"
|
|
"\n");
|
|
|
|
// Generate dependent accessor methods for all fields.
|
|
GenerateDependentFieldAccessorDeclarations(printer);
|
|
|
|
printer->Outdent();
|
|
printer->Print("};\n");
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateClassDefinition(io::Printer* printer) {
|
|
if (IsMapEntryMessage(descriptor_)) {
|
|
std::map<string, string> vars;
|
|
vars["classname"] = classname_;
|
|
CollectMapInfo(descriptor_, &vars);
|
|
vars["lite"] =
|
|
HasDescriptorMethods(descriptor_->file(), options_) ? "" : "Lite";
|
|
printer->Print(
|
|
vars,
|
|
"class $classname$ : public "
|
|
"::google::protobuf::internal::MapEntry$lite$<$classname$, \n"
|
|
" $key_cpp$, $val_cpp$,\n"
|
|
" $key_wire_type$,\n"
|
|
" $val_wire_type$,\n"
|
|
" $default_enum_value$ > {\n"
|
|
"public:\n"
|
|
" typedef ::google::protobuf::internal::MapEntry$lite$<$classname$, \n"
|
|
" $key_cpp$, $val_cpp$,\n"
|
|
" $key_wire_type$,\n"
|
|
" $val_wire_type$,\n"
|
|
" $default_enum_value$ > SuperType;\n"
|
|
" $classname$();\n"
|
|
" $classname$(::google::protobuf::Arena* arena);\n"
|
|
" void MergeFrom(const $classname$& other);\n"
|
|
" static const $classname$* internal_default_instance() { return "
|
|
"reinterpret_cast<const "
|
|
"$classname$*>(&_$classname$_default_instance_); }\n");
|
|
if (HasDescriptorMethods(descriptor_->file(), options_)) {
|
|
printer->Print(
|
|
" void MergeFrom(const ::google::protobuf::Message& other) PROTOBUF_FINAL;\n"
|
|
" ::google::protobuf::Metadata GetMetadata() const;\n"
|
|
"};\n");
|
|
} else {
|
|
printer->Print("};\n");
|
|
}
|
|
return;
|
|
}
|
|
if (use_dependent_base_) {
|
|
GenerateDependentBaseClassDefinition(printer);
|
|
printer->Print("\n");
|
|
}
|
|
|
|
std::map<string, string> vars;
|
|
vars["classname"] = classname_;
|
|
vars["full_name"] = descriptor_->full_name();
|
|
vars["field_count"] = SimpleItoa(descriptor_->field_count());
|
|
vars["oneof_decl_count"] = SimpleItoa(descriptor_->oneof_decl_count());
|
|
if (options_.dllexport_decl.empty()) {
|
|
vars["dllexport"] = "";
|
|
} else {
|
|
vars["dllexport"] = options_.dllexport_decl + " ";
|
|
}
|
|
if (use_dependent_base_) {
|
|
vars["superclass"] =
|
|
DependentBaseClassTemplateName(descriptor_) + "<" + classname_ + ">";
|
|
} else {
|
|
vars["superclass"] = SuperClassName(descriptor_, options_);
|
|
}
|
|
printer->Print(vars,
|
|
"class $dllexport$$classname$ : public $superclass$ "
|
|
"/* @@protoc_insertion_point(class_definition:$full_name$) */ "
|
|
"{\n");
|
|
printer->Annotate("classname", descriptor_);
|
|
if (use_dependent_base_) {
|
|
printer->Print(vars, " friend class $superclass$;\n");
|
|
}
|
|
printer->Print(" public:\n");
|
|
printer->Indent();
|
|
|
|
printer->Print(
|
|
vars,
|
|
"$classname$();\n"
|
|
"virtual ~$classname$();\n"
|
|
"\n"
|
|
"$classname$(const $classname$& from);\n"
|
|
"\n"
|
|
"inline $classname$& operator=(const $classname$& from) {\n"
|
|
" CopyFrom(from);\n"
|
|
" return *this;\n"
|
|
"}\n");
|
|
|
|
if (options_.table_driven_serialization) {
|
|
printer->Print(
|
|
"private:\n"
|
|
"const void* InternalGetTable() const;\n"
|
|
"public:\n"
|
|
"\n");
|
|
}
|
|
|
|
// Generate move constructor and move assignment operator.
|
|
printer->Print(vars,
|
|
"#if LANG_CXX11\n"
|
|
"$classname$($classname$&& from) noexcept\n"
|
|
" : $classname$() {\n"
|
|
" *this = ::std::move(from);\n"
|
|
"}\n"
|
|
"\n"
|
|
"inline $classname$& operator=($classname$&& from) noexcept {\n"
|
|
" if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {\n"
|
|
" if (this != &from) InternalSwap(&from);\n"
|
|
" } else {\n"
|
|
" CopyFrom(from);\n"
|
|
" }\n"
|
|
" return *this;\n"
|
|
"}\n"
|
|
"#endif\n");
|
|
|
|
SetUnknkownFieldsVariable(descriptor_, options_, &vars);
|
|
if (PublicUnknownFieldsAccessors(descriptor_)) {
|
|
printer->Print(vars,
|
|
"inline const $unknown_fields_type$& unknown_fields() const {\n"
|
|
" return $unknown_fields$;\n"
|
|
"}\n"
|
|
"inline $unknown_fields_type$* mutable_unknown_fields() {\n"
|
|
" return $mutable_unknown_fields$;\n"
|
|
"}\n"
|
|
"\n");
|
|
}
|
|
|
|
// N.B.: We exclude GetArena() when arena support is disabled, falling back on
|
|
// MessageLite's implementation which returns NULL rather than generating our
|
|
// own method which returns NULL, in order to reduce code size.
|
|
if (SupportsArenas(descriptor_)) {
|
|
// virtual method version of GetArenaNoVirtual(), required for generic dispatch given a
|
|
// MessageLite* (e.g., in RepeatedField::AddAllocated()).
|
|
printer->Print(
|
|
"inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {\n"
|
|
" return GetArenaNoVirtual();\n"
|
|
"}\n"
|
|
"inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {\n"
|
|
" return MaybeArenaPtr();\n"
|
|
"}\n");
|
|
}
|
|
|
|
// Only generate this member if it's not disabled.
|
|
if (HasDescriptorMethods(descriptor_->file(), options_) &&
|
|
!descriptor_->options().no_standard_descriptor_accessor()) {
|
|
printer->Print(vars,
|
|
"static const ::google::protobuf::Descriptor* descriptor();\n");
|
|
}
|
|
|
|
printer->Print(vars,
|
|
"static const $classname$& default_instance();\n"
|
|
"\n");
|
|
|
|
// Generate enum values for every field in oneofs. One list is generated for
|
|
// each oneof with an additional *_NOT_SET value.
|
|
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
|
|
printer->Print(
|
|
"enum $camel_oneof_name$Case {\n",
|
|
"camel_oneof_name",
|
|
UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), true));
|
|
printer->Indent();
|
|
for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
|
|
printer->Print(
|
|
"k$field_name$ = $field_number$,\n",
|
|
"field_name",
|
|
UnderscoresToCamelCase(
|
|
descriptor_->oneof_decl(i)->field(j)->name(), true),
|
|
"field_number",
|
|
SimpleItoa(descriptor_->oneof_decl(i)->field(j)->number()));
|
|
}
|
|
printer->Print(
|
|
"$cap_oneof_name$_NOT_SET = 0,\n",
|
|
"cap_oneof_name",
|
|
ToUpper(descriptor_->oneof_decl(i)->name()));
|
|
printer->Outdent();
|
|
printer->Print(
|
|
"};\n"
|
|
"\n");
|
|
}
|
|
|
|
// TODO(gerbens) make this private, while still granting other protos access.
|
|
vars["message_index"] = SimpleItoa(index_in_file_messages_);
|
|
printer->Print(
|
|
vars,
|
|
"static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY\n"
|
|
"static inline const $classname$* internal_default_instance() {\n"
|
|
" return reinterpret_cast<const $classname$*>(\n"
|
|
" &_$classname$_default_instance_);\n"
|
|
"}\n"
|
|
"static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =\n"
|
|
" $message_index$;\n"
|
|
"\n");
|
|
|
|
if (SupportsArenas(descriptor_)) {
|
|
printer->Print(vars,
|
|
"void UnsafeArenaSwap($classname$* other);\n");
|
|
}
|
|
|
|
if (IsAnyMessage(descriptor_)) {
|
|
printer->Print(vars,
|
|
"// implements Any -----------------------------------------------\n"
|
|
"\n"
|
|
"void PackFrom(const ::google::protobuf::Message& message);\n"
|
|
"void PackFrom(const ::google::protobuf::Message& message,\n"
|
|
" const ::std::string& type_url_prefix);\n"
|
|
"bool UnpackTo(::google::protobuf::Message* message) const;\n"
|
|
"template<typename T> bool Is() const {\n"
|
|
" return _any_metadata_.Is<T>();\n"
|
|
"}\n"
|
|
"\n");
|
|
}
|
|
|
|
vars["new_final"] = " PROTOBUF_FINAL";
|
|
|
|
printer->Print(vars,
|
|
"void Swap($classname$* other);\n"
|
|
"friend void swap($classname$& a, $classname$& b) {\n"
|
|
" a.Swap(&b);\n"
|
|
"}\n"
|
|
"\n"
|
|
"// implements Message ----------------------------------------------\n"
|
|
"\n"
|
|
"inline $classname$* New() const$new_final$ { return New(NULL); }\n"
|
|
"\n"
|
|
"$classname$* New(::google::protobuf::Arena* arena) const$new_final$;\n");
|
|
|
|
// For instances that derive from Message (rather than MessageLite), some
|
|
// methods are virtual and should be marked as final.
|
|
string use_final = HasDescriptorMethods(descriptor_->file(), options_) ?
|
|
" PROTOBUF_FINAL" : "";
|
|
|
|
if (HasGeneratedMethods(descriptor_->file(), options_)) {
|
|
if (HasDescriptorMethods(descriptor_->file(), options_)) {
|
|
printer->Print(vars,
|
|
"void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;\n"
|
|
"void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;\n");
|
|
} else {
|
|
printer->Print(vars,
|
|
"void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)\n"
|
|
" PROTOBUF_FINAL;\n");
|
|
}
|
|
|
|
vars["clear_final"] = " PROTOBUF_FINAL";
|
|
vars["is_initialized_final"] = " PROTOBUF_FINAL";
|
|
vars["merge_partial_final"] = " PROTOBUF_FINAL";
|
|
|
|
printer->Print(
|
|
vars,
|
|
"void CopyFrom(const $classname$& from);\n"
|
|
"void MergeFrom(const $classname$& from);\n"
|
|
"void Clear()$clear_final$;\n"
|
|
"bool IsInitialized() const$is_initialized_final$;\n"
|
|
"\n"
|
|
"size_t ByteSizeLong() const PROTOBUF_FINAL;\n"
|
|
"bool MergePartialFromCodedStream(\n"
|
|
" ::google::protobuf::io::CodedInputStream* input)$merge_partial_final$;\n");
|
|
if (!options_.table_driven_serialization ||
|
|
descriptor_->options().message_set_wire_format()) {
|
|
printer->Print(
|
|
"void SerializeWithCachedSizes(\n"
|
|
" ::google::protobuf::io::CodedOutputStream* output) const "
|
|
"PROTOBUF_FINAL;\n");
|
|
}
|
|
// DiscardUnknownFields() is implemented in message.cc using reflections. We
|
|
// need to implement this function in generated code for messages.
|
|
if (!UseUnknownFieldSet(descriptor_->file(), options_)) {
|
|
printer->Print(
|
|
"void DiscardUnknownFields()$final$;\n",
|
|
"final", use_final);
|
|
}
|
|
if (HasFastArraySerialization(descriptor_->file(), options_)) {
|
|
printer->Print(
|
|
"::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(\n"
|
|
" bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;\n");
|
|
}
|
|
}
|
|
|
|
printer->Print(
|
|
"int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }\n"
|
|
"private:\n"
|
|
"void SharedCtor();\n"
|
|
"void SharedDtor();\n"
|
|
"void SetCachedSize(int size) const$final$;\n"
|
|
"void InternalSwap($classname$* other);\n",
|
|
"classname", classname_,
|
|
"final", use_final);
|
|
if (SupportsArenas(descriptor_)) {
|
|
printer->Print(
|
|
// TODO(gerbens) Make this private! Currently people are deriving from
|
|
// protos to give access to this constructor, breaking the invariants
|
|
// we rely on.
|
|
"protected:\n"
|
|
"explicit $classname$(::google::protobuf::Arena* arena);\n"
|
|
"private:\n"
|
|
"static void ArenaDtor(void* object);\n"
|
|
"inline void RegisterArenaDtor(::google::protobuf::Arena* arena);\n",
|
|
"classname", classname_);
|
|
}
|
|
|
|
if (SupportsArenas(descriptor_)) {
|
|
printer->Print(
|
|
"private:\n"
|
|
"inline ::google::protobuf::Arena* GetArenaNoVirtual() const {\n"
|
|
" return _internal_metadata_.arena();\n"
|
|
"}\n"
|
|
"inline void* MaybeArenaPtr() const {\n"
|
|
" return _internal_metadata_.raw_arena_ptr();\n"
|
|
"}\n");
|
|
} else {
|
|
printer->Print(
|
|
"private:\n"
|
|
"inline ::google::protobuf::Arena* GetArenaNoVirtual() const {\n"
|
|
" return NULL;\n"
|
|
"}\n"
|
|
"inline void* MaybeArenaPtr() const {\n"
|
|
" return NULL;\n"
|
|
"}\n");
|
|
}
|
|
|
|
printer->Print(
|
|
"public:\n"
|
|
"\n");
|
|
|
|
if (HasDescriptorMethods(descriptor_->file(), options_)) {
|
|
printer->Print(
|
|
"::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;\n"
|
|
"\n");
|
|
} else {
|
|
printer->Print(
|
|
"::std::string GetTypeName() const PROTOBUF_FINAL;\n"
|
|
"\n");
|
|
}
|
|
|
|
printer->Print(
|
|
"// nested types ----------------------------------------------------\n"
|
|
"\n");
|
|
|
|
// Import all nested message classes into this class's scope with typedefs.
|
|
for (int i = 0; i < descriptor_->nested_type_count(); i++) {
|
|
const Descriptor* nested_type = descriptor_->nested_type(i);
|
|
if (!IsMapEntryMessage(nested_type)) {
|
|
printer->Print("typedef $nested_full_name$ $nested_name$;\n",
|
|
"nested_name", nested_type->name(),
|
|
"nested_full_name", ClassName(nested_type, false));
|
|
printer->Annotate("nested_full_name", nested_type);
|
|
printer->Annotate("nested_name", nested_type);
|
|
}
|
|
}
|
|
|
|
if (descriptor_->nested_type_count() > 0) {
|
|
printer->Print("\n");
|
|
}
|
|
|
|
// Import all nested enums and their values into this class's scope with
|
|
// typedefs and constants.
|
|
for (int i = 0; i < descriptor_->enum_type_count(); i++) {
|
|
enum_generators_[i]->GenerateSymbolImports(printer);
|
|
printer->Print("\n");
|
|
}
|
|
|
|
printer->Print(
|
|
"// accessors -------------------------------------------------------\n"
|
|
"\n");
|
|
|
|
// Generate accessor methods for all fields.
|
|
GenerateFieldAccessorDeclarations(printer);
|
|
|
|
// Declare extension identifiers.
|
|
for (int i = 0; i < descriptor_->extension_count(); i++) {
|
|
extension_generators_[i]->GenerateDeclaration(printer);
|
|
}
|
|
|
|
|
|
printer->Print(
|
|
"// @@protoc_insertion_point(class_scope:$full_name$)\n",
|
|
"full_name", descriptor_->full_name());
|
|
|
|
// Generate private members.
|
|
printer->Outdent();
|
|
printer->Print(" private:\n");
|
|
printer->Indent();
|
|
|
|
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
if (!descriptor_->field(i)->is_repeated() &&
|
|
!descriptor_->field(i)->options().weak()) {
|
|
// set_has_***() generated in all proto1/2 code and in oneofs (only) for
|
|
// messages without true field presence.
|
|
if (HasFieldPresence(descriptor_->file()) ||
|
|
descriptor_->field(i)->containing_oneof()) {
|
|
printer->Print("void set_has_$name$();\n", "name",
|
|
FieldName(descriptor_->field(i)));
|
|
}
|
|
// clear_has_***() generated only for non-oneof fields
|
|
// in proto1/2.
|
|
if (!descriptor_->field(i)->containing_oneof() &&
|
|
HasFieldPresence(descriptor_->file())) {
|
|
printer->Print("void clear_has_$name$();\n", "name",
|
|
FieldName(descriptor_->field(i)));
|
|
}
|
|
}
|
|
}
|
|
printer->Print("\n");
|
|
|
|
// Generate oneof function declarations
|
|
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
|
|
printer->Print(
|
|
"inline bool has_$oneof_name$() const;\n"
|
|
"void clear_$oneof_name$();\n"
|
|
"inline void clear_has_$oneof_name$();\n\n",
|
|
"oneof_name", descriptor_->oneof_decl(i)->name());
|
|
}
|
|
|
|
if (HasGeneratedMethods(descriptor_->file(), options_) &&
|
|
!descriptor_->options().message_set_wire_format() &&
|
|
num_required_fields_ > 1) {
|
|
printer->Print(
|
|
"// helper for ByteSizeLong()\n"
|
|
"size_t RequiredFieldsByteSizeFallback() const;\n\n");
|
|
}
|
|
|
|
// Prepare decls for _cached_size_ and _has_bits_. Their position in the
|
|
// output will be determined later.
|
|
|
|
bool need_to_emit_cached_size = true;
|
|
// TODO(kenton): Make _cached_size_ an atomic<int> when C++ supports it.
|
|
const string cached_size_decl = "mutable int _cached_size_;\n";
|
|
|
|
const size_t sizeof_has_bits = HasBitsSize();
|
|
const string has_bits_decl = sizeof_has_bits == 0 ? "" :
|
|
"::google::protobuf::internal::HasBits<" + SimpleItoa(sizeof_has_bits / 4) +
|
|
"> _has_bits_;\n";
|
|
|
|
// To minimize padding, data members are divided into three sections:
|
|
// (1) members assumed to align to 8 bytes
|
|
// (2) members corresponding to message fields, re-ordered to optimize
|
|
// alignment.
|
|
// (3) members assumed to align to 4 bytes.
|
|
|
|
// Members assumed to align to 8 bytes:
|
|
|
|
if (descriptor_->extension_range_count() > 0) {
|
|
printer->Print(
|
|
"::google::protobuf::internal::ExtensionSet _extensions_;\n"
|
|
"\n");
|
|
}
|
|
|
|
if (UseUnknownFieldSet(descriptor_->file(), options_)) {
|
|
printer->Print(
|
|
"::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;\n");
|
|
} else {
|
|
printer->Print(
|
|
"::google::protobuf::internal::InternalMetadataWithArenaLite "
|
|
"_internal_metadata_;\n");
|
|
}
|
|
|
|
if (SupportsArenas(descriptor_)) {
|
|
printer->Print(
|
|
"template <typename T> friend class ::google::protobuf::Arena::InternalHelper;\n"
|
|
"typedef void InternalArenaConstructable_;\n"
|
|
"typedef void DestructorSkippable_;\n");
|
|
}
|
|
|
|
if (HasFieldPresence(descriptor_->file())) {
|
|
// _has_bits_ is frequently accessed, so to reduce code size and improve
|
|
// speed, it should be close to the start of the object. But, try not to
|
|
// waste space:_has_bits_ by itself always makes sense if its size is a
|
|
// multiple of 8, but, otherwise, maybe _has_bits_ and cached_size_ together
|
|
// will work well.
|
|
printer->Print(has_bits_decl.c_str());
|
|
if ((sizeof_has_bits % 8) != 0) {
|
|
printer->Print(cached_size_decl.c_str());
|
|
need_to_emit_cached_size = false;
|
|
}
|
|
}
|
|
|
|
// Field members:
|
|
|
|
// Emit some private and static members
|
|
for (int i = 0; i < optimized_order_.size(); ++i) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
const FieldGenerator& generator = field_generators_.get(field);
|
|
generator.GenerateStaticMembers(printer);
|
|
generator.GeneratePrivateMembers(printer);
|
|
}
|
|
|
|
// For each oneof generate a union
|
|
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
|
|
printer->Print(
|
|
"union $camel_oneof_name$Union {\n"
|
|
// explicit empty constructor is needed when union contains
|
|
// ArenaStringPtr members for string fields.
|
|
" $camel_oneof_name$Union() {}\n",
|
|
"camel_oneof_name",
|
|
UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), true));
|
|
printer->Indent();
|
|
for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
|
|
field_generators_.get(descriptor_->oneof_decl(i)->
|
|
field(j)).GeneratePrivateMembers(printer);
|
|
}
|
|
printer->Outdent();
|
|
printer->Print(
|
|
"} $oneof_name$_;\n",
|
|
"oneof_name", descriptor_->oneof_decl(i)->name());
|
|
for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
|
|
field_generators_.get(descriptor_->oneof_decl(i)->
|
|
field(j)).GenerateStaticMembers(printer);
|
|
}
|
|
}
|
|
|
|
// Members assumed to align to 4 bytes:
|
|
|
|
if (need_to_emit_cached_size) {
|
|
printer->Print(cached_size_decl.c_str());
|
|
need_to_emit_cached_size = false;
|
|
}
|
|
|
|
// Generate _oneof_case_.
|
|
if (descriptor_->oneof_decl_count() > 0) {
|
|
printer->Print(vars,
|
|
"::google::protobuf::uint32 _oneof_case_[$oneof_decl_count$];\n"
|
|
"\n");
|
|
}
|
|
|
|
if (num_weak_fields_) {
|
|
printer->Print(
|
|
"::google::protobuf::internal::WeakFieldMap _weak_field_map_;\n");
|
|
}
|
|
// Generate _any_metadata_ for the Any type.
|
|
if (IsAnyMessage(descriptor_)) {
|
|
printer->Print(vars,
|
|
"::google::protobuf::internal::AnyMetadata _any_metadata_;\n");
|
|
}
|
|
|
|
// The TableStruct struct needs access to the private parts, in order to
|
|
// construct the offsets of all members.
|
|
// TODO(gerbens) Remove the friend for InitDefaults.
|
|
printer->Print(
|
|
"friend struct ::$file_namespace$::TableStruct;\n"
|
|
"friend void ::$file_namespace$::InitDefaults$scc_name$Impl();\n",
|
|
// Vars.
|
|
"scc_name", scc_name_, "file_namespace",
|
|
FileLevelNamespace(descriptor_));
|
|
|
|
printer->Outdent();
|
|
printer->Print("};");
|
|
GOOGLE_DCHECK(!need_to_emit_cached_size);
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateDependentInlineMethods(io::Printer* printer) {
|
|
if (IsMapEntryMessage(descriptor_)) return;
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
if (descriptor_->field(i)->options().weak()) {
|
|
field_generators_.get(descriptor_->field(i))
|
|
.GenerateDependentInlineAccessorDefinitions(printer);
|
|
}
|
|
}
|
|
GenerateDependentFieldAccessorDefinitions(printer);
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateInlineMethods(io::Printer* printer) {
|
|
if (IsMapEntryMessage(descriptor_)) return;
|
|
GenerateFieldAccessorDefinitions(printer);
|
|
|
|
// Generate oneof_case() functions.
|
|
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
|
|
std::map<string, string> vars;
|
|
vars["class_name"] = classname_;
|
|
vars["camel_oneof_name"] = UnderscoresToCamelCase(
|
|
descriptor_->oneof_decl(i)->name(), true);
|
|
vars["oneof_name"] = descriptor_->oneof_decl(i)->name();
|
|
vars["oneof_index"] = SimpleItoa(descriptor_->oneof_decl(i)->index());
|
|
printer->Print(
|
|
vars,
|
|
"inline $class_name$::$camel_oneof_name$Case $class_name$::"
|
|
"$oneof_name$_case() const {\n"
|
|
" return $class_name$::$camel_oneof_name$Case("
|
|
"_oneof_case_[$oneof_index$]);\n"
|
|
"}\n");
|
|
}
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateExtraDefaultFields(io::Printer* printer) {
|
|
// Generate oneof default instance and weak field instances for reflection
|
|
// usage.
|
|
if (descriptor_->oneof_decl_count() > 0 || num_weak_fields_ > 0) {
|
|
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
|
|
for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
|
|
const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
|
|
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE ||
|
|
(field->cpp_type() == FieldDescriptor::CPPTYPE_STRING &&
|
|
EffectiveStringCType(field) != FieldOptions::STRING)) {
|
|
printer->Print("const ");
|
|
}
|
|
field_generators_.get(field).GeneratePrivateMembers(printer);
|
|
}
|
|
}
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
const FieldDescriptor* field = descriptor_->field(i);
|
|
if (field->options().weak()) {
|
|
printer->Print(
|
|
" const ::google::protobuf::Message* $name$_;\n", "name", FieldName(field));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool MessageGenerator::GenerateParseTable(io::Printer* printer, size_t offset,
|
|
size_t aux_offset) {
|
|
if (!table_driven_) {
|
|
printer->Print("{ NULL, NULL, 0, -1, -1, -1, -1, NULL, false },\n");
|
|
return false;
|
|
}
|
|
|
|
std::map<string, string> vars;
|
|
|
|
vars["classname"] = ClassName(descriptor_);
|
|
vars["classtype"] = QualifiedClassName(descriptor_);
|
|
vars["offset"] = SimpleItoa(offset);
|
|
vars["aux_offset"] = SimpleItoa(aux_offset);
|
|
|
|
int max_field_number = 0;
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
const FieldDescriptor* field = descriptor_->field(i);
|
|
if (max_field_number < field->number()) {
|
|
max_field_number = field->number();
|
|
}
|
|
}
|
|
|
|
vars["max_field_number"] = SimpleItoa(max_field_number);
|
|
|
|
printer->Print("{\n");
|
|
printer->Indent();
|
|
|
|
printer->Print(vars,
|
|
"TableStruct::entries + $offset$,\n"
|
|
"TableStruct::aux + $aux_offset$,\n"
|
|
"$max_field_number$,\n");
|
|
|
|
if (!HasFieldPresence(descriptor_->file())) {
|
|
// If we don't have field presence, then _has_bits_ does not exist.
|
|
printer->Print(vars, "-1,\n");
|
|
} else {
|
|
printer->Print(vars,
|
|
"GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(\n"
|
|
" $classtype$, _has_bits_),\n");
|
|
}
|
|
|
|
if (descriptor_->oneof_decl_count() > 0) {
|
|
printer->Print(vars,
|
|
"GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(\n"
|
|
" $classtype$, _oneof_case_),\n");
|
|
} else {
|
|
printer->Print("-1, // no _oneof_case_\n");
|
|
}
|
|
|
|
if (descriptor_->extension_range_count() > 0) {
|
|
printer->Print(vars,
|
|
"GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($classtype$, "
|
|
"_extensions_),\n");
|
|
} else {
|
|
printer->Print("-1, // no _extensions_\n");
|
|
}
|
|
|
|
// TODO(ckennelly): Consolidate this with the calculation for
|
|
// AuxillaryParseTableField.
|
|
vars["ns"] = Namespace(descriptor_);
|
|
|
|
printer->Print(vars,
|
|
"GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(\n"
|
|
" $classtype$, _internal_metadata_),\n"
|
|
"&$ns$::_$classname$_default_instance_,\n");
|
|
|
|
if (UseUnknownFieldSet(descriptor_->file(), options_)) {
|
|
printer->Print(vars, "true,\n");
|
|
} else {
|
|
printer->Print(vars, "false,\n");
|
|
}
|
|
|
|
printer->Outdent();
|
|
printer->Print("},\n");
|
|
return true;
|
|
}
|
|
|
|
void MessageGenerator::GenerateSchema(io::Printer* printer, int offset,
|
|
int has_offset) {
|
|
std::map<string, string> vars;
|
|
|
|
vars["classname"] = QualifiedClassName(descriptor_);
|
|
vars["offset"] = SimpleItoa(offset);
|
|
vars["has_bits_offsets"] =
|
|
HasFieldPresence(descriptor_->file()) || IsMapEntryMessage(descriptor_)
|
|
? SimpleItoa(offset + has_offset)
|
|
: "-1";
|
|
|
|
printer->Print(vars,
|
|
"{ $offset$, $has_bits_offsets$, sizeof($classname$)},\n");
|
|
}
|
|
|
|
namespace {
|
|
|
|
// TODO(gerbens) remove this after the next sync with GitHub code base.
|
|
// Then the opensource testing has gained the functionality to compile
|
|
// the CalcFieldNum given the symbols defined in generated-message-util.
|
|
#ifdef OPENSOURCE_PROTOBUF_CPP_BOOTSTRAP
|
|
// We need a clean version of CalcFieldNum that doesn't use new functionality
|
|
// in the runtime, because this functionality is not yet in the opensource
|
|
// runtime
|
|
|
|
uint32 CalculateType(uint32 type, uint32 type_class) {
|
|
return (type - 1) + type_class * 20;
|
|
}
|
|
|
|
uint32 CalcFieldNum(const FieldDescriptor* field, const Options& options) {
|
|
bool is_a_map = IsMapEntryMessage(field->containing_type());
|
|
int type = field->type();
|
|
if (field->containing_oneof()) {
|
|
return CalculateType(type, 4);
|
|
}
|
|
if (field->is_packed()) {
|
|
return CalculateType(type, 3);
|
|
} else if (field->is_repeated()) {
|
|
return CalculateType(type, 2);
|
|
} else if (!HasFieldPresence(field->file()) &&
|
|
field->containing_oneof() == NULL && !is_a_map) {
|
|
return CalculateType(type, 1);
|
|
} else {
|
|
return CalculateType(type, 0);
|
|
}
|
|
}
|
|
|
|
#else
|
|
// We need to calculate for each field what function the table driven code
|
|
// should use to serialize it. This returns the index in a lookup table.
|
|
uint32 CalcFieldNum(const FieldDescriptor* field, const Options& options) {
|
|
bool is_a_map = IsMapEntryMessage(field->containing_type());
|
|
int type = field->type();
|
|
if (field->containing_oneof()) {
|
|
return internal::FieldMetadata::CalculateType(
|
|
type, internal::FieldMetadata::kOneOf);
|
|
}
|
|
if (field->is_packed()) {
|
|
return internal::FieldMetadata::CalculateType(
|
|
type, internal::FieldMetadata::kPacked);
|
|
} else if (field->is_repeated()) {
|
|
return internal::FieldMetadata::CalculateType(
|
|
type, internal::FieldMetadata::kRepeated);
|
|
} else if (!HasFieldPresence(field->file()) &&
|
|
field->containing_oneof() == NULL && !is_a_map) {
|
|
return internal::FieldMetadata::CalculateType(
|
|
type, internal::FieldMetadata::kNoPresence);
|
|
} else {
|
|
return internal::FieldMetadata::CalculateType(
|
|
type, internal::FieldMetadata::kPresence);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
int FindMessageIndexInFile(const Descriptor* descriptor) {
|
|
std::vector<const Descriptor*> flatten =
|
|
FlattenMessagesInFile(descriptor->file());
|
|
return std::find(flatten.begin(), flatten.end(), descriptor) -
|
|
flatten.begin();
|
|
}
|
|
|
|
} // namespace
|
|
|
|
int MessageGenerator::GenerateFieldMetadata(io::Printer* printer) {
|
|
if (!options_.table_driven_serialization) {
|
|
return 0;
|
|
}
|
|
|
|
string full_classname = QualifiedClassName(descriptor_);
|
|
|
|
std::vector<const FieldDescriptor*> sorted = SortFieldsByNumber(descriptor_);
|
|
if (IsMapEntryMessage(descriptor_)) {
|
|
for (int i = 0; i < 2; i++) {
|
|
const FieldDescriptor* field = sorted[i];
|
|
uint32 tag = internal::WireFormatLite::MakeTag(
|
|
field->number(), WireFormat::WireTypeForFieldType(field->type()));
|
|
|
|
std::map<string, string> vars;
|
|
vars["classname"] = QualifiedClassName(descriptor_);
|
|
vars["field_name"] = FieldName(field);
|
|
vars["tag"] = SimpleItoa(tag);
|
|
vars["hasbit"] = SimpleItoa(i);
|
|
vars["type"] = SimpleItoa(CalcFieldNum(field, options_));
|
|
vars["ptr"] = "NULL";
|
|
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
|
|
GOOGLE_CHECK(!IsMapEntryMessage(field->message_type()));
|
|
{
|
|
vars["ptr"] =
|
|
"::" + FileLevelNamespace(field->message_type()) +
|
|
"::TableStruct::serialization_table + " +
|
|
SimpleItoa(FindMessageIndexInFile(field->message_type()));
|
|
}
|
|
}
|
|
printer->Print(vars,
|
|
"{GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET("
|
|
"::google::protobuf::internal::MapEntryHelper<$classname$::"
|
|
"SuperType>, $field_name$_), $tag$,"
|
|
"GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET("
|
|
"::google::protobuf::internal::MapEntryHelper<$classname$::"
|
|
"SuperType>, _has_bits_) * 8 + $hasbit$, $type$, "
|
|
"$ptr$},\n");
|
|
}
|
|
return 2;
|
|
}
|
|
printer->Print(
|
|
"{GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($classname$, "
|
|
"_cached_size_), 0, 0, 0, NULL},\n",
|
|
"classname", full_classname);
|
|
std::vector<const Descriptor::ExtensionRange*> sorted_extensions;
|
|
for (int i = 0; i < descriptor_->extension_range_count(); ++i) {
|
|
sorted_extensions.push_back(descriptor_->extension_range(i));
|
|
}
|
|
std::sort(sorted_extensions.begin(), sorted_extensions.end(),
|
|
ExtensionRangeSorter());
|
|
for (int i = 0, extension_idx = 0; /* no range */; i++) {
|
|
for (; extension_idx < sorted_extensions.size() &&
|
|
(i == sorted.size() ||
|
|
sorted_extensions[extension_idx]->start < sorted[i]->number());
|
|
extension_idx++) {
|
|
const Descriptor::ExtensionRange* range =
|
|
sorted_extensions[extension_idx];
|
|
printer->Print(
|
|
"{GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($classname$, "
|
|
"_extensions_), $start$, $end$, "
|
|
"::google::protobuf::internal::FieldMetadata::kSpecial, "
|
|
"reinterpret_cast<const "
|
|
"void*>(::google::protobuf::internal::ExtensionSerializer)},\n",
|
|
"classname", full_classname, "start", SimpleItoa(range->start), "end",
|
|
SimpleItoa(range->end));
|
|
}
|
|
if (i == sorted.size()) break;
|
|
const FieldDescriptor* field = sorted[i];
|
|
|
|
uint32 tag = internal::WireFormatLite::MakeTag(
|
|
field->number(), WireFormat::WireTypeForFieldType(field->type()));
|
|
if (field->is_packed()) {
|
|
tag = internal::WireFormatLite::MakeTag(
|
|
field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
|
|
}
|
|
|
|
string classfieldname = FieldName(field);
|
|
if (field->containing_oneof()) {
|
|
classfieldname = field->containing_oneof()->name();
|
|
}
|
|
std::map<string, string> vars;
|
|
vars["classname"] = full_classname;
|
|
vars["field_name"] = classfieldname;
|
|
vars["tag"] = SimpleItoa(tag);
|
|
vars["ptr"] = "NULL";
|
|
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
|
|
if (IsMapEntryMessage(field->message_type())) {
|
|
vars["idx"] = SimpleItoa(FindMessageIndexInFile(field->message_type()));
|
|
vars["fieldclassname"] = QualifiedClassName(field->message_type());
|
|
printer->Print(vars,
|
|
"{GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($"
|
|
"classname$, $field_name$_), $tag$, $idx$, "
|
|
"::google::protobuf::internal::FieldMetadata::kSpecial, "
|
|
"reinterpret_cast<const void*>(static_cast< "
|
|
"::google::protobuf::internal::SpecialSerializer>("
|
|
"::google::protobuf::internal::MapFieldSerializer< "
|
|
"::google::protobuf::internal::MapEntryToMapField<"
|
|
"$fieldclassname$>::MapFieldType, "
|
|
"TableStruct::serialization_table>))},\n");
|
|
continue;
|
|
} else {
|
|
vars["ptr"] =
|
|
"::" + FileLevelNamespace(field->message_type()) +
|
|
"::TableStruct::serialization_table + " +
|
|
SimpleItoa(FindMessageIndexInFile(field->message_type()));
|
|
}
|
|
}
|
|
vars["type"] = SimpleItoa(CalcFieldNum(field, options_));
|
|
|
|
|
|
if (field->options().weak()) {
|
|
// TODO(gerbens) merge weak fields into ranges
|
|
printer->Print(vars,
|
|
"{GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($"
|
|
"classname$, _weak_field_map_), $tag$, $tag$, "
|
|
"::google::protobuf::internal::FieldMetadata::kSpecial, "
|
|
"reinterpret_cast<const "
|
|
"void*>(::google::protobuf::internal::WeakFieldSerializer)},\n");
|
|
} else if (field->containing_oneof()) {
|
|
vars["oneofoffset"] =
|
|
SimpleItoa(sizeof(uint32) * field->containing_oneof()->index());
|
|
printer->Print(vars,
|
|
"{GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($"
|
|
"classname$, $field_name$_), $tag$, "
|
|
"GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($"
|
|
"classname$, _oneof_case_) + $oneofoffset$, "
|
|
"$type$, $ptr$},\n");
|
|
} else if (HasFieldPresence(descriptor_->file()) &&
|
|
has_bit_indices_[field->index()] != -1) {
|
|
vars["hasbitsoffset"] = SimpleItoa(has_bit_indices_[field->index()]);
|
|
printer->Print(vars,
|
|
"{GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($"
|
|
"classname$, $field_name$_), $tag$, "
|
|
"GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($"
|
|
"classname$, _has_bits_) * 8 + $hasbitsoffset$, $type$, "
|
|
"$ptr$},\n");
|
|
} else {
|
|
printer->Print(vars,
|
|
"{GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($"
|
|
"classname$, $field_name$_), $tag$, ~0u, $type$, "
|
|
"$ptr$},\n");
|
|
}
|
|
}
|
|
int num_field_metadata = 1 + sorted.size() + sorted_extensions.size();
|
|
num_field_metadata++;
|
|
string serializer = UseUnknownFieldSet(descriptor_->file(), options_)
|
|
? "::google::protobuf::internal::UnknownFieldSetSerializer"
|
|
: "::google::protobuf::internal::UnknownFieldSerializerLite";
|
|
printer->Print(
|
|
"{GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($classname$, "
|
|
"_internal_metadata_), 0, ~0u, "
|
|
"::google::protobuf::internal::FieldMetadata::kSpecial, reinterpret_cast<const "
|
|
"void*>($serializer$)},\n",
|
|
"classname", full_classname, "serializer", serializer);
|
|
return num_field_metadata;
|
|
}
|
|
|
|
void MessageGenerator::GenerateFieldDefaultInstances(io::Printer* printer) {
|
|
// Construct the default instances for all fields that need one.
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
field_generators_.get(descriptor_->field(i))
|
|
.GenerateDefaultInstanceAllocator(printer);
|
|
}
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateDefaultInstanceInitializer(io::Printer* printer) {
|
|
// The default instance needs all of its embedded message pointers
|
|
// cross-linked to other default instances. We can't do this initialization
|
|
// in the constructor because some other default instances may not have been
|
|
// constructed yet at that time.
|
|
// TODO(kenton): Maybe all message fields (even for non-default messages)
|
|
// should be initialized to point at default instances rather than NULL?
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
const FieldDescriptor* field = descriptor_->field(i);
|
|
|
|
if (!field->is_repeated() &&
|
|
field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
|
|
(field->containing_oneof() == NULL ||
|
|
HasDescriptorMethods(descriptor_->file(), options_))) {
|
|
string name;
|
|
if (field->containing_oneof() || field->options().weak()) {
|
|
name = "_" + classname_ + "_default_instance_.";
|
|
} else {
|
|
name =
|
|
"_" + classname_ + "_default_instance_._instance.get_mutable()->";
|
|
}
|
|
name += FieldName(field);
|
|
printer->Print(
|
|
"$ns$::$name$_ = const_cast< $type$*>(\n"
|
|
" $type$::internal_default_instance());\n",
|
|
// Vars.
|
|
"name", name, "type", FieldMessageTypeName(field), "ns",
|
|
Namespace(descriptor_));
|
|
} else if (field->containing_oneof() &&
|
|
HasDescriptorMethods(descriptor_->file(), options_)) {
|
|
field_generators_.get(descriptor_->field(i))
|
|
.GenerateConstructorCode(printer);
|
|
}
|
|
}
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateClassMethods(io::Printer* printer) {
|
|
if (IsMapEntryMessage(descriptor_)) {
|
|
printer->Print(
|
|
"$classname$::$classname$() {}\n"
|
|
"$classname$::$classname$(::google::protobuf::Arena* arena) : "
|
|
"SuperType(arena) {}\n"
|
|
"void $classname$::MergeFrom(const $classname$& other) {\n"
|
|
" MergeFromInternal(other);\n"
|
|
"}\n",
|
|
"classname", classname_);
|
|
if (HasDescriptorMethods(descriptor_->file(), options_)) {
|
|
printer->Print(
|
|
"::google::protobuf::Metadata $classname$::GetMetadata() const {\n"
|
|
" ::$file_namespace$::protobuf_AssignDescriptorsOnce();\n"
|
|
" return ::$file_namespace$::file_level_metadata[$index$];\n"
|
|
"}\n"
|
|
"void $classname$::MergeFrom(\n"
|
|
" const ::google::protobuf::Message& other) {\n"
|
|
" ::google::protobuf::Message::MergeFrom(other);\n"
|
|
"}\n"
|
|
"\n",
|
|
"file_namespace", FileLevelNamespace(descriptor_),
|
|
"classname", classname_, "index",
|
|
SimpleItoa(index_in_file_messages_));
|
|
}
|
|
return;
|
|
}
|
|
|
|
// TODO(gerbens) Remove this function. With a little bit of cleanup and
|
|
// refactoring this is superfluous.
|
|
printer->Print("void $classname$::InitAsDefaultInstance() {\n", "classname",
|
|
classname_);
|
|
printer->Indent();
|
|
GenerateDefaultInstanceInitializer(printer);
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
|
|
if (IsAnyMessage(descriptor_)) {
|
|
printer->Print(
|
|
"void $classname$::PackFrom(const ::google::protobuf::Message& message) {\n"
|
|
" _any_metadata_.PackFrom(message);\n"
|
|
"}\n"
|
|
"\n"
|
|
"void $classname$::PackFrom(const ::google::protobuf::Message& message,\n"
|
|
" const ::std::string& type_url_prefix) {\n"
|
|
" _any_metadata_.PackFrom(message, type_url_prefix);\n"
|
|
"}\n"
|
|
"\n"
|
|
"bool $classname$::UnpackTo(::google::protobuf::Message* message) const {\n"
|
|
" return _any_metadata_.UnpackTo(message);\n"
|
|
"}\n"
|
|
"\n",
|
|
"classname", classname_);
|
|
}
|
|
|
|
// Generate non-inline field definitions.
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
const FieldDescriptor* field = descriptor_->field(i);
|
|
field_generators_.get(field)
|
|
.GenerateNonInlineAccessorDefinitions(printer);
|
|
if (IsCrossFileMaybeMap(field)) {
|
|
std::map<string, string> vars;
|
|
SetCommonFieldVariables(field, &vars, options_);
|
|
if (field->containing_oneof()) {
|
|
SetCommonOneofFieldVariables(field, &vars);
|
|
}
|
|
GenerateFieldClear(field, vars, false, printer);
|
|
}
|
|
}
|
|
|
|
// Generate field number constants.
|
|
printer->Print("#if !defined(_MSC_VER) || _MSC_VER >= 1900\n");
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
const FieldDescriptor *field = descriptor_->field(i);
|
|
printer->Print(
|
|
"const int $classname$::$constant_name$;\n",
|
|
"classname", ClassName(FieldScope(field), false),
|
|
"constant_name", FieldConstantName(field));
|
|
}
|
|
printer->Print(
|
|
"#endif // !defined(_MSC_VER) || _MSC_VER >= 1900\n"
|
|
"\n");
|
|
|
|
GenerateStructors(printer);
|
|
printer->Print("\n");
|
|
|
|
if (descriptor_->oneof_decl_count() > 0) {
|
|
GenerateOneofClear(printer);
|
|
printer->Print("\n");
|
|
}
|
|
|
|
if (HasGeneratedMethods(descriptor_->file(), options_)) {
|
|
GenerateClear(printer);
|
|
printer->Print("\n");
|
|
|
|
GenerateMergeFromCodedStream(printer);
|
|
printer->Print("\n");
|
|
|
|
GenerateSerializeWithCachedSizes(printer);
|
|
printer->Print("\n");
|
|
|
|
if (HasFastArraySerialization(descriptor_->file(), options_)) {
|
|
GenerateSerializeWithCachedSizesToArray(printer);
|
|
printer->Print("\n");
|
|
}
|
|
|
|
GenerateByteSize(printer);
|
|
printer->Print("\n");
|
|
|
|
GenerateMergeFrom(printer);
|
|
printer->Print("\n");
|
|
|
|
GenerateCopyFrom(printer);
|
|
printer->Print("\n");
|
|
|
|
GenerateIsInitialized(printer);
|
|
printer->Print("\n");
|
|
}
|
|
|
|
GenerateSwap(printer);
|
|
printer->Print("\n");
|
|
|
|
if (options_.table_driven_serialization) {
|
|
printer->Print(
|
|
"const void* $classname$::InternalGetTable() const {\n"
|
|
" return ::$file_namespace$::TableStruct::serialization_table + "
|
|
"$index$;\n"
|
|
"}\n"
|
|
"\n",
|
|
"classname", classname_, "index", SimpleItoa(index_in_file_messages_),
|
|
"file_namespace", FileLevelNamespace(descriptor_));
|
|
}
|
|
if (HasDescriptorMethods(descriptor_->file(), options_)) {
|
|
printer->Print(
|
|
"::google::protobuf::Metadata $classname$::GetMetadata() const {\n"
|
|
" $file_namespace$::protobuf_AssignDescriptorsOnce();\n"
|
|
" return ::"
|
|
"$file_namespace$::file_level_metadata[kIndexInFileMessages];\n"
|
|
"}\n"
|
|
"\n",
|
|
"classname", classname_, "file_namespace",
|
|
FileLevelNamespace(descriptor_));
|
|
} else {
|
|
printer->Print(
|
|
"::std::string $classname$::GetTypeName() const {\n"
|
|
" return \"$type_name$\";\n"
|
|
"}\n"
|
|
"\n",
|
|
"classname", classname_,
|
|
"type_name", descriptor_->full_name());
|
|
}
|
|
|
|
}
|
|
|
|
size_t MessageGenerator::GenerateParseOffsets(io::Printer* printer) {
|
|
if (!table_driven_) {
|
|
return 0;
|
|
}
|
|
|
|
// Field "0" is special: We use it in our switch statement of processing
|
|
// types to handle the successful end tag case.
|
|
printer->Print("{0, 0, 0, ::google::protobuf::internal::kInvalidMask, 0, 0},\n");
|
|
int last_field_number = 1;
|
|
|
|
std::vector<const FieldDescriptor*> ordered_fields =
|
|
SortFieldsByNumber(descriptor_);
|
|
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
const FieldDescriptor* field = ordered_fields[i];
|
|
GOOGLE_CHECK_GE(field->number(), last_field_number);
|
|
|
|
for (; last_field_number < field->number(); last_field_number++) {
|
|
printer->Print(
|
|
"{ 0, 0, ::google::protobuf::internal::kInvalidMask,\n"
|
|
" ::google::protobuf::internal::kInvalidMask, 0, 0 },\n");
|
|
}
|
|
last_field_number++;
|
|
|
|
unsigned char normal_wiretype, packed_wiretype, processing_type;
|
|
normal_wiretype = WireFormat::WireTypeForFieldType(field->type());
|
|
|
|
if (field->is_packable()) {
|
|
packed_wiretype = WireFormatLite::WIRETYPE_LENGTH_DELIMITED;
|
|
} else {
|
|
packed_wiretype = internal::kNotPackedMask;
|
|
}
|
|
|
|
processing_type = static_cast<unsigned>(field->type());
|
|
if (field->type() == FieldDescriptor::TYPE_STRING) {
|
|
switch (EffectiveStringCType(field)) {
|
|
case FieldOptions::STRING:
|
|
default:
|
|
break;
|
|
}
|
|
} else if (field->type() == FieldDescriptor::TYPE_BYTES) {
|
|
switch (EffectiveStringCType(field)) {
|
|
case FieldOptions::STRING:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
processing_type |= static_cast<unsigned>(
|
|
field->is_repeated() ? internal::kRepeatedMask : 0);
|
|
processing_type |= static_cast<unsigned>(
|
|
field->containing_oneof() ? internal::kOneofMask : 0);
|
|
|
|
if (field->is_map()) {
|
|
processing_type = internal::TYPE_MAP;
|
|
}
|
|
|
|
const unsigned char tag_size =
|
|
WireFormat::TagSize(field->number(), field->type());
|
|
|
|
std::map<string, string> vars;
|
|
vars["classname"] = QualifiedClassName(descriptor_);
|
|
if (field->containing_oneof() != NULL) {
|
|
vars["name"] = field->containing_oneof()->name();
|
|
vars["presence"] = SimpleItoa(field->containing_oneof()->index());
|
|
} else {
|
|
vars["name"] = FieldName(field);
|
|
vars["presence"] = SimpleItoa(has_bit_indices_[field->index()]);
|
|
}
|
|
vars["nwtype"] = SimpleItoa(normal_wiretype);
|
|
vars["pwtype"] = SimpleItoa(packed_wiretype);
|
|
vars["ptype"] = SimpleItoa(processing_type);
|
|
vars["tag_size"] = SimpleItoa(tag_size);
|
|
|
|
printer->Print(vars,
|
|
"{\n"
|
|
" GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(\n"
|
|
" $classname$, $name$_),\n"
|
|
" static_cast< ::google::protobuf::uint32>($presence$),\n"
|
|
" $nwtype$, $pwtype$, $ptype$, $tag_size$\n"
|
|
"},\n");
|
|
}
|
|
|
|
return last_field_number;
|
|
}
|
|
|
|
size_t MessageGenerator::GenerateParseAuxTable(io::Printer* printer) {
|
|
if (!table_driven_) {
|
|
return 0;
|
|
}
|
|
|
|
std::vector<const FieldDescriptor*> ordered_fields =
|
|
SortFieldsByNumber(descriptor_);
|
|
|
|
printer->Print("::google::protobuf::internal::AuxillaryParseTableField(),\n");
|
|
int last_field_number = 1;
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
const FieldDescriptor* field = ordered_fields[i];
|
|
|
|
GOOGLE_CHECK_GE(field->number(), last_field_number);
|
|
for (; last_field_number < field->number(); last_field_number++) {
|
|
printer->Print("::google::protobuf::internal::AuxillaryParseTableField(),\n");
|
|
}
|
|
|
|
std::map<string, string> vars;
|
|
SetCommonFieldVariables(field, &vars, options_);
|
|
|
|
switch (field->cpp_type()) {
|
|
case FieldDescriptor::CPPTYPE_ENUM:
|
|
vars["type"] = ClassName(field->enum_type(), true);
|
|
printer->Print(
|
|
vars,
|
|
"{::google::protobuf::internal::AuxillaryParseTableField::enum_aux{"
|
|
"$type$_IsValid}},\n");
|
|
last_field_number++;
|
|
break;
|
|
case FieldDescriptor::CPPTYPE_MESSAGE: {
|
|
if (field->is_map()) {
|
|
vars["classname"] = QualifiedClassName(field->message_type());
|
|
printer->Print(vars,
|
|
"{::google::protobuf::internal::AuxillaryParseTableField::map_"
|
|
"aux{&::google::protobuf::internal::ParseMap<$classname$>}},\n");
|
|
last_field_number++;
|
|
break;
|
|
} else {
|
|
vars["classname"] = ClassName(field->message_type(), false);
|
|
}
|
|
vars["ns"] = Namespace(field->message_type());
|
|
vars["type"] = FieldMessageTypeName(field);
|
|
vars["file_namespace"] =
|
|
FileLevelNamespace(field->message_type());
|
|
|
|
printer->Print(
|
|
vars,
|
|
"{::google::protobuf::internal::AuxillaryParseTableField::message_aux{\n"
|
|
" &$ns$::_$classname$_default_instance_,\n");
|
|
|
|
bool dont_emit_table =
|
|
!TableDrivenParsingEnabled(field->message_type(), options_);
|
|
|
|
if (dont_emit_table) {
|
|
printer->Print(" NULL,\n");
|
|
} else {
|
|
printer->Print(vars,
|
|
" ::$file_namespace$::TableStruct::schema +\n"
|
|
" $ns$::$classname$::kIndexInFileMessages,\n");
|
|
}
|
|
|
|
printer->Print("}},\n");
|
|
last_field_number++;
|
|
break;
|
|
}
|
|
case FieldDescriptor::CPPTYPE_STRING:
|
|
switch (EffectiveStringCType(field)) {
|
|
case FieldOptions::STRING:
|
|
vars["default"] =
|
|
field->default_value_string().empty()
|
|
? "&::google::protobuf::internal::fixed_address_empty_string"
|
|
: "&" + Namespace(field) + " ::" + classname_ +
|
|
"::_default_" + FieldName(field) + "_";
|
|
break;
|
|
case FieldOptions::CORD:
|
|
case FieldOptions::STRING_PIECE:
|
|
vars["default"] =
|
|
"\"" + CEscape(field->default_value_string()) + "\"";
|
|
break;
|
|
}
|
|
vars["full_name"] = field->full_name();
|
|
printer->Print(vars,
|
|
"{::google::protobuf::internal::AuxillaryParseTableField::string_aux{\n"
|
|
" $default$,\n"
|
|
" \"$full_name$\"\n"
|
|
"}},\n");
|
|
last_field_number++;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return last_field_number;
|
|
}
|
|
|
|
std::pair<size_t, size_t> MessageGenerator::GenerateOffsets(
|
|
io::Printer* printer) {
|
|
std::map<string, string> variables;
|
|
string full_classname = QualifiedClassName(descriptor_);
|
|
variables["classname"] = full_classname;
|
|
|
|
if (HasFieldPresence(descriptor_->file()) || IsMapEntryMessage(descriptor_)) {
|
|
printer->Print(
|
|
variables,
|
|
"GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($classname$, "
|
|
"_has_bits_),\n");
|
|
} else {
|
|
printer->Print("~0u, // no _has_bits_\n");
|
|
}
|
|
printer->Print(variables,
|
|
"GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($classname$, "
|
|
"_internal_metadata_),\n");
|
|
if (descriptor_->extension_range_count() > 0) {
|
|
printer->Print(
|
|
variables,
|
|
"GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($classname$, "
|
|
"_extensions_),\n");
|
|
} else {
|
|
printer->Print("~0u, // no _extensions_\n");
|
|
}
|
|
if (descriptor_->oneof_decl_count() > 0) {
|
|
printer->Print(variables,
|
|
"GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET("
|
|
"$classname$, _oneof_case_[0]),\n");
|
|
} else {
|
|
printer->Print("~0u, // no _oneof_case_\n");
|
|
}
|
|
if (num_weak_fields_ > 0) {
|
|
printer->Print(variables,
|
|
"GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($classname$,"
|
|
" _weak_field_map_),\n");
|
|
} else {
|
|
printer->Print("~0u, // no _weak_field_map_\n");
|
|
}
|
|
const int kNumGenericOffsets = 5; // the number of fixed offsets above
|
|
const size_t offsets = kNumGenericOffsets +
|
|
descriptor_->field_count() +
|
|
descriptor_->oneof_decl_count();
|
|
size_t entries = offsets;
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
const FieldDescriptor* field = descriptor_->field(i);
|
|
if (field->containing_oneof() || field->options().weak()) {
|
|
printer->Print("offsetof($classname$DefaultTypeInternal, $name$_),\n",
|
|
"classname", full_classname, "name", FieldName(field));
|
|
} else {
|
|
printer->Print(
|
|
"GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($classname$, "
|
|
"$name$_),\n",
|
|
"classname", full_classname, "name", FieldName(field));
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
|
|
const OneofDescriptor* oneof = descriptor_->oneof_decl(i);
|
|
printer->Print(
|
|
"GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($classname$, $name$_),\n",
|
|
"classname", full_classname, "name", oneof->name());
|
|
}
|
|
|
|
if (IsMapEntryMessage(descriptor_)) {
|
|
entries += 2;
|
|
printer->Print(
|
|
"0,\n"
|
|
"1,\n");
|
|
} else if (HasFieldPresence(descriptor_->file())) {
|
|
entries += has_bit_indices_.size();
|
|
for (int i = 0; i < has_bit_indices_.size(); i++) {
|
|
const string index = has_bit_indices_[i] >= 0 ?
|
|
SimpleItoa(has_bit_indices_[i]) : "~0u";
|
|
printer->Print("$index$,\n", "index", index);
|
|
}
|
|
}
|
|
|
|
return std::make_pair(entries, offsets);
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateSharedConstructorCode(io::Printer* printer) {
|
|
printer->Print(
|
|
"void $classname$::SharedCtor() {\n",
|
|
"classname", classname_);
|
|
printer->Indent();
|
|
|
|
bool need_to_clear_cached_size = true;
|
|
// We reproduce the logic used for laying out _cached_sized_ in the class
|
|
// definition, as to initialize it in-order.
|
|
if (HasFieldPresence(descriptor_->file()) &&
|
|
(HasBitsSize() % 8) != 0) {
|
|
printer->Print("_cached_size_ = 0;\n");
|
|
need_to_clear_cached_size = false;
|
|
}
|
|
|
|
std::vector<bool> processed(optimized_order_.size(), false);
|
|
GenerateConstructorBody(printer, processed, false);
|
|
|
|
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
|
|
printer->Print(
|
|
"clear_has_$oneof_name$();\n",
|
|
"oneof_name", descriptor_->oneof_decl(i)->name());
|
|
}
|
|
|
|
if (need_to_clear_cached_size) {
|
|
printer->Print("_cached_size_ = 0;\n");
|
|
}
|
|
|
|
printer->Outdent();
|
|
printer->Print("}\n\n");
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateSharedDestructorCode(io::Printer* printer) {
|
|
printer->Print(
|
|
"void $classname$::SharedDtor() {\n",
|
|
"classname", classname_);
|
|
printer->Indent();
|
|
if (SupportsArenas(descriptor_)) {
|
|
printer->Print(
|
|
"GOOGLE_DCHECK(GetArenaNoVirtual() == NULL);\n");
|
|
}
|
|
// Write the destructors for each field except oneof members.
|
|
// optimized_order_ does not contain oneof fields.
|
|
for (int i = 0; i < optimized_order_.size(); i++) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
field_generators_.get(field).GenerateDestructorCode(printer);
|
|
}
|
|
|
|
// Generate code to destruct oneofs. Clearing should do the work.
|
|
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
|
|
printer->Print(
|
|
"if (has_$oneof_name$()) {\n"
|
|
" clear_$oneof_name$();\n"
|
|
"}\n",
|
|
"oneof_name", descriptor_->oneof_decl(i)->name());
|
|
}
|
|
|
|
if (num_weak_fields_) {
|
|
printer->Print("_weak_field_map_.ClearAll();\n");
|
|
}
|
|
printer->Outdent();
|
|
printer->Print(
|
|
"}\n"
|
|
"\n");
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateArenaDestructorCode(io::Printer* printer) {
|
|
// Generate the ArenaDtor() method. Track whether any fields actually produced
|
|
// code that needs to be called.
|
|
printer->Print(
|
|
"void $classname$::ArenaDtor(void* object) {\n",
|
|
"classname", classname_);
|
|
printer->Indent();
|
|
|
|
// This code is placed inside a static method, rather than an ordinary one,
|
|
// since that simplifies Arena's destructor list (ordinary function pointers
|
|
// rather than member function pointers). _this is the object being
|
|
// destructed.
|
|
printer->Print(
|
|
"$classname$* _this = reinterpret_cast< $classname$* >(object);\n"
|
|
// avoid an "unused variable" warning in case no fields have dtor code.
|
|
"(void)_this;\n",
|
|
"classname", classname_);
|
|
|
|
bool need_registration = false;
|
|
// Process non-oneof fields first.
|
|
for (int i = 0; i < optimized_order_.size(); i++) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
if (field_generators_.get(field)
|
|
.GenerateArenaDestructorCode(printer)) {
|
|
need_registration = true;
|
|
}
|
|
}
|
|
|
|
// Process oneof fields.
|
|
//
|
|
// Note: As of 10/5/2016, GenerateArenaDestructorCode does not emit anything
|
|
// and returns false for oneof fields.
|
|
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
|
|
const OneofDescriptor* oneof = descriptor_->oneof_decl(i);
|
|
|
|
for (int j = 0; j < oneof->field_count(); j++) {
|
|
const FieldDescriptor* field = oneof->field(j);
|
|
if (field_generators_.get(field)
|
|
.GenerateArenaDestructorCode(printer)) {
|
|
need_registration = true;
|
|
}
|
|
}
|
|
}
|
|
if (num_weak_fields_) {
|
|
// _this is the object being destructed (we are inside a static method
|
|
// here).
|
|
printer->Print("_this->_weak_field_map_.ClearAll();\n");
|
|
need_registration = true;
|
|
}
|
|
|
|
printer->Outdent();
|
|
printer->Print(
|
|
"}\n");
|
|
|
|
if (need_registration) {
|
|
printer->Print(
|
|
"inline void $classname$::RegisterArenaDtor(::google::protobuf::Arena* arena) {\n"
|
|
" if (arena != NULL) {\n"
|
|
" arena->OwnCustomDestructor(this, &$classname$::ArenaDtor);\n"
|
|
" }\n"
|
|
"}\n",
|
|
"classname", classname_);
|
|
} else {
|
|
printer->Print(
|
|
"void $classname$::RegisterArenaDtor(::google::protobuf::Arena* arena) {\n"
|
|
"}\n",
|
|
"classname", classname_);
|
|
}
|
|
}
|
|
|
|
void MessageGenerator::GenerateConstructorBody(io::Printer* printer,
|
|
std::vector<bool> processed,
|
|
bool copy_constructor) const {
|
|
const FieldDescriptor* last_start = NULL;
|
|
// RunMap maps from fields that start each run to the number of fields in that
|
|
// run. This is optimized for the common case that there are very few runs in
|
|
// a message and that most of the eligible fields appear together.
|
|
typedef hash_map<const FieldDescriptor*, size_t> RunMap;
|
|
RunMap runs;
|
|
|
|
for (int i = 0; i < optimized_order_.size(); ++i) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
if ((copy_constructor && IsPOD(field)) ||
|
|
(!copy_constructor && CanConstructByZeroing(field, options_))) {
|
|
if (last_start == NULL) {
|
|
last_start = field;
|
|
}
|
|
|
|
runs[last_start]++;
|
|
} else {
|
|
last_start = NULL;
|
|
}
|
|
}
|
|
|
|
string pod_template;
|
|
if (copy_constructor) {
|
|
pod_template =
|
|
"::memcpy(&$first$_, &from.$first$_,\n"
|
|
" static_cast<size_t>(reinterpret_cast<char*>(&$last$_) -\n"
|
|
" reinterpret_cast<char*>(&$first$_)) + sizeof($last$_));\n";
|
|
} else {
|
|
pod_template =
|
|
"::memset(&$first$_, 0, static_cast<size_t>(\n"
|
|
" reinterpret_cast<char*>(&$last$_) -\n"
|
|
" reinterpret_cast<char*>(&$first$_)) + sizeof($last$_));\n";
|
|
}
|
|
|
|
for (int i = 0; i < optimized_order_.size(); ++i) {
|
|
if (processed[i]) {
|
|
continue;
|
|
}
|
|
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
RunMap::const_iterator it = runs.find(field);
|
|
|
|
// We only apply the memset technique to runs of more than one field, as
|
|
// assignment is better than memset for generated code clarity.
|
|
if (it != runs.end() && it->second > 1) {
|
|
// Use a memset, then skip run_length fields.
|
|
const size_t run_length = it->second;
|
|
const string first_field_name = FieldName(field);
|
|
const string last_field_name =
|
|
FieldName(optimized_order_[i + run_length - 1]);
|
|
|
|
printer->Print(pod_template.c_str(),
|
|
"first", first_field_name,
|
|
"last", last_field_name);
|
|
|
|
i += run_length - 1;
|
|
// ++i at the top of the loop.
|
|
} else {
|
|
if (copy_constructor) {
|
|
field_generators_.get(field).GenerateCopyConstructorCode(printer);
|
|
} else {
|
|
field_generators_.get(field).GenerateConstructorCode(printer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateStructors(io::Printer* printer) {
|
|
string superclass;
|
|
if (use_dependent_base_) {
|
|
superclass =
|
|
DependentBaseClassTemplateName(descriptor_) + "<" + classname_ + ">";
|
|
} else {
|
|
superclass = SuperClassName(descriptor_, options_);
|
|
}
|
|
string initializer_with_arena = superclass + "()";
|
|
|
|
if (descriptor_->extension_range_count() > 0) {
|
|
initializer_with_arena += ",\n _extensions_(arena)";
|
|
}
|
|
|
|
initializer_with_arena += ",\n _internal_metadata_(arena)";
|
|
|
|
// Initialize member variables with arena constructor.
|
|
for (int i = 0; i < optimized_order_.size(); i++) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
|
|
bool has_arena_constructor = field->is_repeated();
|
|
if (has_arena_constructor) {
|
|
initializer_with_arena += string(",\n ") +
|
|
FieldName(field) + string("_(arena)");
|
|
}
|
|
}
|
|
|
|
if (IsAnyMessage(descriptor_)) {
|
|
initializer_with_arena += ",\n _any_metadata_(&type_url_, &value_)";
|
|
}
|
|
if (num_weak_fields_ > 0) {
|
|
initializer_with_arena += ", _weak_field_map_(arena)";
|
|
}
|
|
|
|
string initializer_null = superclass + "(), _internal_metadata_(NULL)";
|
|
if (IsAnyMessage(descriptor_)) {
|
|
initializer_null += ", _any_metadata_(&type_url_, &value_)";
|
|
}
|
|
if (num_weak_fields_ > 0) {
|
|
initializer_null += ", _weak_field_map_(NULL)";
|
|
}
|
|
|
|
printer->Print(
|
|
"$classname$::$classname$()\n"
|
|
" : $initializer$ {\n"
|
|
" if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {\n"
|
|
" ::$file_namespace$::InitDefaults$scc_name$();\n"
|
|
" }\n"
|
|
" SharedCtor();\n"
|
|
" // @@protoc_insertion_point(constructor:$full_name$)\n"
|
|
"}\n",
|
|
"classname", classname_, "full_name", descriptor_->full_name(),
|
|
"scc_name", scc_name_, "initializer", initializer_null, "file_namespace",
|
|
FileLevelNamespace(descriptor_));
|
|
|
|
if (SupportsArenas(descriptor_)) {
|
|
printer->Print(
|
|
"$classname$::$classname$(::google::protobuf::Arena* arena)\n"
|
|
" : $initializer$ {\n"
|
|
" ::$file_namespace$::InitDefaults$scc_name$();\n"
|
|
" SharedCtor();\n"
|
|
" RegisterArenaDtor(arena);\n"
|
|
" // @@protoc_insertion_point(arena_constructor:$full_name$)\n"
|
|
"}\n",
|
|
"initializer", initializer_with_arena, "classname", classname_,
|
|
"superclass", superclass, "full_name", descriptor_->full_name(),
|
|
"scc_name", scc_name_, "file_namespace",
|
|
FileLevelNamespace(descriptor_));
|
|
}
|
|
|
|
// Generate the copy constructor.
|
|
printer->Print(
|
|
"$classname$::$classname$(const $classname$& from)\n"
|
|
" : $superclass$()",
|
|
"classname", classname_,
|
|
"superclass", superclass,
|
|
"full_name", descriptor_->full_name());
|
|
printer->Indent();
|
|
printer->Indent();
|
|
printer->Indent();
|
|
|
|
printer->Print(
|
|
",\n_internal_metadata_(NULL)");
|
|
|
|
if (HasFieldPresence(descriptor_->file())) {
|
|
printer->Print(",\n_has_bits_(from._has_bits_)");
|
|
}
|
|
|
|
bool need_to_emit_cached_size = true;
|
|
const string cached_size_decl = ",\n_cached_size_(0)";
|
|
// We reproduce the logic used for laying out _cached_sized_ in the class
|
|
// definition, as to initialize it in-order.
|
|
if (HasFieldPresence(descriptor_->file()) &&
|
|
(HasBitsSize() % 8) != 0) {
|
|
printer->Print(cached_size_decl.c_str());
|
|
need_to_emit_cached_size = false;
|
|
}
|
|
|
|
std::vector<bool> processed(optimized_order_.size(), false);
|
|
for (int i = 0; i < optimized_order_.size(); ++i) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
|
|
if (!(field->is_repeated() && !(field->is_map()))
|
|
) {
|
|
continue;
|
|
}
|
|
|
|
processed[i] = true;
|
|
printer->Print(",\n$name$_(from.$name$_)",
|
|
"name", FieldName(field));
|
|
}
|
|
|
|
if (need_to_emit_cached_size) {
|
|
printer->Print(cached_size_decl.c_str());
|
|
need_to_emit_cached_size = false;
|
|
}
|
|
|
|
if (IsAnyMessage(descriptor_)) {
|
|
printer->Print(",\n_any_metadata_(&type_url_, &value_)");
|
|
}
|
|
if (num_weak_fields_ > 0) {
|
|
printer->Print(",\n_weak_field_map_(from._weak_field_map_)");
|
|
}
|
|
|
|
printer->Outdent();
|
|
printer->Outdent();
|
|
printer->Print(" {\n");
|
|
|
|
printer->Print(
|
|
"_internal_metadata_.MergeFrom(from._internal_metadata_);\n");
|
|
|
|
if (descriptor_->extension_range_count() > 0) {
|
|
printer->Print("_extensions_.MergeFrom(from._extensions_);\n");
|
|
}
|
|
|
|
GenerateConstructorBody(printer, processed, true);
|
|
|
|
// Copy oneof fields. Oneof field requires oneof case check.
|
|
for (int i = 0; i < descriptor_->oneof_decl_count(); ++i) {
|
|
printer->Print(
|
|
"clear_has_$oneofname$();\n"
|
|
"switch (from.$oneofname$_case()) {\n",
|
|
"oneofname", descriptor_->oneof_decl(i)->name());
|
|
printer->Indent();
|
|
for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
|
|
const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
|
|
printer->Print(
|
|
"case k$field_name$: {\n",
|
|
"field_name", UnderscoresToCamelCase(field->name(), true));
|
|
printer->Indent();
|
|
field_generators_.get(field).GenerateMergingCode(printer);
|
|
printer->Print(
|
|
"break;\n");
|
|
printer->Outdent();
|
|
printer->Print(
|
|
"}\n");
|
|
}
|
|
printer->Print(
|
|
"case $cap_oneof_name$_NOT_SET: {\n"
|
|
" break;\n"
|
|
"}\n",
|
|
"oneof_index",
|
|
SimpleItoa(descriptor_->oneof_decl(i)->index()),
|
|
"cap_oneof_name",
|
|
ToUpper(descriptor_->oneof_decl(i)->name()));
|
|
printer->Outdent();
|
|
printer->Print(
|
|
"}\n");
|
|
}
|
|
|
|
printer->Outdent();
|
|
printer->Print(
|
|
" // @@protoc_insertion_point(copy_constructor:$full_name$)\n"
|
|
"}\n"
|
|
"\n",
|
|
"full_name", descriptor_->full_name());
|
|
|
|
// Generate the shared constructor code.
|
|
GenerateSharedConstructorCode(printer);
|
|
|
|
// Generate the destructor.
|
|
printer->Print(
|
|
"$classname$::~$classname$() {\n"
|
|
" // @@protoc_insertion_point(destructor:$full_name$)\n"
|
|
" SharedDtor();\n"
|
|
"}\n"
|
|
"\n",
|
|
"classname", classname_,
|
|
"full_name", descriptor_->full_name());
|
|
|
|
// Generate the shared destructor code.
|
|
GenerateSharedDestructorCode(printer);
|
|
|
|
// Generate the arena-specific destructor code.
|
|
if (SupportsArenas(descriptor_)) {
|
|
GenerateArenaDestructorCode(printer);
|
|
}
|
|
|
|
// Generate SetCachedSize.
|
|
printer->Print(
|
|
"void $classname$::SetCachedSize(int size) const {\n"
|
|
" GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();\n"
|
|
" _cached_size_ = size;\n"
|
|
" GOOGLE_SAFE_CONCURRENT_WRITES_END();\n"
|
|
"}\n",
|
|
"classname", classname_);
|
|
|
|
// Only generate this member if it's not disabled.
|
|
if (HasDescriptorMethods(descriptor_->file(), options_) &&
|
|
!descriptor_->options().no_standard_descriptor_accessor()) {
|
|
printer->Print(
|
|
"const ::google::protobuf::Descriptor* $classname$::descriptor() {\n"
|
|
" ::$file_namespace$::protobuf_AssignDescriptorsOnce();\n"
|
|
" return ::"
|
|
"$file_namespace$::file_level_metadata[kIndexInFileMessages]."
|
|
"descriptor;\n"
|
|
"}\n"
|
|
"\n",
|
|
"classname", classname_, "file_namespace",
|
|
FileLevelNamespace(descriptor_));
|
|
}
|
|
|
|
printer->Print(
|
|
"const $classname$& $classname$::default_instance() {\n"
|
|
" ::$file_namespace$::InitDefaults$scc_name$();\n"
|
|
" return *internal_default_instance();\n"
|
|
"}\n\n",
|
|
"classname", classname_, "scc_name", scc_name_, "file_namespace",
|
|
FileLevelNamespace(descriptor_));
|
|
|
|
if (SupportsArenas(descriptor_)) {
|
|
printer->Print(
|
|
"$classname$* $classname$::New(::google::protobuf::Arena* arena) const {\n"
|
|
" return ::google::protobuf::Arena::CreateMessage<$classname$>(arena);\n"
|
|
"}\n",
|
|
"classname", classname_);
|
|
} else {
|
|
printer->Print(
|
|
"$classname$* $classname$::New(::google::protobuf::Arena* arena) const {\n"
|
|
" $classname$* n = new $classname$;\n"
|
|
" if (arena != NULL) {\n"
|
|
" arena->Own(n);\n"
|
|
" }\n"
|
|
" return n;\n"
|
|
"}\n",
|
|
"classname", classname_);
|
|
}
|
|
}
|
|
|
|
// Return the number of bits set in n, a non-negative integer.
|
|
static int popcnt(uint32 n) {
|
|
int result = 0;
|
|
while (n != 0) {
|
|
result += (n & 1);
|
|
n = n / 2;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool MessageGenerator::MaybeGenerateOptionalFieldCondition(
|
|
io::Printer* printer, const FieldDescriptor* field,
|
|
int expected_has_bits_index) {
|
|
int has_bit_index = has_bit_indices_[field->index()];
|
|
if (!field->options().weak() &&
|
|
expected_has_bits_index == has_bit_index / 32) {
|
|
const string mask =
|
|
StrCat(strings::Hex(1u << (has_bit_index % 32), strings::ZERO_PAD_8));
|
|
printer->Print(
|
|
"if (cached_has_bits & 0x$mask$u) {\n",
|
|
"mask", mask);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateClear(io::Printer* printer) {
|
|
// Performance tuning parameters
|
|
const int kMaxUnconditionalPrimitiveBytesClear = 4;
|
|
|
|
printer->Print(
|
|
"void $classname$::Clear() {\n"
|
|
"// @@protoc_insertion_point(message_clear_start:$full_name$)\n",
|
|
"classname", classname_, "full_name", descriptor_->full_name());
|
|
printer->Indent();
|
|
|
|
printer->Print(
|
|
// TODO(jwb): It would be better to avoid emitting this if it is not used,
|
|
// rather than emitting a workaround for the resulting warning.
|
|
"::google::protobuf::uint32 cached_has_bits = 0;\n"
|
|
"// Prevent compiler warnings about cached_has_bits being unused\n"
|
|
"(void) cached_has_bits;\n\n");
|
|
|
|
int cached_has_bit_index = -1;
|
|
|
|
// Step 1: Extensions
|
|
if (descriptor_->extension_range_count() > 0) {
|
|
printer->Print("_extensions_.Clear();\n");
|
|
}
|
|
|
|
int last_i = -1;
|
|
int unconditional_budget = kMaxUnconditionalPrimitiveBytesClear;
|
|
for (int i = 0; i < optimized_order_.size(); i++) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
|
|
if (!CanInitializeByZeroing(field)) {
|
|
continue;
|
|
}
|
|
|
|
unconditional_budget -= EstimateAlignmentSize(field);
|
|
}
|
|
|
|
for (int i = 0; i < optimized_order_.size(); ) {
|
|
// Detect infinite loops.
|
|
GOOGLE_CHECK_NE(i, last_i);
|
|
last_i = i;
|
|
|
|
// Step 2: Repeated fields don't use _has_bits_; emit code to clear them
|
|
// here.
|
|
for (; i < optimized_order_.size(); i++) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
const FieldGenerator& generator = field_generators_.get(field);
|
|
|
|
if (!field->is_repeated()) {
|
|
break;
|
|
}
|
|
|
|
generator.GenerateMessageClearingCode(printer);
|
|
}
|
|
|
|
// Step 3: Greedily seek runs of fields that can be cleared by
|
|
// memset-to-0.
|
|
int last_chunk = -1;
|
|
int last_chunk_start = -1;
|
|
int last_chunk_end = -1;
|
|
uint32 last_chunk_mask = 0;
|
|
|
|
int memset_run_start = -1;
|
|
int memset_run_end = -1;
|
|
for (; i < optimized_order_.size(); i++) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
|
|
if (!CanInitializeByZeroing(field)) {
|
|
break;
|
|
}
|
|
|
|
// "index" defines where in the _has_bits_ the field appears.
|
|
// "i" is our loop counter within optimized_order_.
|
|
int index = HasFieldPresence(descriptor_->file()) ?
|
|
has_bit_indices_[field->index()] : 0;
|
|
int chunk = index / 8;
|
|
|
|
if (last_chunk == -1) {
|
|
last_chunk = chunk;
|
|
last_chunk_start = i;
|
|
} else if (chunk != last_chunk) {
|
|
// Emit the fields for this chunk so far.
|
|
break;
|
|
}
|
|
|
|
if (memset_run_start == -1) {
|
|
memset_run_start = i;
|
|
}
|
|
|
|
memset_run_end = i;
|
|
last_chunk_end = i;
|
|
last_chunk_mask |= static_cast<uint32>(1) << (index % 32);
|
|
}
|
|
|
|
if (memset_run_start != memset_run_end && unconditional_budget >= 0) {
|
|
// Flush the memset fields.
|
|
goto flush;
|
|
}
|
|
|
|
// Step 4: Non-repeated, non-zero initializable fields.
|
|
for (; i < optimized_order_.size(); i++) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
if (field->is_repeated() || CanInitializeByZeroing(field)) {
|
|
break;
|
|
}
|
|
|
|
// "index" defines where in the _has_bits_ the field appears.
|
|
// "i" is our loop counter within optimized_order_.
|
|
int index = HasFieldPresence(descriptor_->file()) ?
|
|
has_bit_indices_[field->index()] : 0;
|
|
int chunk = index / 8;
|
|
|
|
if (last_chunk == -1) {
|
|
last_chunk = chunk;
|
|
last_chunk_start = i;
|
|
} else if (chunk != last_chunk) {
|
|
// Emit the fields for this chunk so far.
|
|
break;
|
|
}
|
|
|
|
last_chunk_end = i;
|
|
last_chunk_mask |= static_cast<uint32>(1) << (index % 32);
|
|
}
|
|
|
|
flush:
|
|
|
|
if (last_chunk != -1) {
|
|
GOOGLE_DCHECK_NE(-1, last_chunk_start);
|
|
GOOGLE_DCHECK_NE(-1, last_chunk_end);
|
|
GOOGLE_DCHECK_NE(0, last_chunk_mask);
|
|
|
|
const int count = popcnt(last_chunk_mask);
|
|
const bool have_outer_if = HasFieldPresence(descriptor_->file()) &&
|
|
(last_chunk_start != last_chunk_end) &&
|
|
(memset_run_start != last_chunk_start ||
|
|
memset_run_end != last_chunk_end ||
|
|
unconditional_budget < 0);
|
|
|
|
if (have_outer_if) {
|
|
// Check (up to) 8 has_bits at a time if we have more than one field in
|
|
// this chunk. Due to field layout ordering, we may check
|
|
// _has_bits_[last_chunk * 8 / 32] multiple times.
|
|
GOOGLE_DCHECK_LE(2, count);
|
|
GOOGLE_DCHECK_GE(8, count);
|
|
|
|
if (cached_has_bit_index != last_chunk / 4) {
|
|
cached_has_bit_index = last_chunk / 4;
|
|
printer->Print(
|
|
"cached_has_bits = _has_bits_[$idx$];\n",
|
|
"idx", SimpleItoa(cached_has_bit_index));
|
|
}
|
|
printer->Print(
|
|
"if (cached_has_bits & $mask$u) {\n",
|
|
"mask", SimpleItoa(last_chunk_mask));
|
|
printer->Indent();
|
|
}
|
|
|
|
if (memset_run_start != -1) {
|
|
if (memset_run_start == memset_run_end) {
|
|
// For clarity, do not memset a single field.
|
|
const FieldGenerator& generator =
|
|
field_generators_.get(optimized_order_[memset_run_start]);
|
|
generator.GenerateMessageClearingCode(printer);
|
|
} else {
|
|
const string first_field_name =
|
|
FieldName(optimized_order_[memset_run_start]);
|
|
const string last_field_name =
|
|
FieldName(optimized_order_[memset_run_end]);
|
|
|
|
printer->Print(
|
|
"::memset(&$first$_, 0, static_cast<size_t>(\n"
|
|
" reinterpret_cast<char*>(&$last$_) -\n"
|
|
" reinterpret_cast<char*>(&$first$_)) + sizeof($last$_));\n",
|
|
"first", first_field_name,
|
|
"last", last_field_name);
|
|
}
|
|
|
|
// Advance last_chunk_start to skip over the fields we zeroed/memset.
|
|
last_chunk_start = memset_run_end + 1;
|
|
}
|
|
|
|
// Go back and emit clears for each of the fields we processed.
|
|
for (int j = last_chunk_start; j <= last_chunk_end; j++) {
|
|
const FieldDescriptor* field = optimized_order_[j];
|
|
const string fieldname = FieldName(field);
|
|
const FieldGenerator& generator = field_generators_.get(field);
|
|
|
|
// It's faster to just overwrite primitive types, but we should only
|
|
// clear strings and messages if they were set.
|
|
//
|
|
// TODO(kenton): Let the CppFieldGenerator decide this somehow.
|
|
bool should_check_bit =
|
|
field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE ||
|
|
field->cpp_type() == FieldDescriptor::CPPTYPE_STRING;
|
|
|
|
bool have_enclosing_if = false;
|
|
if (should_check_bit &&
|
|
// If no field presence, then always clear strings/messages as well.
|
|
HasFieldPresence(descriptor_->file())) {
|
|
if (!field->options().weak() &&
|
|
cached_has_bit_index != (has_bit_indices_[field->index()] / 32)) {
|
|
cached_has_bit_index = (has_bit_indices_[field->index()] / 32);
|
|
printer->Print("cached_has_bits = _has_bits_[$new_index$];\n",
|
|
"new_index", SimpleItoa(cached_has_bit_index));
|
|
}
|
|
if (!MaybeGenerateOptionalFieldCondition(printer, field,
|
|
cached_has_bit_index)) {
|
|
printer->Print(
|
|
"if (has_$name$()) {\n",
|
|
"name", fieldname);
|
|
}
|
|
printer->Indent();
|
|
have_enclosing_if = true;
|
|
}
|
|
|
|
generator.GenerateMessageClearingCode(printer);
|
|
|
|
if (have_enclosing_if) {
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
}
|
|
}
|
|
|
|
if (have_outer_if) {
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Step 4: Unions.
|
|
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
|
|
printer->Print(
|
|
"clear_$oneof_name$();\n",
|
|
"oneof_name", descriptor_->oneof_decl(i)->name());
|
|
}
|
|
|
|
if (num_weak_fields_) {
|
|
printer->Print("_weak_field_map_.ClearAll();\n");
|
|
}
|
|
|
|
if (HasFieldPresence(descriptor_->file())) {
|
|
// Step 5: Everything else.
|
|
printer->Print("_has_bits_.Clear();\n");
|
|
}
|
|
|
|
printer->Print("_internal_metadata_.Clear();\n");
|
|
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateOneofClear(io::Printer* printer) {
|
|
// Generated function clears the active field and union case (e.g. foo_case_).
|
|
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
|
|
std::map<string, string> oneof_vars;
|
|
oneof_vars["classname"] = classname_;
|
|
oneof_vars["oneofname"] = descriptor_->oneof_decl(i)->name();
|
|
oneof_vars["full_name"] = descriptor_->full_name();
|
|
string message_class;
|
|
|
|
printer->Print(oneof_vars,
|
|
"void $classname$::clear_$oneofname$() {\n"
|
|
"// @@protoc_insertion_point(one_of_clear_start:"
|
|
"$full_name$)\n");
|
|
printer->Indent();
|
|
printer->Print(oneof_vars,
|
|
"switch ($oneofname$_case()) {\n");
|
|
printer->Indent();
|
|
for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
|
|
const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
|
|
printer->Print(
|
|
"case k$field_name$: {\n",
|
|
"field_name", UnderscoresToCamelCase(field->name(), true));
|
|
printer->Indent();
|
|
// We clear only allocated objects in oneofs
|
|
if (!IsStringOrMessage(field)) {
|
|
printer->Print(
|
|
"// No need to clear\n");
|
|
} else {
|
|
field_generators_.get(field).GenerateClearingCode(printer);
|
|
}
|
|
printer->Print(
|
|
"break;\n");
|
|
printer->Outdent();
|
|
printer->Print(
|
|
"}\n");
|
|
}
|
|
printer->Print(
|
|
"case $cap_oneof_name$_NOT_SET: {\n"
|
|
" break;\n"
|
|
"}\n",
|
|
"cap_oneof_name",
|
|
ToUpper(descriptor_->oneof_decl(i)->name()));
|
|
printer->Outdent();
|
|
printer->Print(
|
|
"}\n"
|
|
"_oneof_case_[$oneof_index$] = $cap_oneof_name$_NOT_SET;\n",
|
|
"oneof_index", SimpleItoa(i),
|
|
"cap_oneof_name",
|
|
ToUpper(descriptor_->oneof_decl(i)->name()));
|
|
printer->Outdent();
|
|
printer->Print(
|
|
"}\n"
|
|
"\n");
|
|
}
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateSwap(io::Printer* printer) {
|
|
if (SupportsArenas(descriptor_)) {
|
|
// Generate the Swap member function. This is a lightweight wrapper around
|
|
// UnsafeArenaSwap() / MergeFrom() with temporaries, depending on the memory
|
|
// ownership situation: swapping across arenas or between an arena and a
|
|
// heap requires copying.
|
|
printer->Print(
|
|
"void $classname$::Swap($classname$* other) {\n"
|
|
" if (other == this) return;\n"
|
|
" if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {\n"
|
|
" InternalSwap(other);\n"
|
|
" } else {\n"
|
|
" $classname$* temp = New(GetArenaNoVirtual());\n"
|
|
" temp->MergeFrom(*other);\n"
|
|
" other->CopyFrom(*this);\n"
|
|
" InternalSwap(temp);\n"
|
|
" if (GetArenaNoVirtual() == NULL) {\n"
|
|
" delete temp;\n"
|
|
" }\n"
|
|
" }\n"
|
|
"}\n"
|
|
"void $classname$::UnsafeArenaSwap($classname$* other) {\n"
|
|
" if (other == this) return;\n"
|
|
" GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());\n"
|
|
" InternalSwap(other);\n"
|
|
"}\n",
|
|
"classname", classname_);
|
|
} else {
|
|
printer->Print(
|
|
"void $classname$::Swap($classname$* other) {\n"
|
|
" if (other == this) return;\n"
|
|
" InternalSwap(other);\n"
|
|
"}\n",
|
|
"classname", classname_);
|
|
}
|
|
|
|
// Generate the UnsafeArenaSwap member function.
|
|
printer->Print("void $classname$::InternalSwap($classname$* other) {\n",
|
|
"classname", classname_);
|
|
printer->Indent();
|
|
printer->Print("using std::swap;\n");
|
|
|
|
if (HasGeneratedMethods(descriptor_->file(), options_)) {
|
|
for (int i = 0; i < optimized_order_.size(); i++) {
|
|
// optimized_order_ does not contain oneof fields, but the field
|
|
// generators for these fields do not emit swapping code on their own.
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
field_generators_.get(field).GenerateSwappingCode(printer);
|
|
}
|
|
|
|
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
|
|
printer->Print(
|
|
"swap($oneof_name$_, other->$oneof_name$_);\n"
|
|
"swap(_oneof_case_[$i$], other->_oneof_case_[$i$]);\n",
|
|
"oneof_name", descriptor_->oneof_decl(i)->name(),
|
|
"i", SimpleItoa(i));
|
|
}
|
|
|
|
if (HasFieldPresence(descriptor_->file())) {
|
|
for (int i = 0; i < HasBitsSize() / 4; ++i) {
|
|
printer->Print("swap(_has_bits_[$i$], other->_has_bits_[$i$]);\n",
|
|
"i", SimpleItoa(i));
|
|
}
|
|
}
|
|
|
|
printer->Print("_internal_metadata_.Swap(&other->_internal_metadata_);\n");
|
|
|
|
printer->Print("swap(_cached_size_, other->_cached_size_);\n");
|
|
if (descriptor_->extension_range_count() > 0) {
|
|
printer->Print("_extensions_.Swap(&other->_extensions_);\n");
|
|
}
|
|
if (num_weak_fields_) {
|
|
printer->Print(
|
|
"_weak_field_map_.UnsafeArenaSwap(&other->_weak_field_map_);\n");
|
|
}
|
|
} else {
|
|
printer->Print("GetReflection()->Swap(this, other);");
|
|
}
|
|
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateMergeFrom(io::Printer* printer) {
|
|
if (HasDescriptorMethods(descriptor_->file(), options_)) {
|
|
// Generate the generalized MergeFrom (aka that which takes in the Message
|
|
// base class as a parameter).
|
|
printer->Print(
|
|
"void $classname$::MergeFrom(const ::google::protobuf::Message& from) {\n"
|
|
"// @@protoc_insertion_point(generalized_merge_from_start:"
|
|
"$full_name$)\n"
|
|
" GOOGLE_DCHECK_NE(&from, this);\n",
|
|
"classname", classname_, "full_name", descriptor_->full_name());
|
|
printer->Indent();
|
|
|
|
// Cast the message to the proper type. If we find that the message is
|
|
// *not* of the proper type, we can still call Merge via the reflection
|
|
// system, as the GOOGLE_CHECK above ensured that we have the same descriptor
|
|
// for each message.
|
|
printer->Print(
|
|
"const $classname$* source =\n"
|
|
" ::google::protobuf::internal::DynamicCastToGenerated<const $classname$>(\n"
|
|
" &from);\n"
|
|
"if (source == NULL) {\n"
|
|
"// @@protoc_insertion_point(generalized_merge_from_cast_fail:"
|
|
"$full_name$)\n"
|
|
" ::google::protobuf::internal::ReflectionOps::Merge(from, this);\n"
|
|
"} else {\n"
|
|
"// @@protoc_insertion_point(generalized_merge_from_cast_success:"
|
|
"$full_name$)\n"
|
|
" MergeFrom(*source);\n"
|
|
"}\n",
|
|
"classname", classname_, "full_name", descriptor_->full_name());
|
|
|
|
printer->Outdent();
|
|
printer->Print("}\n\n");
|
|
} else {
|
|
// Generate CheckTypeAndMergeFrom().
|
|
printer->Print(
|
|
"void $classname$::CheckTypeAndMergeFrom(\n"
|
|
" const ::google::protobuf::MessageLite& from) {\n"
|
|
" MergeFrom(*::google::protobuf::down_cast<const $classname$*>(&from));\n"
|
|
"}\n"
|
|
"\n",
|
|
"classname", classname_);
|
|
}
|
|
|
|
// Generate the class-specific MergeFrom, which avoids the GOOGLE_CHECK and cast.
|
|
printer->Print(
|
|
"void $classname$::MergeFrom(const $classname$& from) {\n"
|
|
"// @@protoc_insertion_point(class_specific_merge_from_start:"
|
|
"$full_name$)\n"
|
|
" GOOGLE_DCHECK_NE(&from, this);\n",
|
|
"classname", classname_, "full_name", descriptor_->full_name());
|
|
printer->Indent();
|
|
|
|
if (descriptor_->extension_range_count() > 0) {
|
|
printer->Print("_extensions_.MergeFrom(from._extensions_);\n");
|
|
}
|
|
|
|
printer->Print(
|
|
"_internal_metadata_.MergeFrom(from._internal_metadata_);\n"
|
|
"::google::protobuf::uint32 cached_has_bits = 0;\n"
|
|
"(void) cached_has_bits;\n\n");
|
|
|
|
// cached_has_bit_index maintains that:
|
|
// cached_has_bits = from._has_bits_[cached_has_bit_index]
|
|
// for cached_has_bit_index >= 0
|
|
int cached_has_bit_index = -1;
|
|
|
|
int last_i = -1;
|
|
for (int i = 0; i < optimized_order_.size(); ) {
|
|
// Detect infinite loops.
|
|
GOOGLE_CHECK_NE(i, last_i);
|
|
last_i = i;
|
|
|
|
// Merge Repeated fields. These fields do not require a
|
|
// check as we can simply iterate over them.
|
|
for (; i < optimized_order_.size(); i++) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
if (!field->is_repeated()) {
|
|
break;
|
|
}
|
|
|
|
const FieldGenerator& generator = field_generators_.get(field);
|
|
generator.GenerateMergingCode(printer);
|
|
}
|
|
|
|
// Merge Optional and Required fields (after a _has_bit_ check).
|
|
int last_chunk = -1;
|
|
int last_chunk_start = -1;
|
|
int last_chunk_end = -1;
|
|
uint32 last_chunk_mask = 0;
|
|
for (; i < optimized_order_.size(); i++) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
if (field->is_repeated()) {
|
|
break;
|
|
}
|
|
|
|
// "index" defines where in the _has_bits_ the field appears.
|
|
// "i" is our loop counter within optimized_order_.
|
|
int index = HasFieldPresence(descriptor_->file()) ?
|
|
has_bit_indices_[field->index()] : 0;
|
|
int chunk = index / 8;
|
|
|
|
if (last_chunk == -1) {
|
|
last_chunk = chunk;
|
|
last_chunk_start = i;
|
|
} else if (chunk != last_chunk) {
|
|
// Emit the fields for this chunk so far.
|
|
break;
|
|
}
|
|
|
|
last_chunk_end = i;
|
|
last_chunk_mask |= static_cast<uint32>(1) << (index % 32);
|
|
}
|
|
|
|
if (last_chunk != -1) {
|
|
GOOGLE_DCHECK_NE(-1, last_chunk_start);
|
|
GOOGLE_DCHECK_NE(-1, last_chunk_end);
|
|
GOOGLE_DCHECK_NE(0, last_chunk_mask);
|
|
|
|
const int count = popcnt(last_chunk_mask);
|
|
const bool have_outer_if = HasFieldPresence(descriptor_->file()) &&
|
|
(last_chunk_start != last_chunk_end);
|
|
|
|
if (have_outer_if) {
|
|
// Check (up to) 8 has_bits at a time if we have more than one field in
|
|
// this chunk. Due to field layout ordering, we may check
|
|
// _has_bits_[last_chunk * 8 / 32] multiple times.
|
|
GOOGLE_DCHECK_LE(2, count);
|
|
GOOGLE_DCHECK_GE(8, count);
|
|
|
|
if (cached_has_bit_index != last_chunk / 4) {
|
|
int new_index = last_chunk / 4;
|
|
printer->Print("cached_has_bits = from._has_bits_[$new_index$];\n",
|
|
"new_index", SimpleItoa(new_index));
|
|
cached_has_bit_index = new_index;
|
|
}
|
|
|
|
printer->Print(
|
|
"if (cached_has_bits & $mask$u) {\n",
|
|
"mask", SimpleItoa(last_chunk_mask));
|
|
printer->Indent();
|
|
}
|
|
|
|
// Go back and emit clears for each of the fields we processed.
|
|
bool deferred_has_bit_changes = false;
|
|
for (int j = last_chunk_start; j <= last_chunk_end; j++) {
|
|
const FieldDescriptor* field = optimized_order_[j];
|
|
const FieldGenerator& generator = field_generators_.get(field);
|
|
|
|
bool have_enclosing_if = false;
|
|
if (HasFieldPresence(descriptor_->file())) {
|
|
// Attempt to use the state of cached_has_bits, if possible.
|
|
int has_bit_index = has_bit_indices_[field->index()];
|
|
if (!field->options().weak() &&
|
|
cached_has_bit_index == has_bit_index / 32) {
|
|
const string mask = StrCat(
|
|
strings::Hex(1u << (has_bit_index % 32),
|
|
strings::ZERO_PAD_8));
|
|
|
|
printer->Print(
|
|
"if (cached_has_bits & 0x$mask$u) {\n", "mask", mask);
|
|
} else {
|
|
printer->Print(
|
|
"if (from.has_$name$()) {\n",
|
|
"name", FieldName(field));
|
|
}
|
|
|
|
printer->Indent();
|
|
have_enclosing_if = true;
|
|
} else {
|
|
// Merge semantics without true field presence: primitive fields are
|
|
// merged only if non-zero (numeric) or non-empty (string).
|
|
have_enclosing_if = EmitFieldNonDefaultCondition(
|
|
printer, "from.", field);
|
|
}
|
|
|
|
if (have_outer_if && IsPOD(field)) {
|
|
// GenerateCopyConstructorCode for enum and primitive scalar fields
|
|
// does not do _has_bits_ modifications. We defer _has_bits_
|
|
// manipulation until the end of the outer if.
|
|
//
|
|
// This can reduce the number of loads/stores by up to 7 per 8 fields.
|
|
deferred_has_bit_changes = true;
|
|
generator.GenerateCopyConstructorCode(printer);
|
|
} else {
|
|
generator.GenerateMergingCode(printer);
|
|
}
|
|
|
|
if (have_enclosing_if) {
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
}
|
|
}
|
|
|
|
if (have_outer_if) {
|
|
if (deferred_has_bit_changes) {
|
|
// Flush the has bits for the primitives we deferred.
|
|
GOOGLE_CHECK_LE(0, cached_has_bit_index);
|
|
printer->Print(
|
|
"_has_bits_[$index$] |= cached_has_bits;\n",
|
|
"index", SimpleItoa(cached_has_bit_index));
|
|
}
|
|
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Merge oneof fields. Oneof field requires oneof case check.
|
|
for (int i = 0; i < descriptor_->oneof_decl_count(); ++i) {
|
|
printer->Print(
|
|
"switch (from.$oneofname$_case()) {\n",
|
|
"oneofname", descriptor_->oneof_decl(i)->name());
|
|
printer->Indent();
|
|
for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
|
|
const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
|
|
printer->Print(
|
|
"case k$field_name$: {\n",
|
|
"field_name", UnderscoresToCamelCase(field->name(), true));
|
|
printer->Indent();
|
|
field_generators_.get(field).GenerateMergingCode(printer);
|
|
printer->Print(
|
|
"break;\n");
|
|
printer->Outdent();
|
|
printer->Print(
|
|
"}\n");
|
|
}
|
|
printer->Print(
|
|
"case $cap_oneof_name$_NOT_SET: {\n"
|
|
" break;\n"
|
|
"}\n",
|
|
"cap_oneof_name",
|
|
ToUpper(descriptor_->oneof_decl(i)->name()));
|
|
printer->Outdent();
|
|
printer->Print(
|
|
"}\n");
|
|
}
|
|
if (num_weak_fields_) {
|
|
printer->Print("_weak_field_map_.MergeFrom(from._weak_field_map_);\n");
|
|
}
|
|
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateCopyFrom(io::Printer* printer) {
|
|
if (HasDescriptorMethods(descriptor_->file(), options_)) {
|
|
// Generate the generalized CopyFrom (aka that which takes in the Message
|
|
// base class as a parameter).
|
|
printer->Print(
|
|
"void $classname$::CopyFrom(const ::google::protobuf::Message& from) {\n"
|
|
"// @@protoc_insertion_point(generalized_copy_from_start:"
|
|
"$full_name$)\n",
|
|
"classname", classname_, "full_name", descriptor_->full_name());
|
|
printer->Indent();
|
|
|
|
printer->Print(
|
|
"if (&from == this) return;\n"
|
|
"Clear();\n"
|
|
"MergeFrom(from);\n");
|
|
|
|
printer->Outdent();
|
|
printer->Print("}\n\n");
|
|
}
|
|
|
|
// Generate the class-specific CopyFrom.
|
|
printer->Print(
|
|
"void $classname$::CopyFrom(const $classname$& from) {\n"
|
|
"// @@protoc_insertion_point(class_specific_copy_from_start:"
|
|
"$full_name$)\n",
|
|
"classname", classname_, "full_name", descriptor_->full_name());
|
|
printer->Indent();
|
|
|
|
printer->Print(
|
|
"if (&from == this) return;\n"
|
|
"Clear();\n"
|
|
"MergeFrom(from);\n");
|
|
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateMergeFromCodedStream(io::Printer* printer) {
|
|
std::map<string, string> vars;
|
|
SetUnknkownFieldsVariable(descriptor_, options_, &vars);
|
|
if (descriptor_->options().message_set_wire_format()) {
|
|
// Special-case MessageSet.
|
|
vars["classname"] = classname_;
|
|
printer->Print(vars,
|
|
"bool $classname$::MergePartialFromCodedStream(\n"
|
|
" ::google::protobuf::io::CodedInputStream* input) {\n"
|
|
" return _extensions_.ParseMessageSet(input,\n"
|
|
" internal_default_instance(), $mutable_unknown_fields$);\n"
|
|
"}\n");
|
|
return;
|
|
}
|
|
|
|
std::vector<const FieldDescriptor*> ordered_fields =
|
|
SortFieldsByNumber(descriptor_);
|
|
|
|
printer->Print(
|
|
"bool $classname$::MergePartialFromCodedStream(\n"
|
|
" ::google::protobuf::io::CodedInputStream* input) {\n",
|
|
"classname", classname_);
|
|
|
|
if (table_driven_) {
|
|
printer->Indent();
|
|
|
|
const string lite = UseUnknownFieldSet(descriptor_->file(), options_) ?
|
|
"" : "Lite";
|
|
|
|
printer->Print(
|
|
"return ::google::protobuf::internal::MergePartialFromCodedStream$lite$(\n"
|
|
" this,\n"
|
|
" ::$file_namespace$::TableStruct::schema[\n"
|
|
" $classname$::kIndexInFileMessages],\n"
|
|
" input);\n",
|
|
"classname", classname_, "file_namespace",
|
|
FileLevelNamespace(descriptor_), "lite", lite);
|
|
|
|
printer->Outdent();
|
|
|
|
printer->Print("}\n");
|
|
return;
|
|
}
|
|
|
|
printer->Print(
|
|
"#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure\n"
|
|
" ::google::protobuf::uint32 tag;\n");
|
|
|
|
if (!UseUnknownFieldSet(descriptor_->file(), options_)) {
|
|
printer->Print(
|
|
" ::google::protobuf::internal::LiteUnknownFieldSetter unknown_fields_setter(\n"
|
|
" &_internal_metadata_);\n"
|
|
" ::google::protobuf::io::StringOutputStream unknown_fields_output(\n"
|
|
" unknown_fields_setter.buffer());\n"
|
|
" ::google::protobuf::io::CodedOutputStream unknown_fields_stream(\n"
|
|
" &unknown_fields_output, false);\n",
|
|
"classname", classname_);
|
|
}
|
|
|
|
printer->Print(
|
|
" // @@protoc_insertion_point(parse_start:$full_name$)\n",
|
|
"full_name", descriptor_->full_name());
|
|
|
|
printer->Indent();
|
|
printer->Print("for (;;) {\n");
|
|
printer->Indent();
|
|
|
|
uint32 maxtag = descriptor_->field_count() == 0 ? 0 :
|
|
WireFormat::MakeTag(ordered_fields[descriptor_->field_count() - 1]);
|
|
const int kCutoff0 = 127; // fits in 1-byte varint
|
|
const int kCutoff1 = (127 << 7) + 127; // fits in 2-byte varint
|
|
|
|
// We need to capture the last tag when parsing if this is a Group type, as
|
|
// our caller will verify (via CodedInputStream::LastTagWas) that the correct
|
|
// closing tag was received.
|
|
bool capture_last_tag = false;
|
|
const Descriptor* parent = descriptor_->containing_type();
|
|
if (parent) {
|
|
for (int i = 0; i < parent->field_count(); i++) {
|
|
const FieldDescriptor* field = parent->field(i);
|
|
if (field->type() == FieldDescriptor::TYPE_GROUP &&
|
|
field->message_type() == descriptor_) {
|
|
capture_last_tag = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < descriptor_->file()->extension_count(); i++) {
|
|
const FieldDescriptor* field = descriptor_->file()->extension(i);
|
|
if (field->type() == FieldDescriptor::TYPE_GROUP &&
|
|
field->message_type() == descriptor_) {
|
|
capture_last_tag = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
printer->Print("::std::pair< ::google::protobuf::uint32, bool> p = "
|
|
"input->ReadTagWithCutoffNoLastTag($max$u);\n"
|
|
"tag = p.first;\n"
|
|
"if (!p.second) goto handle_unusual;\n",
|
|
"max", SimpleItoa(maxtag <= kCutoff0 ? kCutoff0 :
|
|
(maxtag <= kCutoff1 ? kCutoff1 :
|
|
maxtag)));
|
|
|
|
if (descriptor_->field_count() > 0) {
|
|
// We don't even want to print the switch() if we have no fields because
|
|
// MSVC dislikes switch() statements that contain only a default value.
|
|
|
|
// Note: If we just switched on the tag rather than the field number, we
|
|
// could avoid the need for the if() to check the wire type at the beginning
|
|
// of each case. However, this is actually a bit slower in practice as it
|
|
// creates a jump table that is 8x larger and sparser, and meanwhile the
|
|
// if()s are highly predictable.
|
|
//
|
|
// Historically, we inserted checks to peek at the next tag on the wire and
|
|
// jump directly to the next case statement. While this avoids the jump
|
|
// table that the switch uses, it greatly increases code size (20-60%) and
|
|
// inserts branches that may fail (especially for real world protos that
|
|
// interleave--in field number order--hot and cold fields). Loadtests
|
|
// confirmed that removing this optimization is performance neutral.
|
|
printer->Print("switch (::google::protobuf::internal::WireFormatLite::"
|
|
"GetTagFieldNumber(tag)) {\n");
|
|
|
|
printer->Indent();
|
|
|
|
for (int i = 0; i < ordered_fields.size(); i++) {
|
|
const FieldDescriptor* field = ordered_fields[i];
|
|
|
|
PrintFieldComment(printer, field);
|
|
|
|
printer->Print(
|
|
"case $number$: {\n",
|
|
"number", SimpleItoa(field->number()));
|
|
printer->Indent();
|
|
const FieldGenerator& field_generator = field_generators_.get(field);
|
|
|
|
// Emit code to parse the common, expected case.
|
|
printer->Print(
|
|
"if (static_cast< ::google::protobuf::uint8>(tag) ==\n"
|
|
" static_cast< ::google::protobuf::uint8>($truncated$u /* $full$ & 0xFF */)) {\n",
|
|
"truncated", SimpleItoa(WireFormat::MakeTag(field) & 0xFF),
|
|
"full", SimpleItoa(WireFormat::MakeTag(field)));
|
|
|
|
printer->Indent();
|
|
if (field->is_packed()) {
|
|
field_generator.GenerateMergeFromCodedStreamWithPacking(printer);
|
|
} else {
|
|
field_generator.GenerateMergeFromCodedStream(printer);
|
|
}
|
|
printer->Outdent();
|
|
|
|
// Emit code to parse unexpectedly packed or unpacked values.
|
|
if (field->is_packed()) {
|
|
internal::WireFormatLite::WireType wiretype =
|
|
WireFormat::WireTypeForFieldType(field->type());
|
|
const uint32 tag = internal::WireFormatLite::MakeTag(
|
|
field->number(), wiretype);
|
|
printer->Print(
|
|
"} else if (\n"
|
|
" static_cast< ::google::protobuf::uint8>(tag) ==\n"
|
|
" static_cast< ::google::protobuf::uint8>($truncated$u /* $full$ & 0xFF */)) {\n",
|
|
"truncated", SimpleItoa(tag & 0xFF),
|
|
"full", SimpleItoa(tag));
|
|
|
|
printer->Indent();
|
|
field_generator.GenerateMergeFromCodedStream(printer);
|
|
printer->Outdent();
|
|
} else if (field->is_packable() && !field->is_packed()) {
|
|
internal::WireFormatLite::WireType wiretype =
|
|
internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED;
|
|
const uint32 tag = internal::WireFormatLite::MakeTag(
|
|
field->number(), wiretype);
|
|
|
|
printer->Print(
|
|
"} else if (\n"
|
|
" static_cast< ::google::protobuf::uint8>(tag) ==\n"
|
|
" static_cast< ::google::protobuf::uint8>($truncated$u /* $full$ & 0xFF */)) {\n",
|
|
"truncated", SimpleItoa(tag & 0xFF),
|
|
"full", SimpleItoa(tag));
|
|
printer->Indent();
|
|
field_generator.GenerateMergeFromCodedStreamWithPacking(printer);
|
|
printer->Outdent();
|
|
}
|
|
|
|
printer->Print(
|
|
"} else {\n"
|
|
" goto handle_unusual;\n"
|
|
"}\n");
|
|
|
|
printer->Print(
|
|
"break;\n");
|
|
|
|
printer->Outdent();
|
|
printer->Print("}\n\n");
|
|
}
|
|
|
|
printer->Print("default: {\n");
|
|
printer->Indent();
|
|
}
|
|
|
|
printer->Outdent();
|
|
printer->Print("handle_unusual:\n");
|
|
printer->Indent();
|
|
// If tag is 0 or an end-group tag then this must be the end of the message.
|
|
if (capture_last_tag) {
|
|
printer->Print(
|
|
"if (tag == 0 ||\n"
|
|
" ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==\n"
|
|
" ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {\n"
|
|
" input->SetLastTag(tag);\n"
|
|
" goto success;\n"
|
|
"}\n");
|
|
} else {
|
|
printer->Print(
|
|
"if (tag == 0) {\n"
|
|
" goto success;\n"
|
|
"}\n");
|
|
}
|
|
|
|
// Handle extension ranges.
|
|
if (descriptor_->extension_range_count() > 0) {
|
|
printer->Print(
|
|
"if (");
|
|
for (int i = 0; i < descriptor_->extension_range_count(); i++) {
|
|
const Descriptor::ExtensionRange* range =
|
|
descriptor_->extension_range(i);
|
|
if (i > 0) printer->Print(" ||\n ");
|
|
|
|
uint32 start_tag = WireFormatLite::MakeTag(
|
|
range->start, static_cast<WireFormatLite::WireType>(0));
|
|
uint32 end_tag = WireFormatLite::MakeTag(
|
|
range->end, static_cast<WireFormatLite::WireType>(0));
|
|
|
|
if (range->end > FieldDescriptor::kMaxNumber) {
|
|
printer->Print(
|
|
"($start$u <= tag)",
|
|
"start", SimpleItoa(start_tag));
|
|
} else {
|
|
printer->Print(
|
|
"($start$u <= tag && tag < $end$u)",
|
|
"start", SimpleItoa(start_tag),
|
|
"end", SimpleItoa(end_tag));
|
|
}
|
|
}
|
|
printer->Print(") {\n");
|
|
if (UseUnknownFieldSet(descriptor_->file(), options_)) {
|
|
printer->Print(vars,
|
|
" DO_(_extensions_.ParseField(tag, input,\n"
|
|
" internal_default_instance(),\n"
|
|
" $mutable_unknown_fields$));\n");
|
|
} else {
|
|
printer->Print(
|
|
" DO_(_extensions_.ParseField(tag, input,\n"
|
|
" internal_default_instance(),\n"
|
|
" &unknown_fields_stream));\n");
|
|
}
|
|
printer->Print(
|
|
" continue;\n"
|
|
"}\n");
|
|
}
|
|
|
|
// We really don't recognize this tag. Skip it.
|
|
if (UseUnknownFieldSet(descriptor_->file(), options_)) {
|
|
printer->Print(vars,
|
|
"DO_(::google::protobuf::internal::WireFormat::SkipField(\n"
|
|
" input, tag, $mutable_unknown_fields$));\n");
|
|
} else {
|
|
printer->Print(
|
|
"DO_(::google::protobuf::internal::WireFormatLite::SkipField(\n"
|
|
" input, tag, &unknown_fields_stream));\n");
|
|
}
|
|
|
|
if (descriptor_->field_count() > 0) {
|
|
printer->Print("break;\n");
|
|
printer->Outdent();
|
|
printer->Print("}\n"); // default:
|
|
printer->Outdent();
|
|
printer->Print("}\n"); // switch
|
|
}
|
|
|
|
printer->Outdent();
|
|
printer->Outdent();
|
|
printer->Print(
|
|
" }\n" // for (;;)
|
|
"success:\n"
|
|
" // @@protoc_insertion_point(parse_success:$full_name$)\n"
|
|
" return true;\n"
|
|
"failure:\n"
|
|
" // @@protoc_insertion_point(parse_failure:$full_name$)\n"
|
|
" return false;\n"
|
|
"#undef DO_\n"
|
|
"}\n", "full_name", descriptor_->full_name());
|
|
}
|
|
|
|
void MessageGenerator::GenerateSerializeOneofFields(
|
|
io::Printer* printer, const std::vector<const FieldDescriptor*>& fields,
|
|
bool to_array) {
|
|
GOOGLE_CHECK(!fields.empty());
|
|
if (fields.size() == 1) {
|
|
GenerateSerializeOneField(printer, fields[0], to_array, -1);
|
|
return;
|
|
}
|
|
// We have multiple mutually exclusive choices. Emit a switch statement.
|
|
const OneofDescriptor* oneof = fields[0]->containing_oneof();
|
|
printer->Print(
|
|
"switch ($oneofname$_case()) {\n",
|
|
"oneofname", oneof->name());
|
|
printer->Indent();
|
|
for (int i = 0; i < fields.size(); i++) {
|
|
const FieldDescriptor* field = fields[i];
|
|
printer->Print(
|
|
"case k$field_name$:\n",
|
|
"field_name", UnderscoresToCamelCase(field->name(), true));
|
|
printer->Indent();
|
|
if (to_array) {
|
|
field_generators_.get(field).GenerateSerializeWithCachedSizesToArray(
|
|
printer);
|
|
} else {
|
|
field_generators_.get(field).GenerateSerializeWithCachedSizes(printer);
|
|
}
|
|
printer->Print(
|
|
"break;\n");
|
|
printer->Outdent();
|
|
}
|
|
printer->Outdent();
|
|
// Doing nothing is an option.
|
|
printer->Print(
|
|
" default: ;\n"
|
|
"}\n");
|
|
}
|
|
|
|
void MessageGenerator::GenerateSerializeOneField(
|
|
io::Printer* printer, const FieldDescriptor* field, bool to_array,
|
|
int cached_has_bits_index) {
|
|
if (!field->options().weak()) {
|
|
// For weakfields, PrintFieldComment is called during iteration.
|
|
PrintFieldComment(printer, field);
|
|
}
|
|
|
|
bool have_enclosing_if = false;
|
|
if (field->options().weak()) {
|
|
} else if (!field->is_repeated() && HasFieldPresence(descriptor_->file())) {
|
|
// Attempt to use the state of cached_has_bits, if possible.
|
|
int has_bit_index = has_bit_indices_[field->index()];
|
|
if (cached_has_bits_index == has_bit_index / 32) {
|
|
const string mask = StrCat(
|
|
strings::Hex(1u << (has_bit_index % 32),
|
|
strings::ZERO_PAD_8));
|
|
|
|
printer->Print(
|
|
"if (cached_has_bits & 0x$mask$u) {\n", "mask", mask);
|
|
} else {
|
|
printer->Print(
|
|
"if (has_$name$()) {\n",
|
|
"name", FieldName(field));
|
|
}
|
|
|
|
printer->Indent();
|
|
have_enclosing_if = true;
|
|
} else if (!HasFieldPresence(descriptor_->file())) {
|
|
have_enclosing_if = EmitFieldNonDefaultCondition(printer, "this->", field);
|
|
}
|
|
|
|
if (to_array) {
|
|
field_generators_.get(field).GenerateSerializeWithCachedSizesToArray(
|
|
printer);
|
|
} else {
|
|
field_generators_.get(field).GenerateSerializeWithCachedSizes(printer);
|
|
}
|
|
|
|
if (have_enclosing_if) {
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
}
|
|
printer->Print("\n");
|
|
}
|
|
|
|
void MessageGenerator::GenerateSerializeOneExtensionRange(
|
|
io::Printer* printer, const Descriptor::ExtensionRange* range,
|
|
bool to_array) {
|
|
std::map<string, string> vars;
|
|
vars["start"] = SimpleItoa(range->start);
|
|
vars["end"] = SimpleItoa(range->end);
|
|
printer->Print(vars,
|
|
"// Extension range [$start$, $end$)\n");
|
|
if (to_array) {
|
|
printer->Print(vars,
|
|
"target = _extensions_.InternalSerializeWithCachedSizesToArray(\n"
|
|
" $start$, $end$, deterministic, target);\n\n");
|
|
} else {
|
|
printer->Print(vars,
|
|
"_extensions_.SerializeWithCachedSizes(\n"
|
|
" $start$, $end$, output);\n\n");
|
|
}
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateSerializeWithCachedSizes(io::Printer* printer) {
|
|
if (descriptor_->options().message_set_wire_format()) {
|
|
// Special-case MessageSet.
|
|
printer->Print(
|
|
"void $classname$::SerializeWithCachedSizes(\n"
|
|
" ::google::protobuf::io::CodedOutputStream* output) const {\n"
|
|
" _extensions_.SerializeMessageSetWithCachedSizes(output);\n",
|
|
"classname", classname_);
|
|
GOOGLE_CHECK(UseUnknownFieldSet(descriptor_->file(), options_));
|
|
std::map<string, string> vars;
|
|
SetUnknkownFieldsVariable(descriptor_, options_, &vars);
|
|
printer->Print(vars,
|
|
" ::google::protobuf::internal::WireFormat::SerializeUnknownMessageSetItems(\n"
|
|
" $unknown_fields$, output);\n");
|
|
printer->Print(
|
|
"}\n");
|
|
return;
|
|
}
|
|
if (options_.table_driven_serialization) return;
|
|
|
|
printer->Print(
|
|
"void $classname$::SerializeWithCachedSizes(\n"
|
|
" ::google::protobuf::io::CodedOutputStream* output) const {\n",
|
|
"classname", classname_);
|
|
printer->Indent();
|
|
|
|
printer->Print(
|
|
"// @@protoc_insertion_point(serialize_start:$full_name$)\n",
|
|
"full_name", descriptor_->full_name());
|
|
|
|
GenerateSerializeWithCachedSizesBody(printer, false);
|
|
|
|
printer->Print(
|
|
"// @@protoc_insertion_point(serialize_end:$full_name$)\n",
|
|
"full_name", descriptor_->full_name());
|
|
|
|
printer->Outdent();
|
|
printer->Print(
|
|
"}\n");
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateSerializeWithCachedSizesToArray(io::Printer* printer) {
|
|
if (descriptor_->options().message_set_wire_format()) {
|
|
// Special-case MessageSet.
|
|
printer->Print(
|
|
"::google::protobuf::uint8* $classname$::InternalSerializeWithCachedSizesToArray(\n"
|
|
" bool deterministic, ::google::protobuf::uint8* target) const {\n"
|
|
" target = _extensions_."
|
|
"InternalSerializeMessageSetWithCachedSizesToArray(\n"
|
|
" deterministic, target);\n",
|
|
"classname", classname_);
|
|
GOOGLE_CHECK(UseUnknownFieldSet(descriptor_->file(), options_));
|
|
std::map<string, string> vars;
|
|
SetUnknkownFieldsVariable(descriptor_, options_, &vars);
|
|
printer->Print(vars,
|
|
" target = ::google::protobuf::internal::WireFormat::\n"
|
|
" SerializeUnknownMessageSetItemsToArray(\n"
|
|
" $unknown_fields$, target);\n");
|
|
printer->Print(
|
|
" return target;\n"
|
|
"}\n");
|
|
return;
|
|
}
|
|
|
|
printer->Print(
|
|
"::google::protobuf::uint8* $classname$::InternalSerializeWithCachedSizesToArray(\n"
|
|
" bool deterministic, ::google::protobuf::uint8* target) const {\n",
|
|
"classname", classname_);
|
|
printer->Indent();
|
|
|
|
printer->Print("(void)deterministic; // Unused\n");
|
|
printer->Print(
|
|
"// @@protoc_insertion_point(serialize_to_array_start:$full_name$)\n",
|
|
"full_name", descriptor_->full_name());
|
|
|
|
GenerateSerializeWithCachedSizesBody(printer, true);
|
|
|
|
printer->Print(
|
|
"// @@protoc_insertion_point(serialize_to_array_end:$full_name$)\n",
|
|
"full_name", descriptor_->full_name());
|
|
|
|
printer->Outdent();
|
|
printer->Print(
|
|
" return target;\n"
|
|
"}\n");
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateSerializeWithCachedSizesBody(io::Printer* printer, bool to_array) {
|
|
// If there are multiple fields in a row from the same oneof then we
|
|
// coalesce them and emit a switch statement. This is more efficient
|
|
// because it lets the C++ compiler know this is a "at most one can happen"
|
|
// situation. If we emitted "if (has_x()) ...; if (has_y()) ..." the C++
|
|
// compiler's emitted code might check has_y() even when has_x() is true.
|
|
class LazySerializerEmitter {
|
|
public:
|
|
LazySerializerEmitter(MessageGenerator* mg, io::Printer* printer,
|
|
bool to_array)
|
|
: mg_(mg),
|
|
printer_(printer),
|
|
to_array_(to_array),
|
|
eager_(!HasFieldPresence(mg->descriptor_->file())),
|
|
cached_has_bit_index_(-1) {}
|
|
|
|
~LazySerializerEmitter() { Flush(); }
|
|
|
|
// If conditions allow, try to accumulate a run of fields from the same
|
|
// oneof, and handle them at the next Flush().
|
|
void Emit(const FieldDescriptor* field) {
|
|
if (eager_ || MustFlush(field)) {
|
|
Flush();
|
|
}
|
|
if (field->containing_oneof() == NULL) {
|
|
// TODO(ckennelly): Defer non-oneof fields similarly to oneof fields.
|
|
|
|
if (!field->options().weak() && !field->is_repeated() && !eager_) {
|
|
// We speculatively load the entire _has_bits_[index] contents, even
|
|
// if it is for only one field. Deferring non-oneof emitting would
|
|
// allow us to determine whether this is going to be useful.
|
|
int has_bit_index = mg_->has_bit_indices_[field->index()];
|
|
if (cached_has_bit_index_ != has_bit_index / 32) {
|
|
// Reload.
|
|
int new_index = has_bit_index / 32;
|
|
|
|
printer_->Print(
|
|
"cached_has_bits = _has_bits_[$new_index$];\n",
|
|
"new_index", SimpleItoa(new_index));
|
|
|
|
cached_has_bit_index_ = new_index;
|
|
}
|
|
}
|
|
|
|
mg_->GenerateSerializeOneField(
|
|
printer_, field, to_array_, cached_has_bit_index_);
|
|
} else {
|
|
v_.push_back(field);
|
|
}
|
|
}
|
|
|
|
void Flush() {
|
|
if (!v_.empty()) {
|
|
mg_->GenerateSerializeOneofFields(printer_, v_, to_array_);
|
|
v_.clear();
|
|
}
|
|
}
|
|
|
|
private:
|
|
// If we have multiple fields in v_ then they all must be from the same
|
|
// oneof. Would adding field to v_ break that invariant?
|
|
bool MustFlush(const FieldDescriptor* field) {
|
|
return !v_.empty() &&
|
|
v_[0]->containing_oneof() != field->containing_oneof();
|
|
}
|
|
|
|
MessageGenerator* mg_;
|
|
io::Printer* printer_;
|
|
const bool to_array_;
|
|
const bool eager_;
|
|
std::vector<const FieldDescriptor*> v_;
|
|
|
|
// cached_has_bit_index_ maintains that:
|
|
// cached_has_bits = from._has_bits_[cached_has_bit_index_]
|
|
// for cached_has_bit_index_ >= 0
|
|
int cached_has_bit_index_;
|
|
};
|
|
|
|
std::vector<const FieldDescriptor*> ordered_fields =
|
|
SortFieldsByNumber(descriptor_);
|
|
|
|
std::vector<const Descriptor::ExtensionRange*> sorted_extensions;
|
|
for (int i = 0; i < descriptor_->extension_range_count(); ++i) {
|
|
sorted_extensions.push_back(descriptor_->extension_range(i));
|
|
}
|
|
std::sort(sorted_extensions.begin(), sorted_extensions.end(),
|
|
ExtensionRangeSorter());
|
|
if (num_weak_fields_) {
|
|
printer->Print(
|
|
"::google::protobuf::internal::WeakFieldMap::FieldWriter field_writer("
|
|
"_weak_field_map_);\n");
|
|
}
|
|
|
|
printer->Print(
|
|
"::google::protobuf::uint32 cached_has_bits = 0;\n"
|
|
"(void) cached_has_bits;\n\n");
|
|
|
|
// Merge the fields and the extension ranges, both sorted by field number.
|
|
{
|
|
LazySerializerEmitter e(this, printer, to_array);
|
|
const FieldDescriptor* last_weak_field = NULL;
|
|
int i, j;
|
|
for (i = 0, j = 0;
|
|
i < ordered_fields.size() || j < sorted_extensions.size();) {
|
|
if ((j == sorted_extensions.size()) ||
|
|
(i < descriptor_->field_count() &&
|
|
ordered_fields[i]->number() < sorted_extensions[j]->start)) {
|
|
const FieldDescriptor* field = ordered_fields[i++];
|
|
if (field->options().weak()) {
|
|
last_weak_field = field;
|
|
PrintFieldComment(printer, field);
|
|
} else {
|
|
if (last_weak_field != NULL) {
|
|
e.Emit(last_weak_field);
|
|
last_weak_field = NULL;
|
|
}
|
|
e.Emit(field);
|
|
}
|
|
} else {
|
|
if (last_weak_field != NULL) {
|
|
e.Emit(last_weak_field);
|
|
last_weak_field = NULL;
|
|
}
|
|
e.Flush();
|
|
GenerateSerializeOneExtensionRange(printer,
|
|
sorted_extensions[j++],
|
|
to_array);
|
|
}
|
|
}
|
|
if (last_weak_field != NULL) {
|
|
e.Emit(last_weak_field);
|
|
}
|
|
}
|
|
|
|
std::map<string, string> vars;
|
|
SetUnknkownFieldsVariable(descriptor_, options_, &vars);
|
|
if (UseUnknownFieldSet(descriptor_->file(), options_)) {
|
|
printer->Print(vars,
|
|
"if ($have_unknown_fields$) {\n");
|
|
printer->Indent();
|
|
if (to_array) {
|
|
printer->Print(vars,
|
|
"target = "
|
|
"::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(\n"
|
|
" $unknown_fields$, target);\n");
|
|
} else {
|
|
printer->Print(vars,
|
|
"::google::protobuf::internal::WireFormat::SerializeUnknownFields(\n"
|
|
" $unknown_fields$, output);\n");
|
|
}
|
|
printer->Outdent();
|
|
|
|
printer->Print("}\n");
|
|
} else {
|
|
printer->Print(vars,
|
|
"output->WriteRaw($unknown_fields$.data(),\n"
|
|
" static_cast<int>($unknown_fields$.size()));\n");
|
|
}
|
|
}
|
|
|
|
std::vector<uint32> MessageGenerator::RequiredFieldsBitMask() const {
|
|
const int array_size = HasBitsSize();
|
|
std::vector<uint32> masks(array_size, 0);
|
|
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
const FieldDescriptor* field = descriptor_->field(i);
|
|
if (!field->is_required()) {
|
|
continue;
|
|
}
|
|
|
|
const int has_bit_index = has_bit_indices_[field->index()];
|
|
masks[has_bit_index / 32] |=
|
|
static_cast<uint32>(1) << (has_bit_index % 32);
|
|
}
|
|
return masks;
|
|
}
|
|
|
|
// Create an expression that evaluates to
|
|
// "for all i, (_has_bits_[i] & masks[i]) == masks[i]"
|
|
// masks is allowed to be shorter than _has_bits_, but at least one element of
|
|
// masks must be non-zero.
|
|
static string ConditionalToCheckBitmasks(const std::vector<uint32>& masks) {
|
|
std::vector<string> parts;
|
|
for (int i = 0; i < masks.size(); i++) {
|
|
if (masks[i] == 0) continue;
|
|
string m = StrCat("0x", strings::Hex(masks[i], strings::ZERO_PAD_8));
|
|
// Each xor evaluates to 0 if the expected bits are present.
|
|
parts.push_back(StrCat("((_has_bits_[", i, "] & ", m, ") ^ ", m, ")"));
|
|
}
|
|
GOOGLE_CHECK(!parts.empty());
|
|
// If we have multiple parts, each expected to be 0, then bitwise-or them.
|
|
string result = parts.size() == 1 ? parts[0] :
|
|
StrCat("(", Join(parts, "\n | "), ")");
|
|
return result + " == 0";
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateByteSize(io::Printer* printer) {
|
|
if (descriptor_->options().message_set_wire_format()) {
|
|
// Special-case MessageSet.
|
|
GOOGLE_CHECK(UseUnknownFieldSet(descriptor_->file(), options_));
|
|
std::map<string, string> vars;
|
|
SetUnknkownFieldsVariable(descriptor_, options_, &vars);
|
|
vars["classname"] = classname_;
|
|
vars["full_name"] = descriptor_->full_name();
|
|
printer->Print(vars,
|
|
"size_t $classname$::ByteSizeLong() const {\n"
|
|
"// @@protoc_insertion_point(message_set_byte_size_start:$full_name$)\n"
|
|
" size_t total_size = _extensions_.MessageSetByteSize();\n"
|
|
" if ($have_unknown_fields$) {\n"
|
|
" total_size += ::google::protobuf::internal::WireFormat::\n"
|
|
" ComputeUnknownMessageSetItemsSize($unknown_fields$);\n"
|
|
" }\n"
|
|
" int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);\n"
|
|
" GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();\n"
|
|
" _cached_size_ = cached_size;\n"
|
|
" GOOGLE_SAFE_CONCURRENT_WRITES_END();\n"
|
|
" return total_size;\n"
|
|
"}\n");
|
|
return;
|
|
}
|
|
|
|
if (num_required_fields_ > 1 && HasFieldPresence(descriptor_->file())) {
|
|
// Emit a function (rarely used, we hope) that handles the required fields
|
|
// by checking for each one individually.
|
|
printer->Print(
|
|
"size_t $classname$::RequiredFieldsByteSizeFallback() const {\n"
|
|
"// @@protoc_insertion_point(required_fields_byte_size_fallback_start:"
|
|
"$full_name$)\n",
|
|
"classname", classname_, "full_name", descriptor_->full_name());
|
|
printer->Indent();
|
|
printer->Print("size_t total_size = 0;\n");
|
|
for (int i = 0; i < optimized_order_.size(); i++) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
if (field->is_required()) {
|
|
printer->Print("\n"
|
|
"if (has_$name$()) {\n",
|
|
"name", FieldName(field));
|
|
printer->Indent();
|
|
PrintFieldComment(printer, field);
|
|
field_generators_.get(field).GenerateByteSize(printer);
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
}
|
|
}
|
|
printer->Print("\n"
|
|
"return total_size;\n");
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
}
|
|
|
|
printer->Print(
|
|
"size_t $classname$::ByteSizeLong() const {\n"
|
|
"// @@protoc_insertion_point(message_byte_size_start:$full_name$)\n",
|
|
"classname", classname_, "full_name", descriptor_->full_name());
|
|
printer->Indent();
|
|
printer->Print(
|
|
"size_t total_size = 0;\n"
|
|
"\n");
|
|
|
|
if (descriptor_->extension_range_count() > 0) {
|
|
printer->Print(
|
|
"total_size += _extensions_.ByteSize();\n"
|
|
"\n");
|
|
}
|
|
|
|
std::map<string, string> vars;
|
|
SetUnknkownFieldsVariable(descriptor_, options_, &vars);
|
|
if (UseUnknownFieldSet(descriptor_->file(), options_)) {
|
|
printer->Print(vars,
|
|
"if ($have_unknown_fields$) {\n"
|
|
" total_size +=\n"
|
|
" ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(\n"
|
|
" $unknown_fields$);\n"
|
|
"}\n");
|
|
} else {
|
|
printer->Print(vars,
|
|
"total_size += $unknown_fields$.size();\n"
|
|
"\n");
|
|
}
|
|
|
|
// Handle required fields (if any). We expect all of them to be
|
|
// present, so emit one conditional that checks for that. If they are all
|
|
// present then the fast path executes; otherwise the slow path executes.
|
|
if (num_required_fields_ > 1 && HasFieldPresence(descriptor_->file())) {
|
|
// The fast path works if all required fields are present.
|
|
const std::vector<uint32> masks_for_has_bits = RequiredFieldsBitMask();
|
|
printer->Print((string("if (") +
|
|
ConditionalToCheckBitmasks(masks_for_has_bits) +
|
|
") { // All required fields are present.\n").c_str());
|
|
printer->Indent();
|
|
// Oneof fields cannot be required, so optimized_order_ contains all of the
|
|
// fields that we need to potentially emit.
|
|
for (int i = 0; i < optimized_order_.size(); i++) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
if (!field->is_required()) continue;
|
|
PrintFieldComment(printer, field);
|
|
field_generators_.get(field).GenerateByteSize(printer);
|
|
printer->Print("\n");
|
|
}
|
|
printer->Outdent();
|
|
printer->Print("} else {\n" // the slow path
|
|
" total_size += RequiredFieldsByteSizeFallback();\n"
|
|
"}\n");
|
|
} else {
|
|
// num_required_fields_ <= 1: no need to be tricky
|
|
for (int i = 0; i < optimized_order_.size(); i++) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
if (!field->is_required()) continue;
|
|
PrintFieldComment(printer, field);
|
|
printer->Print("if (has_$name$()) {\n",
|
|
"name", FieldName(field));
|
|
printer->Indent();
|
|
field_generators_.get(field).GenerateByteSize(printer);
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
}
|
|
}
|
|
|
|
int last_i = -1;
|
|
for (int i = 0; i < optimized_order_.size(); ) {
|
|
// Detect infinite loops.
|
|
GOOGLE_CHECK_NE(i, last_i);
|
|
last_i = i;
|
|
|
|
// Skip required fields.
|
|
for (; i < optimized_order_.size() &&
|
|
optimized_order_[i]->is_required(); i++) {
|
|
}
|
|
|
|
// Handle repeated fields.
|
|
for (; i < optimized_order_.size(); i++) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
if (!field->is_repeated()) {
|
|
break;
|
|
}
|
|
|
|
PrintFieldComment(printer, field);
|
|
const FieldGenerator& generator = field_generators_.get(field);
|
|
generator.GenerateByteSize(printer);
|
|
printer->Print("\n");
|
|
}
|
|
|
|
// Handle optional (non-repeated/oneof) fields.
|
|
//
|
|
// These are handled in chunks of 8. The first chunk is
|
|
// the non-requireds-non-repeateds-non-unions-non-extensions in
|
|
// descriptor_->field(0), descriptor_->field(1), ... descriptor_->field(7),
|
|
// and the second chunk is the same for
|
|
// descriptor_->field(8), descriptor_->field(9), ...
|
|
// descriptor_->field(15),
|
|
// etc.
|
|
int last_chunk = -1;
|
|
int last_chunk_start = -1;
|
|
int last_chunk_end = -1;
|
|
uint32 last_chunk_mask = 0;
|
|
for (; i < optimized_order_.size(); i++) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
if (field->is_repeated() || field->is_required()) {
|
|
break;
|
|
}
|
|
|
|
// "index" defines where in the _has_bits_ the field appears.
|
|
// "i" is our loop counter within optimized_order_.
|
|
int index = HasFieldPresence(descriptor_->file()) ?
|
|
has_bit_indices_[field->index()] : 0;
|
|
int chunk = index / 8;
|
|
|
|
if (last_chunk == -1) {
|
|
last_chunk = chunk;
|
|
last_chunk_start = i;
|
|
} else if (chunk != last_chunk) {
|
|
// Emit the fields for this chunk so far.
|
|
break;
|
|
}
|
|
|
|
last_chunk_end = i;
|
|
last_chunk_mask |= static_cast<uint32>(1) << (index % 32);
|
|
}
|
|
|
|
if (last_chunk != -1) {
|
|
GOOGLE_DCHECK_NE(-1, last_chunk_start);
|
|
GOOGLE_DCHECK_NE(-1, last_chunk_end);
|
|
GOOGLE_DCHECK_NE(0, last_chunk_mask);
|
|
|
|
const int count = popcnt(last_chunk_mask);
|
|
const bool have_outer_if = HasFieldPresence(descriptor_->file()) &&
|
|
(last_chunk_start != last_chunk_end);
|
|
|
|
if (have_outer_if) {
|
|
// Check (up to) 8 has_bits at a time if we have more than one field in
|
|
// this chunk. Due to field layout ordering, we may check
|
|
// _has_bits_[last_chunk * 8 / 32] multiple times.
|
|
GOOGLE_DCHECK_LE(2, count);
|
|
GOOGLE_DCHECK_GE(8, count);
|
|
|
|
printer->Print(
|
|
"if (_has_bits_[$index$ / 32] & $mask$u) {\n",
|
|
"index", SimpleItoa(last_chunk * 8),
|
|
"mask", SimpleItoa(last_chunk_mask));
|
|
printer->Indent();
|
|
}
|
|
|
|
// Go back and emit checks for each of the fields we processed.
|
|
for (int j = last_chunk_start; j <= last_chunk_end; j++) {
|
|
const FieldDescriptor* field = optimized_order_[j];
|
|
const FieldGenerator& generator = field_generators_.get(field);
|
|
|
|
PrintFieldComment(printer, field);
|
|
|
|
bool have_enclosing_if = false;
|
|
if (HasFieldPresence(descriptor_->file())) {
|
|
printer->Print(
|
|
"if (has_$name$()) {\n",
|
|
"name", FieldName(field));
|
|
printer->Indent();
|
|
have_enclosing_if = true;
|
|
} else {
|
|
// Without field presence: field is serialized only if it has a
|
|
// non-default value.
|
|
have_enclosing_if = EmitFieldNonDefaultCondition(
|
|
printer, "this->", field);
|
|
}
|
|
|
|
generator.GenerateByteSize(printer);
|
|
|
|
if (have_enclosing_if) {
|
|
printer->Outdent();
|
|
printer->Print(
|
|
"}\n"
|
|
"\n");
|
|
}
|
|
}
|
|
|
|
if (have_outer_if) {
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Fields inside a oneof don't use _has_bits_ so we count them in a separate
|
|
// pass.
|
|
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
|
|
printer->Print(
|
|
"switch ($oneofname$_case()) {\n",
|
|
"oneofname", descriptor_->oneof_decl(i)->name());
|
|
printer->Indent();
|
|
for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
|
|
const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
|
|
PrintFieldComment(printer, field);
|
|
printer->Print(
|
|
"case k$field_name$: {\n",
|
|
"field_name", UnderscoresToCamelCase(field->name(), true));
|
|
printer->Indent();
|
|
field_generators_.get(field).GenerateByteSize(printer);
|
|
printer->Print(
|
|
"break;\n");
|
|
printer->Outdent();
|
|
printer->Print(
|
|
"}\n");
|
|
}
|
|
printer->Print(
|
|
"case $cap_oneof_name$_NOT_SET: {\n"
|
|
" break;\n"
|
|
"}\n",
|
|
"cap_oneof_name",
|
|
ToUpper(descriptor_->oneof_decl(i)->name()));
|
|
printer->Outdent();
|
|
printer->Print(
|
|
"}\n");
|
|
}
|
|
|
|
if (num_weak_fields_) {
|
|
// TagSize + MessageSize
|
|
printer->Print("total_size += _weak_field_map_.ByteSizeLong();\n");
|
|
}
|
|
|
|
// We update _cached_size_ even though this is a const method. In theory,
|
|
// this is not thread-compatible, because concurrent writes have undefined
|
|
// results. In practice, since any concurrent writes will be writing the
|
|
// exact same value, it works on all common processors. In a future version
|
|
// of C++, _cached_size_ should be made into an atomic<int>.
|
|
printer->Print(
|
|
"int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);\n"
|
|
"GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();\n"
|
|
"_cached_size_ = cached_size;\n"
|
|
"GOOGLE_SAFE_CONCURRENT_WRITES_END();\n"
|
|
"return total_size;\n");
|
|
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
}
|
|
|
|
void MessageGenerator::
|
|
GenerateIsInitialized(io::Printer* printer) {
|
|
printer->Print(
|
|
"bool $classname$::IsInitialized() const {\n",
|
|
"classname", classname_);
|
|
printer->Indent();
|
|
|
|
if (descriptor_->extension_range_count() > 0) {
|
|
printer->Print(
|
|
"if (!_extensions_.IsInitialized()) {\n"
|
|
" return false;\n"
|
|
"}\n\n");
|
|
}
|
|
|
|
if (HasFieldPresence(descriptor_->file())) {
|
|
// Check that all required fields in this message are set. We can do this
|
|
// most efficiently by checking 32 "has bits" at a time.
|
|
const std::vector<uint32> masks = RequiredFieldsBitMask();
|
|
|
|
for (int i = 0; i < masks.size(); i++) {
|
|
uint32 mask = masks[i];
|
|
if (mask == 0) {
|
|
continue;
|
|
}
|
|
|
|
// TODO(ckennelly): Consider doing something similar to ByteSizeLong(),
|
|
// where we check all of the required fields in a single branch (assuming
|
|
// that we aren't going to benefit from early termination).
|
|
printer->Print(
|
|
"if ((_has_bits_[$i$] & 0x$mask$) != 0x$mask$) return false;\n",
|
|
"i", SimpleItoa(i),
|
|
"mask", StrCat(strings::Hex(mask, strings::ZERO_PAD_8)));
|
|
}
|
|
}
|
|
|
|
// Now check that all non-oneof embedded messages are initialized.
|
|
for (int i = 0; i < optimized_order_.size(); i++) {
|
|
const FieldDescriptor* field = optimized_order_[i];
|
|
// TODO(ckennelly): Push this down into a generator?
|
|
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
|
|
!ShouldIgnoreRequiredFieldCheck(field, options_) &&
|
|
scc_analyzer_->HasRequiredFields(field->message_type())) {
|
|
if (field->is_repeated()) {
|
|
printer->Print(
|
|
"if (!::google::protobuf::internal::AllAreInitialized(this->$name$()))"
|
|
" return false;\n",
|
|
"name", FieldName(field));
|
|
} else if (field->options().weak()) {
|
|
continue;
|
|
} else {
|
|
GOOGLE_CHECK(!field->containing_oneof());
|
|
printer->Print(
|
|
"if (has_$name$()) {\n"
|
|
" if (!this->$name$_->IsInitialized()) return false;\n"
|
|
"}\n",
|
|
"name", FieldName(field));
|
|
}
|
|
}
|
|
}
|
|
if (num_weak_fields_) {
|
|
// For Weak fields.
|
|
printer->Print("if (!_weak_field_map_.IsInitialized()) return false;\n");
|
|
}
|
|
// Go through the oneof fields, emitting a switch if any might have required
|
|
// fields.
|
|
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
|
|
const OneofDescriptor* oneof = descriptor_->oneof_decl(i);
|
|
|
|
bool has_required_fields = false;
|
|
for (int j = 0; j < oneof->field_count(); j++) {
|
|
const FieldDescriptor* field = oneof->field(j);
|
|
|
|
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
|
|
!ShouldIgnoreRequiredFieldCheck(field, options_) &&
|
|
scc_analyzer_->HasRequiredFields(field->message_type())) {
|
|
has_required_fields = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!has_required_fields) {
|
|
continue;
|
|
}
|
|
|
|
printer->Print(
|
|
"switch ($oneofname$_case()) {\n",
|
|
"oneofname", oneof->name());
|
|
printer->Indent();
|
|
for (int j = 0; j < oneof->field_count(); j++) {
|
|
const FieldDescriptor* field = oneof->field(j);
|
|
printer->Print(
|
|
"case k$field_name$: {\n",
|
|
"field_name", UnderscoresToCamelCase(field->name(), true));
|
|
printer->Indent();
|
|
|
|
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
|
|
!ShouldIgnoreRequiredFieldCheck(field, options_) &&
|
|
scc_analyzer_->HasRequiredFields(field->message_type())) {
|
|
GOOGLE_CHECK(!(field->options().weak() || !field->containing_oneof()));
|
|
if (field->options().weak()) {
|
|
// Just skip.
|
|
} else {
|
|
printer->Print(
|
|
"if (has_$name$()) {\n"
|
|
" if (!this->$name$().IsInitialized()) return false;\n"
|
|
"}\n",
|
|
"name", FieldName(field));
|
|
}
|
|
}
|
|
|
|
printer->Print(
|
|
"break;\n");
|
|
printer->Outdent();
|
|
printer->Print(
|
|
"}\n");
|
|
}
|
|
printer->Print(
|
|
"case $cap_oneof_name$_NOT_SET: {\n"
|
|
" break;\n"
|
|
"}\n",
|
|
"cap_oneof_name",
|
|
ToUpper(oneof->name()));
|
|
printer->Outdent();
|
|
printer->Print(
|
|
"}\n");
|
|
}
|
|
|
|
printer->Outdent();
|
|
printer->Print(
|
|
" return true;\n"
|
|
"}\n");
|
|
}
|
|
|
|
} // namespace cpp
|
|
} // namespace compiler
|
|
} // namespace protobuf
|
|
} // namespace google
|