# Conflicts: # java/kotlin/src/test/kotlin/com/google/protobuf/Proto2Test.kt # src/google/protobuf/repeated_field_unittest.ccpull/8617/head
Deanna Garcia
4 years ago
commit
f66dea481d
118 changed files with 6029 additions and 2835 deletions
@ -0,0 +1,59 @@ |
||||
// 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: qrczak@google.com (Marcin Kowalczyk)
|
||||
|
||||
#include <google/protobuf/python/python_protobuf.h> |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace python { |
||||
|
||||
static const Message* GetCProtoInsidePyProtoStub(PyObject* msg) { return NULL; } |
||||
static Message* MutableCProtoInsidePyProtoStub(PyObject* msg) { return NULL; } |
||||
|
||||
// This is initialized with a default, stub implementation.
|
||||
// If python-google.protobuf.cc is loaded, the function pointer is overridden
|
||||
// with a full implementation.
|
||||
const Message* (*GetCProtoInsidePyProtoPtr)(PyObject* msg) = |
||||
GetCProtoInsidePyProtoStub; |
||||
Message* (*MutableCProtoInsidePyProtoPtr)(PyObject* msg) = |
||||
MutableCProtoInsidePyProtoStub; |
||||
|
||||
const Message* GetCProtoInsidePyProto(PyObject* msg) { |
||||
return GetCProtoInsidePyProtoPtr(msg); |
||||
} |
||||
Message* MutableCProtoInsidePyProto(PyObject* msg) { |
||||
return MutableCProtoInsidePyProtoPtr(msg); |
||||
} |
||||
|
||||
} // namespace python
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -0,0 +1,57 @@ |
||||
// 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: qrczak@google.com (Marcin Kowalczyk)
|
||||
//
|
||||
// This module exposes the C proto inside the given Python proto, in
|
||||
// case the Python proto is implemented with a C proto.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_PYTHON_PYTHON_PROTOBUF_H__ |
||||
#define GOOGLE_PROTOBUF_PYTHON_PYTHON_PROTOBUF_H__ |
||||
|
||||
#include <Python.h> |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
|
||||
class Message; |
||||
|
||||
namespace python { |
||||
|
||||
// Return the pointer to the C proto inside the given Python proto,
|
||||
// or NULL when this is not a Python proto implemented with a C proto.
|
||||
const Message* GetCProtoInsidePyProto(PyObject* msg); |
||||
Message* MutableCProtoInsidePyProto(PyObject* msg); |
||||
|
||||
} // namespace python
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_PYTHON_PYTHON_PROTOBUF_H__
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,123 @@ |
||||
// 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.
|
||||
|
||||
// This file contains declarations needed in generated headers for messages
|
||||
// that use tail-call table parsing. Everything in this file is for internal
|
||||
// use only.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_DECL_H__ |
||||
#define GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_DECL_H__ |
||||
|
||||
#include <cstdint> |
||||
#include <type_traits> |
||||
|
||||
#include <google/protobuf/parse_context.h> |
||||
#include <google/protobuf/message_lite.h> |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
// Additional information about this field:
|
||||
struct TcFieldData { |
||||
constexpr TcFieldData() : data(0) {} |
||||
constexpr TcFieldData(uint16_t coded_tag, uint8_t hasbit_idx, uint16_t offset) |
||||
: data(static_cast<uint64_t>(offset) << 48 | |
||||
static_cast<uint64_t>(hasbit_idx) << 16 | coded_tag) {} |
||||
|
||||
uint16_t coded_tag() const { return static_cast<uint16_t>(data); } |
||||
uint8_t hasbit_idx() const { return static_cast<uint8_t>(data >> 16); } |
||||
uint16_t offset() const { return static_cast<uint16_t>(data >> 48); } |
||||
|
||||
uint64_t data; |
||||
}; |
||||
|
||||
struct TailCallParseTableBase; |
||||
|
||||
// TailCallParseFunc is the function pointer type used in the tailcall table.
|
||||
typedef const char* (*TailCallParseFunc)(MessageLite* msg, const char* ptr, |
||||
ParseContext* ctx, |
||||
const TailCallParseTableBase* table, |
||||
uint64_t hasbits, TcFieldData data); |
||||
|
||||
// Base class for message-level table with info for the tail-call parser.
|
||||
struct TailCallParseTableBase { |
||||
// Common attributes for message layout:
|
||||
uint16_t has_bits_offset; |
||||
uint16_t extension_offset; |
||||
uint32_t extension_range_low; |
||||
uint32_t extension_range_high; |
||||
uint32_t has_bits_required_mask; |
||||
const MessageLite* default_instance; |
||||
|
||||
// Handler for fields which are not handled by table dispatch.
|
||||
TailCallParseFunc fallback; |
||||
|
||||
// Table entry for fast-path tailcall dispatch handling.
|
||||
struct FieldEntry { |
||||
// Target function for dispatch:
|
||||
TailCallParseFunc target; |
||||
// Field data used during parse:
|
||||
TcFieldData bits; |
||||
}; |
||||
// There is always at least one table entry.
|
||||
const FieldEntry* table() const { |
||||
return reinterpret_cast<const FieldEntry*>(this + 1); |
||||
} |
||||
}; |
||||
|
||||
static_assert(sizeof(TailCallParseTableBase::FieldEntry) <= 16, |
||||
"Field entry is too big."); |
||||
|
||||
template <size_t kTableSizeLog2> |
||||
struct TailCallParseTable { |
||||
TailCallParseTableBase header; |
||||
|
||||
// Entries for each field.
|
||||
//
|
||||
// Fields are indexed by the lowest bits of their field number. The field
|
||||
// number is masked to fit inside the table. Note that the parsing logic
|
||||
// generally calls `TailCallParseTableBase::table()` instead of accessing
|
||||
// this field directly.
|
||||
TailCallParseTableBase::FieldEntry entries[(1 << kTableSizeLog2)]; |
||||
}; |
||||
|
||||
static_assert(std::is_standard_layout<TailCallParseTable<1>>::value, |
||||
"TailCallParseTable must be standard layout."); |
||||
|
||||
static_assert(offsetof(TailCallParseTable<1>, entries) == |
||||
sizeof(TailCallParseTableBase), |
||||
"Table entries must be laid out after TailCallParseTableBase."); |
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_DECL_H__
|
||||
@ -0,0 +1,53 @@ |
||||
// 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.
|
||||
|
||||
#include <cstdint> |
||||
|
||||
#include <google/protobuf/parse_context.h> |
||||
#include <google/protobuf/extension_set.h> |
||||
#include <google/protobuf/generated_message_tctable_impl.h> |
||||
#include <google/protobuf/message.h> |
||||
#include <google/protobuf/unknown_field_set.h> |
||||
|
||||
// clang-format off
|
||||
#include <google/protobuf/port_def.inc> |
||||
// clang-format on
|
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
const char* TcParserBase::GenericFallback(PROTOBUF_TC_PARAM_DECL) { |
||||
return GenericFallbackImpl<Message, UnknownFieldSet>(PROTOBUF_TC_PARAM_PASS); |
||||
} |
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -0,0 +1,245 @@ |
||||
// 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.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_IMPL_H__ |
||||
#define GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_IMPL_H__ |
||||
|
||||
#include <cstdint> |
||||
#include <type_traits> |
||||
|
||||
#include <google/protobuf/parse_context.h> |
||||
#include <google/protobuf/extension_set.h> |
||||
#include <google/protobuf/generated_message_tctable_decl.h> |
||||
#include <google/protobuf/message_lite.h> |
||||
#include <google/protobuf/metadata_lite.h> |
||||
#include <google/protobuf/port.h> |
||||
#include <google/protobuf/wire_format_lite.h> |
||||
|
||||
// Must come last:
|
||||
#include <google/protobuf/port_def.inc> |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
|
||||
class Message; |
||||
class UnknownFieldSet; |
||||
|
||||
namespace internal { |
||||
|
||||
// PROTOBUF_TC_PARAM_DECL are the parameters for tailcall functions.
|
||||
//
|
||||
// Note that this is performance sensitive: changing the parameters will change
|
||||
// the registers used by the ABI calling convention, which subsequently affects
|
||||
// register selection logic inside the function.
|
||||
#define PROTOBUF_TC_PARAM_DECL \ |
||||
::google::protobuf::MessageLite *msg, const char *ptr, \
|
||||
::google::protobuf::internal::ParseContext *ctx, \
|
||||
const ::google::protobuf::internal::TailCallParseTableBase *table, \
|
||||
uint64_t hasbits, ::google::protobuf::internal::TcFieldData data |
||||
|
||||
// PROTOBUF_TC_PARAM_PASS passes values to match PROTOBUF_TC_PARAM_DECL.
|
||||
#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, table, hasbits, data |
||||
|
||||
class TcParserBase { |
||||
public: |
||||
static const char* GenericFallback(PROTOBUF_TC_PARAM_DECL); |
||||
static const char* GenericFallbackLite(PROTOBUF_TC_PARAM_DECL); |
||||
|
||||
template <typename FieldType, typename TagType> |
||||
PROTOBUF_NOINLINE static const char* SingularParseMessage( |
||||
PROTOBUF_TC_PARAM_DECL) { |
||||
if (PROTOBUF_PREDICT_FALSE(static_cast<TagType>(data.coded_tag()) != 0)) { |
||||
return table->fallback(PROTOBUF_TC_PARAM_PASS); |
||||
} |
||||
ptr += sizeof(TagType); |
||||
hasbits |= (1 << data.hasbit_idx()); |
||||
auto& field = RefAt<FieldType*>(msg, data.offset()); |
||||
if (field == nullptr) { |
||||
auto arena = ctx->data().arena; |
||||
if (Arena::is_arena_constructable<FieldType>::value) { |
||||
field = Arena::CreateMessage<FieldType>(arena); |
||||
} else { |
||||
field = Arena::Create<FieldType>(arena); |
||||
} |
||||
} |
||||
SyncHasbits(msg, hasbits, table); |
||||
return ctx->ParseMessage(field, ptr); |
||||
} |
||||
|
||||
template <typename FieldType, typename TagType> |
||||
PROTOBUF_NOINLINE static const char* RepeatedParseMessage( |
||||
PROTOBUF_TC_PARAM_DECL) { |
||||
if (PROTOBUF_PREDICT_FALSE(static_cast<TagType>(data.coded_tag()) != 0)) { |
||||
return table->fallback(PROTOBUF_TC_PARAM_PASS); |
||||
} |
||||
ptr += sizeof(TagType); |
||||
auto& field = RefAt<RepeatedPtrField<FieldType>>(msg, data.offset()); |
||||
SyncHasbits(msg, hasbits, table); |
||||
ptr = ctx->ParseMessage(field.Add(), ptr); |
||||
return ptr; |
||||
} |
||||
|
||||
template <typename LayoutType, typename TagType> |
||||
static const char* RepeatedFixed(PROTOBUF_TC_PARAM_DECL); |
||||
template <typename LayoutType, typename TagType> |
||||
static const char* PackedFixed(PROTOBUF_TC_PARAM_DECL); |
||||
|
||||
protected: |
||||
template <typename T> |
||||
static T& RefAt(void* x, size_t offset) { |
||||
T* target = reinterpret_cast<T*>(static_cast<char*>(x) + offset); |
||||
GOOGLE_DCHECK_EQ(0, reinterpret_cast<uintptr_t>(target) % alignof(T)); |
||||
return *target; |
||||
} |
||||
|
||||
static inline PROTOBUF_ALWAYS_INLINE void SyncHasbits( |
||||
MessageLite* msg, uint64_t hasbits, const TailCallParseTableBase* table) { |
||||
const uint32_t has_bits_offset = table->has_bits_offset; |
||||
if (has_bits_offset) { |
||||
// Only the first 32 has-bits are updated. Nothing above those is stored,
|
||||
// but e.g. messages without has-bits update the upper bits.
|
||||
RefAt<uint32_t>(msg, has_bits_offset) = static_cast<uint32_t>(hasbits); |
||||
} |
||||
} |
||||
|
||||
static inline PROTOBUF_ALWAYS_INLINE const char* Return( |
||||
PROTOBUF_TC_PARAM_DECL) { |
||||
SyncHasbits(msg, hasbits, table); |
||||
return ptr; |
||||
} |
||||
|
||||
static inline PROTOBUF_ALWAYS_INLINE const char* Error( |
||||
PROTOBUF_TC_PARAM_DECL) { |
||||
SyncHasbits(msg, hasbits, table); |
||||
return nullptr; |
||||
} |
||||
|
||||
class ScopedArenaSwap final { |
||||
public: |
||||
ScopedArenaSwap(MessageLite* msg, ParseContext* ctx) |
||||
: ctx_(ctx), saved_(ctx->data().arena) { |
||||
ctx_->data().arena = msg->GetArenaForAllocation(); |
||||
} |
||||
ScopedArenaSwap(const ScopedArenaSwap&) = delete; |
||||
~ScopedArenaSwap() { ctx_->data().arena = saved_; } |
||||
|
||||
private: |
||||
ParseContext* const ctx_; |
||||
Arena* const saved_; |
||||
}; |
||||
|
||||
template <class MessageBaseT, class UnknownFieldsT> |
||||
static const char* GenericFallbackImpl(PROTOBUF_TC_PARAM_DECL) { |
||||
#define CHK_(x) \ |
||||
if (PROTOBUF_PREDICT_FALSE(!(x))) return nullptr /* NOLINT */ |
||||
|
||||
SyncHasbits(msg, hasbits, table); |
||||
uint32_t tag; |
||||
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); |
||||
CHK_(ptr); |
||||
if ((tag & 7) == WireFormatLite::WIRETYPE_END_GROUP || tag == 0) { |
||||
ctx->SetLastTag(tag); |
||||
return ptr; |
||||
} |
||||
uint32_t num = tag >> 3; |
||||
if (table->extension_range_low <= num && |
||||
num <= table->extension_range_high) { |
||||
return RefAt<ExtensionSet>(msg, table->extension_offset) |
||||
.ParseField(tag, ptr, |
||||
static_cast<const MessageBaseT*>(table->default_instance), |
||||
&msg->_internal_metadata_, ctx); |
||||
} |
||||
return UnknownFieldParse( |
||||
tag, msg->_internal_metadata_.mutable_unknown_fields<UnknownFieldsT>(), |
||||
ptr, ctx); |
||||
#undef CHK_ |
||||
} |
||||
}; |
||||
|
||||
// TcParser implements most of the parsing logic for tailcall tables.
|
||||
//
|
||||
// This is templated on lg2(table size), since dispatching depends upon the size
|
||||
// of the table. The template parameter avoids runtime overhead for computing
|
||||
// the table entry index.
|
||||
template <uint32_t kPowerOf2> |
||||
struct TcParser final : TcParserBase { |
||||
// Dispatch to the designated parse function
|
||||
inline PROTOBUF_ALWAYS_INLINE static const char* TagDispatch( |
||||
PROTOBUF_TC_PARAM_DECL) { |
||||
const auto coded_tag = UnalignedLoad<uint16_t>(ptr); |
||||
constexpr size_t kIdxMask = ((1 << (kPowerOf2)) - 1); |
||||
const size_t idx = (coded_tag >> 3) & kIdxMask; |
||||
data = table->table()[idx].bits; |
||||
data.data ^= coded_tag; |
||||
PROTOBUF_MUSTTAIL return table->table()[idx].target(PROTOBUF_TC_PARAM_PASS); |
||||
} |
||||
|
||||
// We can only safely call from field to next field if the call is optimized
|
||||
// to a proper tail call. Otherwise we blow through stack. Clang and gcc
|
||||
// reliably do this optimization in opt mode, but do not perform this in debug
|
||||
// mode. Luckily the structure of the algorithm is such that it's always
|
||||
// possible to just return and use the enclosing parse loop as a trampoline.
|
||||
static const char* TailCall(PROTOBUF_TC_PARAM_DECL) { |
||||
constexpr bool always_return = !PROTOBUF_TAILCALL; |
||||
if (always_return || !ctx->DataAvailable(ptr)) { |
||||
PROTOBUF_MUSTTAIL return Return(PROTOBUF_TC_PARAM_PASS); |
||||
} |
||||
PROTOBUF_MUSTTAIL return TagDispatch(PROTOBUF_TC_PARAM_PASS); |
||||
} |
||||
|
||||
static const char* ParseLoop(MessageLite* msg, const char* ptr, |
||||
ParseContext* ctx, |
||||
const TailCallParseTableBase* table) { |
||||
ScopedArenaSwap saved(msg, ctx); |
||||
const uint32_t has_bits_offset = table->has_bits_offset; |
||||
while (!ctx->Done(&ptr)) { |
||||
uint64_t hasbits = 0; |
||||
if (has_bits_offset) hasbits = RefAt<uint32_t>(msg, has_bits_offset); |
||||
ptr = TagDispatch(msg, ptr, ctx, table, hasbits, {}); |
||||
if (ptr == nullptr) break; |
||||
if (ctx->LastTag() != 1) break; // Ended on terminating tag
|
||||
} |
||||
return ptr; |
||||
} |
||||
|
||||
template <typename LayoutType, typename TagType> |
||||
static const char* SingularFixed(PROTOBUF_TC_PARAM_DECL); |
||||
}; |
||||
|
||||
// Declare helper functions:
|
||||
#include <google/protobuf/generated_message_tctable_impl.inc> |
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#include <google/protobuf/port_undef.inc> |
||||
|
||||
#endif // GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_IMPL_H__
|
||||
@ -0,0 +1,91 @@ |
||||
// 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. |
||||
|
||||
// clang-format off |
||||
#ifdef PROTOBUF_TCT_SOURCE |
||||
template const char* TcParser<1>::SingularFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<2>::SingularFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<3>::SingularFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<4>::SingularFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<5>::SingularFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParserBase::RepeatedFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParserBase::PackedFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<1>::SingularFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<2>::SingularFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<3>::SingularFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<4>::SingularFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<5>::SingularFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParserBase::RepeatedFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParserBase::PackedFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<1>::SingularFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<2>::SingularFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<3>::SingularFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<4>::SingularFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<5>::SingularFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParserBase::RepeatedFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParserBase::PackedFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<1>::SingularFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<2>::SingularFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<3>::SingularFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<4>::SingularFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParser<5>::SingularFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParserBase::RepeatedFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
template const char* TcParserBase::PackedFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
#else |
||||
extern template const char* TcParser<1>::SingularFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<2>::SingularFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<3>::SingularFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<4>::SingularFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<5>::SingularFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParserBase::RepeatedFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParserBase::PackedFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<1>::SingularFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<2>::SingularFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<3>::SingularFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<4>::SingularFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<5>::SingularFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParserBase::RepeatedFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParserBase::PackedFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<1>::SingularFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<2>::SingularFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<3>::SingularFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<4>::SingularFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<5>::SingularFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParserBase::RepeatedFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParserBase::PackedFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<1>::SingularFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<2>::SingularFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<3>::SingularFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<4>::SingularFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParser<5>::SingularFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParserBase::RepeatedFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
extern template const char* TcParserBase::PackedFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL); |
||||
#endif |
||||
// clang-format on |
||||
@ -0,0 +1,148 @@ |
||||
// 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.
|
||||
|
||||
#include <cstdint> |
||||
|
||||
#include <google/protobuf/parse_context.h> |
||||
#include <google/protobuf/extension_set.h> |
||||
#include <google/protobuf/generated_message_tctable_decl.h> |
||||
#include <google/protobuf/generated_message_tctable_impl.h> |
||||
#include <google/protobuf/message_lite.h> |
||||
#include <google/protobuf/wire_format_lite.h> |
||||
|
||||
// clang-format off
|
||||
#include <google/protobuf/port_def.inc> |
||||
// clang-format on
|
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
const char* TcParserBase::GenericFallbackLite(PROTOBUF_TC_PARAM_DECL) { |
||||
return GenericFallbackImpl<MessageLite, std::string>(PROTOBUF_TC_PARAM_PASS); |
||||
} |
||||
|
||||
namespace { |
||||
|
||||
// Offset returns the address `offset` bytes after `base`.
|
||||
inline void* Offset(void* base, uint32_t offset) { |
||||
return static_cast<uint8*>(base) + offset; |
||||
} |
||||
|
||||
// InvertPacked changes tag bits from the given wire type to length
|
||||
// delimited. This is the difference expected between packed and non-packed
|
||||
// repeated fields.
|
||||
template <WireFormatLite::WireType Wt> |
||||
inline PROTOBUF_ALWAYS_INLINE void InvertPacked(TcFieldData& data) { |
||||
data.data ^= Wt ^ WireFormatLite::WIRETYPE_LENGTH_DELIMITED; |
||||
} |
||||
|
||||
} // namespace
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// Fixed fields
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
template <uint32_t kPowerOf2> |
||||
template <typename LayoutType, typename TagType> |
||||
const char* TcParser<kPowerOf2>::SingularFixed(PROTOBUF_TC_PARAM_DECL) { |
||||
if (PROTOBUF_PREDICT_FALSE(static_cast<TagType>(data.coded_tag()) != 0)) { |
||||
return table->fallback(PROTOBUF_TC_PARAM_PASS); |
||||
} |
||||
ptr += sizeof(TagType); // Consume tag
|
||||
hasbits |= (1 << data.hasbit_idx()); |
||||
std::memcpy(Offset(msg, data.offset()), ptr, sizeof(LayoutType)); |
||||
ptr += sizeof(LayoutType); |
||||
// TailCall syncs any pending hasbits:
|
||||
PROTOBUF_MUSTTAIL return TailCall(PROTOBUF_TC_PARAM_PASS); |
||||
} |
||||
|
||||
template <typename LayoutType, typename TagType> |
||||
const char* TcParserBase::RepeatedFixed(PROTOBUF_TC_PARAM_DECL) { |
||||
if (PROTOBUF_PREDICT_FALSE(static_cast<TagType>(data.coded_tag()) != 0)) { |
||||
// Check if the field can be parsed as packed repeated:
|
||||
constexpr WireFormatLite::WireType fallback_wt = |
||||
sizeof(LayoutType) == 4 ? WireFormatLite::WIRETYPE_FIXED32 |
||||
: WireFormatLite::WIRETYPE_FIXED64; |
||||
InvertPacked<fallback_wt>(data); |
||||
if (static_cast<TagType>(data.coded_tag()) == 0) { |
||||
return PackedFixed<LayoutType, TagType>(PROTOBUF_TC_PARAM_PASS); |
||||
} else { |
||||
return table->fallback(PROTOBUF_TC_PARAM_PASS); |
||||
} |
||||
} |
||||
auto& field = RefAt<RepeatedField<LayoutType>>(msg, data.offset()); |
||||
int idx = field.size(); |
||||
auto elem = field.Add(); |
||||
int space = field.Capacity() - idx; |
||||
idx = 0; |
||||
auto expected_tag = UnalignedLoad<TagType>(ptr); |
||||
do { |
||||
ptr += sizeof(TagType); |
||||
std::memcpy(elem + (idx++), ptr, sizeof(LayoutType)); |
||||
ptr += sizeof(LayoutType); |
||||
if (idx >= space) break; |
||||
if (!ctx->DataAvailable(ptr)) break; |
||||
} while (UnalignedLoad<TagType>(ptr) == expected_tag); |
||||
field.AddNAlreadyReserved(idx - 1); |
||||
return Return(PROTOBUF_TC_PARAM_PASS); |
||||
} |
||||
|
||||
template <typename LayoutType, typename TagType> |
||||
const char* TcParserBase::PackedFixed(PROTOBUF_TC_PARAM_DECL) { |
||||
if (PROTOBUF_PREDICT_FALSE(static_cast<TagType>(data.coded_tag()) != 0)) { |
||||
// Try parsing as non-packed repeated:
|
||||
constexpr WireFormatLite::WireType fallback_wt = |
||||
sizeof(LayoutType) == 4 ? WireFormatLite::WIRETYPE_FIXED32 |
||||
: WireFormatLite::WIRETYPE_FIXED64; |
||||
InvertPacked<fallback_wt>(data); |
||||
if (static_cast<TagType>(data.coded_tag()) == 0) { |
||||
return RepeatedFixed<LayoutType, TagType>(PROTOBUF_TC_PARAM_PASS); |
||||
} else { |
||||
return table->fallback(PROTOBUF_TC_PARAM_PASS); |
||||
} |
||||
} |
||||
ptr += sizeof(TagType); |
||||
// Since ctx->ReadPackedFixed does not use TailCall<> or Return<>, sync any
|
||||
// pending hasbits now:
|
||||
SyncHasbits(msg, hasbits, table); |
||||
auto& field = RefAt<RepeatedField<LayoutType>>(msg, data.offset()); |
||||
int size = ReadSize(&ptr); |
||||
// TODO(dlj): add a tailcalling variant of ReadPackedFixed.
|
||||
return ctx->ReadPackedFixed(ptr, size, |
||||
static_cast<RepeatedField<LayoutType>*>(&field)); |
||||
} |
||||
|
||||
#define PROTOBUF_TCT_SOURCE |
||||
#include <google/protobuf/generated_message_tctable_impl.inc> |
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue