Merge pull request #10595 from oqtvs:updateProtobuf
Alexander Alekhin
7 years ago
commit
cbb21f3cf2
174 changed files with 67642 additions and 82484 deletions
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,242 @@ |
||||
// 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 defines an Arena allocator for better allocation performance.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_ARENA_IMPL_H__ |
||||
#define GOOGLE_PROTOBUF_ARENA_IMPL_H__ |
||||
|
||||
#include <limits> |
||||
|
||||
#include <google/protobuf/stubs/atomic_sequence_num.h> |
||||
#include <google/protobuf/stubs/atomicops.h> |
||||
#include <google/protobuf/stubs/common.h> |
||||
#include <google/protobuf/stubs/logging.h> |
||||
#include <google/protobuf/stubs/mutex.h> |
||||
#include <google/protobuf/stubs/type_traits.h> |
||||
|
||||
#include <google/protobuf/stubs/port.h> |
||||
|
||||
namespace google { |
||||
|
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
inline size_t AlignUpTo8(size_t n) { |
||||
// Align n to next multiple of 8 (from Hacker's Delight, Chapter 3.)
|
||||
return (n + 7) & -8; |
||||
} |
||||
|
||||
// This class provides the core Arena memory allocation library. Different
|
||||
// implementations only need to implement the public interface below.
|
||||
// Arena is not a template type as that would only be useful if all protos
|
||||
// in turn would be templates, which will/cannot happen. However separating
|
||||
// the memory allocation part from the cruft of the API users expect we can
|
||||
// use #ifdef the select the best implementation based on hardware / OS.
|
||||
class LIBPROTOBUF_EXPORT ArenaImpl { |
||||
public: |
||||
struct Options { |
||||
size_t start_block_size; |
||||
size_t max_block_size; |
||||
char* initial_block; |
||||
size_t initial_block_size; |
||||
void* (*block_alloc)(size_t); |
||||
void (*block_dealloc)(void*, size_t); |
||||
|
||||
template <typename O> |
||||
explicit Options(const O& options) |
||||
: start_block_size(options.start_block_size), |
||||
max_block_size(options.max_block_size), |
||||
initial_block(options.initial_block), |
||||
initial_block_size(options.initial_block_size), |
||||
block_alloc(options.block_alloc), |
||||
block_dealloc(options.block_dealloc) {} |
||||
}; |
||||
|
||||
template <typename O> |
||||
explicit ArenaImpl(const O& options) : options_(options) { |
||||
if (options_.initial_block != NULL && options_.initial_block_size > 0) { |
||||
GOOGLE_CHECK_GE(options_.initial_block_size, sizeof(Block)) |
||||
<< ": Initial block size too small for header."; |
||||
initial_block_ = reinterpret_cast<Block*>(options_.initial_block); |
||||
} else { |
||||
initial_block_ = NULL; |
||||
} |
||||
|
||||
Init(); |
||||
} |
||||
|
||||
// Destructor deletes all owned heap allocated objects, and destructs objects
|
||||
// that have non-trivial destructors, except for proto2 message objects whose
|
||||
// destructors can be skipped. Also, frees all blocks except the initial block
|
||||
// if it was passed in.
|
||||
~ArenaImpl(); |
||||
|
||||
uint64 Reset(); |
||||
|
||||
uint64 SpaceAllocated() const; |
||||
uint64 SpaceUsed() const; |
||||
|
||||
void* AllocateAligned(size_t n); |
||||
|
||||
void* AllocateAlignedAndAddCleanup(size_t n, void (*cleanup)(void*)); |
||||
|
||||
// Add object pointer and cleanup function pointer to the list.
|
||||
void AddCleanup(void* elem, void (*cleanup)(void*)); |
||||
|
||||
private: |
||||
// Node contains the ptr of the object to be cleaned up and the associated
|
||||
// cleanup function ptr.
|
||||
struct CleanupNode { |
||||
void* elem; // Pointer to the object to be cleaned up.
|
||||
void (*cleanup)(void*); // Function pointer to the destructor or deleter.
|
||||
}; |
||||
|
||||
// Cleanup uses a chunked linked list, to reduce pointer chasing.
|
||||
struct CleanupChunk { |
||||
static size_t SizeOf(size_t i) { |
||||
return sizeof(CleanupChunk) + (sizeof(CleanupNode) * (i - 1)); |
||||
} |
||||
size_t len; // Number of elements currently present.
|
||||
size_t size; // Total elements in the list.
|
||||
CleanupChunk* next; // Next node in the list.
|
||||
CleanupNode nodes[1]; // True length is |size|.
|
||||
}; |
||||
|
||||
struct Block; |
||||
|
||||
// Tracks per-thread info. ThreadInfos are kept in a linked list.
|
||||
struct ThreadInfo { |
||||
void *owner; // &ThreadCache of this thread;
|
||||
Block* head; // Head of linked list of blocks.
|
||||
CleanupChunk* cleanup; // Head of cleanup list.
|
||||
ThreadInfo* next; // Next ThreadInfo in this linked list.
|
||||
}; |
||||
|
||||
// Blocks are variable length malloc-ed objects. The following structure
|
||||
// describes the common header for all blocks.
|
||||
struct Block { |
||||
void* owner; // &ThreadCache of thread that owns this block.
|
||||
ThreadInfo* thread_info; // ThreadInfo of thread that owns this block.
|
||||
Block* next; // Next block in arena (may have different owner)
|
||||
// ((char*) &block) + pos is next available byte. It is always
|
||||
// aligned at a multiple of 8 bytes.
|
||||
size_t pos; |
||||
size_t size; // total size of the block.
|
||||
GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE |
||||
size_t avail() const { return size - pos; } |
||||
// data follows
|
||||
}; |
||||
|
||||
struct ThreadCache { |
||||
#if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL) |
||||
// If we are using the ThreadLocalStorage class to store the ThreadCache,
|
||||
// then the ThreadCache's default constructor has to be responsible for
|
||||
// initializing it.
|
||||
ThreadCache() : last_lifecycle_id_seen(-1), last_block_used_(NULL) {} |
||||
#endif |
||||
|
||||
// The ThreadCache is considered valid as long as this matches the
|
||||
// lifecycle_id of the arena being used.
|
||||
int64 last_lifecycle_id_seen; |
||||
Block* last_block_used_; |
||||
}; |
||||
static google::protobuf::internal::SequenceNumber lifecycle_id_generator_; |
||||
#if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL) |
||||
// Android ndk does not support GOOGLE_THREAD_LOCAL keyword so we use a custom thread
|
||||
// local storage class we implemented.
|
||||
// iOS also does not support the GOOGLE_THREAD_LOCAL keyword.
|
||||
static ThreadCache& thread_cache(); |
||||
#elif defined(PROTOBUF_USE_DLLS) |
||||
// Thread local variables cannot be exposed through DLL interface but we can
|
||||
// wrap them in static functions.
|
||||
static ThreadCache& thread_cache(); |
||||
#else |
||||
static GOOGLE_THREAD_LOCAL ThreadCache thread_cache_; |
||||
static ThreadCache& thread_cache() { return thread_cache_; } |
||||
#endif |
||||
|
||||
void Init(); |
||||
|
||||
// Free all blocks and return the total space used which is the sums of sizes
|
||||
// of the all the allocated blocks.
|
||||
uint64 FreeBlocks(); |
||||
|
||||
void AddCleanupInBlock(Block* b, void* elem, void (*func)(void*)); |
||||
CleanupChunk* ExpandCleanupList(CleanupChunk* cleanup, Block* b); |
||||
// Delete or Destruct all objects owned by the arena.
|
||||
void CleanupList(); |
||||
|
||||
inline void CacheBlock(Block* block) { |
||||
thread_cache().last_block_used_ = block; |
||||
thread_cache().last_lifecycle_id_seen = lifecycle_id_; |
||||
// TODO(haberman): evaluate whether we would gain efficiency by getting rid
|
||||
// of hint_. It's the only write we do to ArenaImpl in the allocation path,
|
||||
// which will dirty the cache line.
|
||||
google::protobuf::internal::Release_Store(&hint_, reinterpret_cast<google::protobuf::internal::AtomicWord>(block)); |
||||
} |
||||
|
||||
google::protobuf::internal::AtomicWord threads_; // Pointer to a linked list of ThreadInfo.
|
||||
google::protobuf::internal::AtomicWord hint_; // Fast thread-local block access
|
||||
google::protobuf::internal::AtomicWord space_allocated_; // Sum of sizes of all allocated blocks.
|
||||
|
||||
Block *initial_block_; // If non-NULL, points to the block that came from
|
||||
// user data.
|
||||
|
||||
// Returns a block owned by this thread.
|
||||
Block* GetBlock(size_t n); |
||||
Block* GetBlockSlow(void* me, Block* my_full_block, size_t n); |
||||
Block* NewBlock(void* me, Block* my_last_block, size_t min_bytes); |
||||
void InitBlock(Block* b, void *me, size_t size); |
||||
static void* AllocFromBlock(Block* b, size_t n); |
||||
ThreadInfo* NewThreadInfo(Block* b); |
||||
ThreadInfo* FindThreadInfo(void* me); |
||||
ThreadInfo* GetThreadInfo(void* me, size_t n); |
||||
|
||||
int64 lifecycle_id_; // Unique for each arena. Changes on Reset().
|
||||
|
||||
Options options_; |
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ArenaImpl); |
||||
|
||||
public: |
||||
// kHeaderSize is sizeof(Block), aligned up to the nearest multiple of 8 to
|
||||
// protect the invariant that pos is always at a multiple of 8.
|
||||
static const size_t kHeaderSize = (sizeof(Block) + 7) & -8; |
||||
#if LANG_CXX11 |
||||
static_assert(kHeaderSize % 8 == 0, "kHeaderSize must be a multiple of 8."); |
||||
#endif |
||||
}; |
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_ARENA_IMPL_H__
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,103 @@ |
||||
// 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 <google/protobuf/generated_message_table_driven.h> |
||||
|
||||
#include <google/protobuf/stubs/type_traits.h> |
||||
|
||||
#include <google/protobuf/generated_message_table_driven_lite.h> |
||||
#include <google/protobuf/io/zero_copy_stream_impl_lite.h> |
||||
#include <google/protobuf/metadata.h> |
||||
#include <google/protobuf/repeated_field.h> |
||||
#include <google/protobuf/wire_format.h> |
||||
#include <google/protobuf/wire_format_lite.h> |
||||
#include <google/protobuf/wire_format_lite_inl.h> |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
namespace { |
||||
|
||||
UnknownFieldSet* MutableUnknownFields(MessageLite* msg, int64 arena_offset) { |
||||
return Raw<InternalMetadataWithArena>(msg, arena_offset) |
||||
->mutable_unknown_fields(); |
||||
} |
||||
|
||||
struct UnknownFieldHandler { |
||||
static bool Skip(MessageLite* msg, const ParseTable& table, |
||||
io::CodedInputStream* input, |
||||
int tag) { |
||||
GOOGLE_DCHECK(table.unknown_field_set); |
||||
|
||||
return WireFormat::SkipField(input, tag, |
||||
MutableUnknownFields(msg, table.arena_offset)); |
||||
} |
||||
|
||||
static void Varint(MessageLite* msg, const ParseTable& table, |
||||
int tag, int value) { |
||||
GOOGLE_DCHECK(table.unknown_field_set); |
||||
|
||||
MutableUnknownFields(msg, table.arena_offset)->AddVarint( |
||||
WireFormatLite::GetTagFieldNumber(tag), value); |
||||
} |
||||
|
||||
static bool ParseExtension( |
||||
MessageLite* msg, const ParseTable& table, |
||||
io::CodedInputStream* input, int tag) { |
||||
ExtensionSet* extensions = GetExtensionSet(msg, table.extension_offset); |
||||
if (extensions == NULL) { |
||||
return false; |
||||
} |
||||
|
||||
const Message* prototype = down_cast<const Message*>( |
||||
table.default_instance()); |
||||
|
||||
GOOGLE_DCHECK(prototype != NULL); |
||||
GOOGLE_DCHECK(table.unknown_field_set); |
||||
UnknownFieldSet* unknown_fields = |
||||
MutableUnknownFields(msg, table.arena_offset); |
||||
|
||||
return extensions->ParseField(tag, input, prototype, unknown_fields); |
||||
} |
||||
}; |
||||
|
||||
} // namespace
|
||||
|
||||
bool MergePartialFromCodedStream( |
||||
MessageLite* msg, const ParseTable& table, io::CodedInputStream* input) { |
||||
return MergePartialFromCodedStreamImpl<UnknownFieldHandler, |
||||
InternalMetadataWithArena>(msg, table, |
||||
input); |
||||
} |
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -0,0 +1,219 @@ |
||||
// 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_TABLE_DRIVEN_H__ |
||||
#define GOOGLE_PROTOBUF_GENERATED_MESSAGE_TABLE_DRIVEN_H__ |
||||
|
||||
#include <google/protobuf/map.h> |
||||
#include <google/protobuf/map_entry_lite.h> |
||||
#include <google/protobuf/map_field_lite.h> |
||||
#include <google/protobuf/message_lite.h> |
||||
#include <google/protobuf/wire_format_lite.h> |
||||
#include <google/protobuf/wire_format_lite_inl.h> |
||||
|
||||
#if LANG_CXX11 |
||||
#define PROTOBUF_CONSTEXPR constexpr |
||||
|
||||
// We require C++11 and Clang to use constexpr for variables, as GCC 4.8
|
||||
// requires constexpr to be consistent between declarations of variables
|
||||
// unnecessarily (see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58541).
|
||||
// VS 2017 Update 3 also supports this usage of constexpr.
|
||||
#if defined(__clang__) || (defined(_MSC_VER) && _MSC_VER >= 1911) |
||||
#define PROTOBUF_CONSTEXPR_VAR constexpr |
||||
#else // !__clang__
|
||||
#define PROTOBUF_CONSTEXPR_VAR |
||||
#endif // !_clang
|
||||
|
||||
#else |
||||
#define PROTOBUF_CONSTEXPR |
||||
#define PROTOBUF_CONSTEXPR_VAR |
||||
#endif |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
// Processing-type masks.
|
||||
static PROTOBUF_CONSTEXPR const unsigned char kOneofMask = 0x40; |
||||
static PROTOBUF_CONSTEXPR const unsigned char kRepeatedMask = 0x20; |
||||
// Mask for the raw type: either a WireFormatLite::FieldType or one of the
|
||||
// ProcessingTypes below, without the oneof or repeated flag.
|
||||
static PROTOBUF_CONSTEXPR const unsigned char kTypeMask = 0x1f; |
||||
|
||||
// Wire type masks.
|
||||
static PROTOBUF_CONSTEXPR const unsigned char kNotPackedMask = 0x10; |
||||
static PROTOBUF_CONSTEXPR const unsigned char kInvalidMask = 0x20; |
||||
|
||||
enum ProcessingTypes { |
||||
TYPE_STRING_CORD = 19, |
||||
TYPE_STRING_STRING_PIECE = 20, |
||||
TYPE_BYTES_CORD = 21, |
||||
TYPE_BYTES_STRING_PIECE = 22, |
||||
TYPE_MAP = 23, |
||||
}; |
||||
|
||||
#if LANG_CXX11 |
||||
static_assert(TYPE_MAP < kRepeatedMask, "Invalid enum"); |
||||
#endif |
||||
|
||||
// TODO(ckennelly): Add a static assertion to ensure that these masks do not
|
||||
// conflict with wiretypes.
|
||||
|
||||
// ParseTableField is kept small to help simplify instructions for computing
|
||||
// offsets, as we will always need this information to parse a field.
|
||||
// Additional data, needed for some types, is stored in
|
||||
// AuxillaryParseTableField.
|
||||
struct ParseTableField { |
||||
uint32 offset; |
||||
// The presence_index ordinarily represents a has_bit index, but for fields
|
||||
// inside a oneof it represents the index in _oneof_case_.
|
||||
uint32 presence_index; |
||||
unsigned char normal_wiretype; |
||||
unsigned char packed_wiretype; |
||||
|
||||
// processing_type is given by:
|
||||
// (FieldDescriptor->type() << 1) | FieldDescriptor->is_packed()
|
||||
unsigned char processing_type; |
||||
|
||||
unsigned char tag_size; |
||||
}; |
||||
|
||||
struct ParseTable; |
||||
|
||||
union AuxillaryParseTableField { |
||||
typedef bool (*EnumValidator)(int); |
||||
|
||||
// Enums
|
||||
struct enum_aux { |
||||
EnumValidator validator; |
||||
}; |
||||
enum_aux enums; |
||||
// Group, messages
|
||||
struct message_aux { |
||||
// ExplicitlyInitialized<T> -> T requires a reinterpret_cast, which prevents
|
||||
// the tables from being constructed as a constexpr. We use void to avoid
|
||||
// the cast.
|
||||
const void* default_message_void; |
||||
const MessageLite* default_message() const { |
||||
return static_cast<const MessageLite*>(default_message_void); |
||||
} |
||||
const ParseTable* parse_table; |
||||
}; |
||||
message_aux messages; |
||||
// Strings
|
||||
struct string_aux { |
||||
const void* default_ptr; |
||||
const char* field_name; |
||||
}; |
||||
string_aux strings; |
||||
|
||||
struct map_aux { |
||||
bool (*parse_map)(io::CodedInputStream*, void*); |
||||
}; |
||||
map_aux maps; |
||||
|
||||
#if LANG_CXX11 |
||||
AuxillaryParseTableField() = default; |
||||
#else |
||||
AuxillaryParseTableField() { } |
||||
#endif |
||||
PROTOBUF_CONSTEXPR AuxillaryParseTableField( |
||||
AuxillaryParseTableField::enum_aux e) : enums(e) {} |
||||
PROTOBUF_CONSTEXPR AuxillaryParseTableField( |
||||
AuxillaryParseTableField::message_aux m) : messages(m) {} |
||||
PROTOBUF_CONSTEXPR AuxillaryParseTableField( |
||||
AuxillaryParseTableField::string_aux s) : strings(s) {} |
||||
PROTOBUF_CONSTEXPR AuxillaryParseTableField( |
||||
AuxillaryParseTableField::map_aux m) |
||||
: maps(m) {} |
||||
}; |
||||
|
||||
struct ParseTable { |
||||
const ParseTableField* fields; |
||||
const AuxillaryParseTableField* aux; |
||||
int max_field_number; |
||||
// TODO(ckennelly): Do something with this padding.
|
||||
|
||||
// TODO(ckennelly): Vet these for sign extension.
|
||||
int64 has_bits_offset; |
||||
int64 oneof_case_offset; |
||||
int64 extension_offset; |
||||
int64 arena_offset; |
||||
|
||||
// ExplicitlyInitialized<T> -> T requires a reinterpret_cast, which prevents
|
||||
// the tables from being constructed as a constexpr. We use void to avoid
|
||||
// the cast.
|
||||
const void* default_instance_void; |
||||
const MessageLite* default_instance() const { |
||||
return static_cast<const MessageLite*>(default_instance_void); |
||||
} |
||||
|
||||
bool unknown_field_set; |
||||
}; |
||||
|
||||
// TODO(jhen): Remove the __NVCC__ check when we get a version of nvcc that
|
||||
// supports these checks.
|
||||
#if LANG_CXX11 && !defined(__NVCC__) |
||||
static_assert(sizeof(ParseTableField) <= 16, "ParseTableField is too large"); |
||||
// The tables must be composed of POD components to ensure link-time
|
||||
// initialization.
|
||||
static_assert(std::is_pod<ParseTableField>::value, ""); |
||||
static_assert(std::is_pod<AuxillaryParseTableField>::value, ""); |
||||
static_assert(std::is_pod<AuxillaryParseTableField::enum_aux>::value, ""); |
||||
static_assert(std::is_pod<AuxillaryParseTableField::message_aux>::value, ""); |
||||
static_assert(std::is_pod<AuxillaryParseTableField::string_aux>::value, ""); |
||||
static_assert(std::is_pod<ParseTable>::value, ""); |
||||
#endif |
||||
|
||||
// TODO(ckennelly): Consolidate these implementations into a single one, using
|
||||
// dynamic dispatch to the appropriate unknown field handler.
|
||||
bool MergePartialFromCodedStream(MessageLite* msg, const ParseTable& table, |
||||
io::CodedInputStream* input); |
||||
bool MergePartialFromCodedStreamLite(MessageLite* msg, const ParseTable& table, |
||||
io::CodedInputStream* input); |
||||
|
||||
template <typename Entry> |
||||
bool ParseMap(io::CodedInputStream* input, void* map_field) { |
||||
typedef typename MapEntryToMapField<Entry>::MapFieldType MapFieldType; |
||||
typedef google::protobuf::Map<typename Entry::EntryKeyType, |
||||
typename Entry::EntryValueType> |
||||
MapType; |
||||
typedef typename Entry::template Parser<MapFieldType, MapType> ParserType; |
||||
|
||||
ParserType parser(static_cast<MapFieldType*>(map_field)); |
||||
return ::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(input, |
||||
&parser); |
||||
} |
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_GENERATED_MESSAGE_TABLE_DRIVEN_H__
|
||||
@ -0,0 +1,109 @@ |
||||
// 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 <google/protobuf/generated_message_table_driven_lite.h> |
||||
|
||||
#include <google/protobuf/stubs/type_traits.h> |
||||
|
||||
#include <google/protobuf/io/zero_copy_stream_impl_lite.h> |
||||
#include <google/protobuf/metadata_lite.h> |
||||
#include <google/protobuf/repeated_field.h> |
||||
#include <google/protobuf/wire_format_lite.h> |
||||
#include <google/protobuf/wire_format_lite_inl.h> |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
namespace { |
||||
|
||||
string* MutableUnknownFields(MessageLite* msg, int64 arena_offset) { |
||||
return Raw<InternalMetadataWithArenaLite>(msg, arena_offset) |
||||
->mutable_unknown_fields(); |
||||
} |
||||
|
||||
struct UnknownFieldHandlerLite { |
||||
static bool Skip(MessageLite* msg, const ParseTable& table, |
||||
io::CodedInputStream* input, |
||||
int tag) { |
||||
GOOGLE_DCHECK(!table.unknown_field_set); |
||||
::google::protobuf::io::StringOutputStream unknown_fields_string( |
||||
MutableUnknownFields(msg, table.arena_offset)); |
||||
::google::protobuf::io::CodedOutputStream unknown_fields_stream( |
||||
&unknown_fields_string, false); |
||||
|
||||
return ::google::protobuf::internal::WireFormatLite::SkipField( |
||||
input, tag, &unknown_fields_stream); |
||||
} |
||||
|
||||
static void Varint(MessageLite* msg, const ParseTable& table, |
||||
int tag, int value) { |
||||
GOOGLE_DCHECK(!table.unknown_field_set); |
||||
|
||||
::google::protobuf::io::StringOutputStream unknown_fields_string( |
||||
MutableUnknownFields(msg, table.arena_offset)); |
||||
::google::protobuf::io::CodedOutputStream unknown_fields_stream( |
||||
&unknown_fields_string, false); |
||||
unknown_fields_stream.WriteVarint32(tag); |
||||
unknown_fields_stream.WriteVarint32(value); |
||||
} |
||||
|
||||
static bool ParseExtension( |
||||
MessageLite* msg, const ParseTable& table, |
||||
io::CodedInputStream* input, int tag) { |
||||
ExtensionSet* extensions = GetExtensionSet(msg, table.extension_offset); |
||||
if (extensions == NULL) { |
||||
return false; |
||||
} |
||||
|
||||
const MessageLite* prototype = table.default_instance(); |
||||
|
||||
GOOGLE_DCHECK(!table.unknown_field_set); |
||||
::google::protobuf::io::StringOutputStream unknown_fields_string( |
||||
MutableUnknownFields(msg, table.arena_offset)); |
||||
::google::protobuf::io::CodedOutputStream unknown_fields_stream( |
||||
&unknown_fields_string, false); |
||||
return extensions->ParseField( |
||||
tag, input, prototype, &unknown_fields_stream); |
||||
} |
||||
}; |
||||
|
||||
} // namespace
|
||||
|
||||
bool MergePartialFromCodedStreamLite( |
||||
MessageLite* msg, const ParseTable& table, io::CodedInputStream* input) { |
||||
return MergePartialFromCodedStreamImpl<UnknownFieldHandlerLite, |
||||
InternalMetadataWithArenaLite>( |
||||
msg, table, input); |
||||
} |
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -0,0 +1,823 @@ |
||||
// 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_TABLE_DRIVEN_LITE_H__ |
||||
#define GOOGLE_PROTOBUF_GENERATED_MESSAGE_TABLE_DRIVEN_LITE_H__ |
||||
|
||||
#include <google/protobuf/generated_message_table_driven.h> |
||||
|
||||
#include <google/protobuf/stubs/type_traits.h> |
||||
|
||||
#include <google/protobuf/io/zero_copy_stream_impl_lite.h> |
||||
#include <google/protobuf/extension_set.h> |
||||
#include <google/protobuf/metadata_lite.h> |
||||
#include <google/protobuf/repeated_field.h> |
||||
#include <google/protobuf/wire_format_lite.h> |
||||
#include <google/protobuf/wire_format_lite_inl.h> |
||||
|
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
|
||||
enum StringType { |
||||
StringType_STRING = 0, |
||||
StringType_CORD = 1, |
||||
StringType_STRING_PIECE = 2 |
||||
}; |
||||
|
||||
// Logically a superset of StringType, consisting of all field types that
|
||||
// require special initialization.
|
||||
enum ProcessingType { |
||||
ProcessingType_STRING = 0, |
||||
ProcessingType_CORD = 1, |
||||
ProcessingType_STRING_PIECE = 2, |
||||
ProcessingType_MESSAGE = 3 |
||||
}; |
||||
|
||||
enum Cardinality { |
||||
Cardinality_SINGULAR = 0, |
||||
Cardinality_REPEATED = 1, |
||||
Cardinality_ONEOF = 3 |
||||
}; |
||||
|
||||
template <typename Type> |
||||
inline Type* Raw(MessageLite* msg, int64 offset) { |
||||
return reinterpret_cast<Type*>(reinterpret_cast<uint8*>(msg) + offset); |
||||
} |
||||
|
||||
template <typename Type> |
||||
inline const Type* Raw(const MessageLite* msg, int64 offset) { |
||||
return reinterpret_cast<const Type*>(reinterpret_cast<const uint8*>(msg) + |
||||
offset); |
||||
} |
||||
|
||||
template <typename InternalMetadata> |
||||
inline Arena* GetArena(MessageLite* msg, int64 arena_offset) { |
||||
if (GOOGLE_PREDICT_FALSE(arena_offset == -1)) { |
||||
return NULL; |
||||
} |
||||
|
||||
return Raw<InternalMetadata>(msg, arena_offset)->arena(); |
||||
} |
||||
|
||||
inline ExtensionSet* GetExtensionSet(MessageLite* msg, int64 extension_offset) { |
||||
if (extension_offset == -1) { |
||||
return NULL; |
||||
} |
||||
|
||||
return Raw<ExtensionSet>(msg, extension_offset); |
||||
} |
||||
|
||||
template <typename Type> |
||||
inline Type* AddField(MessageLite* msg, int64 offset) { |
||||
#if LANG_CXX11 |
||||
static_assert(has_trivial_copy<Type>::value, |
||||
"Do not assign"); |
||||
#endif |
||||
|
||||
google::protobuf::RepeatedField<Type>* repeated = |
||||
Raw<google::protobuf::RepeatedField<Type> >(msg, offset); |
||||
return repeated->Add(); |
||||
} |
||||
|
||||
template <> |
||||
inline string* AddField<string>(MessageLite* msg, int64 offset) { |
||||
google::protobuf::RepeatedPtrField<string>* repeated = |
||||
Raw<google::protobuf::RepeatedPtrField<string> >(msg, offset); |
||||
return repeated->Add(); |
||||
} |
||||
|
||||
|
||||
template <typename Type> |
||||
inline void AddField(MessageLite* msg, int64 offset, Type value) { |
||||
#if LANG_CXX11 |
||||
static_assert(has_trivial_copy<Type>::value, |
||||
"Do not assign"); |
||||
#endif |
||||
*AddField<Type>(msg, offset) = value; |
||||
} |
||||
|
||||
inline void SetBit(uint32* has_bits, uint32 has_bit_index) { |
||||
GOOGLE_DCHECK(has_bits != NULL); |
||||
|
||||
uint32 mask = static_cast<uint32>(1u) << (has_bit_index % 32); |
||||
has_bits[has_bit_index / 32u] |= mask; |
||||
} |
||||
|
||||
template <typename Type> |
||||
inline Type* MutableField(MessageLite* msg, uint32* has_bits, |
||||
uint32 has_bit_index, int64 offset) { |
||||
SetBit(has_bits, has_bit_index); |
||||
return Raw<Type>(msg, offset); |
||||
} |
||||
|
||||
template <typename Type> |
||||
inline void SetField(MessageLite* msg, uint32* has_bits, uint32 has_bit_index, |
||||
int64 offset, Type value) { |
||||
#if LANG_CXX11 |
||||
static_assert(has_trivial_copy<Type>::value, |
||||
"Do not assign"); |
||||
#endif |
||||
*MutableField<Type>(msg, has_bits, has_bit_index, offset) = value; |
||||
} |
||||
|
||||
template <typename Type> |
||||
inline void SetOneofField(MessageLite* msg, uint32* oneof_case, |
||||
uint32 oneof_case_index, int64 offset, |
||||
int field_number, Type value) { |
||||
oneof_case[oneof_case_index] = field_number; |
||||
*Raw<Type>(msg, offset) = value; |
||||
} |
||||
|
||||
// Clears a oneof field. The field argument should correspond to the particular
|
||||
// field that is currently set in the oneof.
|
||||
inline void ClearOneofField(const ParseTableField& field, Arena* arena, |
||||
MessageLite* msg) { |
||||
switch (field.processing_type & kTypeMask) { |
||||
case WireFormatLite::TYPE_MESSAGE: |
||||
if (arena == NULL) { |
||||
delete *Raw<MessageLite*>(msg, field.offset); |
||||
} |
||||
break; |
||||
|
||||
case WireFormatLite::TYPE_STRING: |
||||
case WireFormatLite::TYPE_BYTES: |
||||
Raw<ArenaStringPtr>(msg, field.offset) |
||||
->Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena); |
||||
break; |
||||
|
||||
default: |
||||
// No cleanup needed.
|
||||
break; |
||||
} |
||||
} |
||||
|
||||
// Clears and reinitializes a oneof field as necessary, in preparation for
|
||||
// parsing a new value with type field_type and field number field_number.
|
||||
//
|
||||
// Note: the oneof_case argument should point directly to the _oneof_case_
|
||||
// element corresponding to this particular oneof, not to the beginning of the
|
||||
// _oneof_case_ array.
|
||||
template <ProcessingType field_type> |
||||
inline void ResetOneofField(const ParseTable& table, int field_number, |
||||
Arena* arena, MessageLite* msg, uint32* oneof_case, |
||||
int64 offset, const void* default_ptr) { |
||||
if (*oneof_case == field_number) { |
||||
// The oneof is already set to the right type, so there is no need to clear
|
||||
// it.
|
||||
return; |
||||
} |
||||
|
||||
if (*oneof_case != 0) { |
||||
ClearOneofField(table.fields[*oneof_case], arena, msg); |
||||
} |
||||
*oneof_case = field_number; |
||||
|
||||
switch (field_type) { |
||||
case ProcessingType_STRING: |
||||
Raw<ArenaStringPtr>(msg, offset) |
||||
->UnsafeSetDefault(static_cast<const string*>(default_ptr)); |
||||
break; |
||||
case ProcessingType_MESSAGE: |
||||
MessageLite** submessage = Raw<MessageLite*>(msg, offset); |
||||
const MessageLite* prototype = |
||||
table.aux[field_number].messages.default_message(); |
||||
*submessage = prototype->New(arena); |
||||
break; |
||||
} |
||||
} |
||||
|
||||
template <Cardinality cardinality, bool validate, StringType ctype> |
||||
static inline bool HandleString(io::CodedInputStream* input, MessageLite* msg, |
||||
Arena* arena, uint32* has_bits, |
||||
uint32 has_bit_index, int64 offset, |
||||
const void* default_ptr, |
||||
const char* field_name) { |
||||
#ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED |
||||
const char* sdata; |
||||
size_t size; |
||||
#endif |
||||
|
||||
string* value; |
||||
switch (cardinality) { |
||||
case Cardinality_SINGULAR: |
||||
// TODO(ckennelly): Is this optimal?
|
||||
value = |
||||
MutableField<ArenaStringPtr>(msg, has_bits, has_bit_index, offset) |
||||
->Mutable(static_cast<const string*>(default_ptr), arena); |
||||
break; |
||||
case Cardinality_REPEATED: |
||||
value = AddField<string>(msg, offset); |
||||
break; |
||||
case Cardinality_ONEOF: |
||||
value = Raw<ArenaStringPtr>(msg, offset) |
||||
->Mutable(static_cast<const string*>(default_ptr), arena); |
||||
break; |
||||
} |
||||
GOOGLE_DCHECK(value != NULL); |
||||
|
||||
if (GOOGLE_PREDICT_FALSE(!WireFormatLite::ReadString(input, value))) { |
||||
return false; |
||||
} |
||||
|
||||
#ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED |
||||
sdata = value->data(); |
||||
size = value->size(); |
||||
#endif |
||||
|
||||
#ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED |
||||
if (validate) { |
||||
WireFormatLite::VerifyUtf8String(sdata, size, WireFormatLite::PARSE, |
||||
field_name); |
||||
} |
||||
#endif |
||||
|
||||
return true; |
||||
} |
||||
|
||||
template <typename UnknownFieldHandler, typename InternalMetadata, |
||||
Cardinality cardinality> |
||||
inline bool HandleEnum(const ParseTable& table, io::CodedInputStream* input, |
||||
MessageLite* msg, uint32* presence, |
||||
uint32 presence_index, int64 offset, uint32 tag, |
||||
int field_number) { |
||||
int value; |
||||
if (GOOGLE_PREDICT_FALSE( |
||||
(!WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>( |
||||
input, &value)))) { |
||||
return false; |
||||
} |
||||
|
||||
AuxillaryParseTableField::EnumValidator validator = |
||||
table.aux[field_number].enums.validator; |
||||
if (validator(value)) { |
||||
switch (cardinality) { |
||||
case Cardinality_SINGULAR: |
||||
SetField(msg, presence, presence_index, offset, value); |
||||
break; |
||||
case Cardinality_REPEATED: |
||||
AddField(msg, offset, value); |
||||
break; |
||||
case Cardinality_ONEOF: |
||||
ClearOneofField(table.fields[presence[presence_index]], |
||||
GetArena<InternalMetadata>(msg, table.arena_offset), |
||||
msg); |
||||
SetOneofField(msg, presence, presence_index, offset, field_number, |
||||
value); |
||||
break; |
||||
} |
||||
} else { |
||||
UnknownFieldHandler::Varint(msg, table, tag, value); |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
// RepeatedMessageTypeHandler allows us to operate on RepeatedPtrField fields
|
||||
// without instantiating the specific template.
|
||||
class RepeatedMessageTypeHandler { |
||||
public: |
||||
typedef MessageLite Type; |
||||
static Arena* GetArena(Type* t) { return t->GetArena(); } |
||||
static void* GetMaybeArenaPointer(Type* t) { |
||||
return t->GetMaybeArenaPointer(); |
||||
} |
||||
static inline Type* NewFromPrototype(const Type* prototype, |
||||
Arena* arena = NULL) { |
||||
return prototype->New(arena); |
||||
} |
||||
static void Delete(Type* t, Arena* arena = NULL) { |
||||
if (arena == NULL) { |
||||
delete t; |
||||
} |
||||
} |
||||
}; |
||||
|
||||
inline bool ReadGroup(int field_number, io::CodedInputStream* input, |
||||
MessageLite* value) { |
||||
if (GOOGLE_PREDICT_FALSE(!input->IncrementRecursionDepth())) { |
||||
return false; |
||||
} |
||||
|
||||
if (GOOGLE_PREDICT_FALSE(!value->MergePartialFromCodedStream(input))) { |
||||
return false; |
||||
} |
||||
|
||||
input->DecrementRecursionDepth(); |
||||
// Make sure the last thing read was an end tag for this group.
|
||||
if (GOOGLE_PREDICT_FALSE(!input->LastTagWas(WireFormatLite::MakeTag( |
||||
field_number, WireFormatLite::WIRETYPE_END_GROUP)))) { |
||||
return false; |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
inline bool ReadMessage(io::CodedInputStream* input, MessageLite* value) { |
||||
int length; |
||||
if (GOOGLE_PREDICT_FALSE(!input->ReadVarintSizeAsInt(&length))) { |
||||
return false; |
||||
} |
||||
|
||||
std::pair<io::CodedInputStream::Limit, int> p = |
||||
input->IncrementRecursionDepthAndPushLimit(length); |
||||
if (GOOGLE_PREDICT_FALSE(p.second < 0 || |
||||
!value->MergePartialFromCodedStream(input))) { |
||||
return false; |
||||
} |
||||
|
||||
// Make sure that parsing stopped when the limit was hit, not at an endgroup
|
||||
// tag.
|
||||
return input->DecrementRecursionDepthAndPopLimit(p.first); |
||||
} |
||||
|
||||
class MergePartialFromCodedStreamHelper { |
||||
public: |
||||
static MessageLite* Add(RepeatedPtrFieldBase* field, |
||||
const MessageLite* prototype) { |
||||
return field->Add<RepeatedMessageTypeHandler>( |
||||
const_cast<MessageLite*>(prototype)); |
||||
} |
||||
}; |
||||
|
||||
template <typename UnknownFieldHandler, typename InternalMetadata> |
||||
bool MergePartialFromCodedStreamImpl(MessageLite* msg, const ParseTable& table, |
||||
io::CodedInputStream* input) { |
||||
// We require that has_bits are present, as to avoid having to check for them
|
||||
// for every field.
|
||||
//
|
||||
// TODO(ckennelly): Make this a compile-time parameter with templates.
|
||||
GOOGLE_DCHECK_GE(table.has_bits_offset, 0); |
||||
uint32* has_bits = Raw<uint32>(msg, table.has_bits_offset); |
||||
GOOGLE_DCHECK(has_bits != NULL); |
||||
|
||||
while (true) { |
||||
uint32 tag = input->ReadTag(); |
||||
|
||||
const WireFormatLite::WireType wire_type = |
||||
WireFormatLite::GetTagWireType(tag); |
||||
const int field_number = WireFormatLite::GetTagFieldNumber(tag); |
||||
|
||||
if (field_number > table.max_field_number) { |
||||
// check for possible extensions
|
||||
if (UnknownFieldHandler::ParseExtension(msg, table, input, tag)) { |
||||
// successfully parsed
|
||||
continue; |
||||
} |
||||
|
||||
if (GOOGLE_PREDICT_FALSE(!UnknownFieldHandler::Skip(msg, table, input, tag))) { |
||||
return false; |
||||
} |
||||
|
||||
continue; |
||||
} |
||||
|
||||
// We implicitly verify that data points to a valid field as we check the
|
||||
// wire types. Entries in table.fields[i] that do not correspond to valid
|
||||
// field numbers have their normal_wiretype and packed_wiretype fields set
|
||||
// with the kInvalidMask value. As wire_type cannot take on that value, we
|
||||
// will never match.
|
||||
const ParseTableField* data = table.fields + field_number; |
||||
|
||||
// TODO(ckennelly): Avoid sign extension
|
||||
const int64 presence_index = data->presence_index; |
||||
const int64 offset = data->offset; |
||||
const unsigned char processing_type = data->processing_type; |
||||
|
||||
if (data->normal_wiretype == static_cast<unsigned char>(wire_type)) { |
||||
// TODO(ckennelly): Use a computed goto on GCC/LLVM or otherwise eliminate
|
||||
// the bounds check on processing_type.
|
||||
|
||||
switch (processing_type) { |
||||
#define HANDLE_TYPE(TYPE, CPPTYPE) \ |
||||
case (WireFormatLite::TYPE_##TYPE): { \
|
||||
CPPTYPE value; \
|
||||
if (GOOGLE_PREDICT_FALSE( \
|
||||
(!WireFormatLite::ReadPrimitive< \
|
||||
CPPTYPE, WireFormatLite::TYPE_##TYPE>(input, &value)))) { \
|
||||
return false; \
|
||||
} \
|
||||
SetField(msg, has_bits, presence_index, offset, value); \
|
||||
break; \
|
||||
} \
|
||||
case (WireFormatLite::TYPE_##TYPE) | kRepeatedMask: { \
|
||||
google::protobuf::RepeatedField<CPPTYPE>* values = \
|
||||
Raw<google::protobuf::RepeatedField<CPPTYPE> >(msg, offset); \
|
||||
if (GOOGLE_PREDICT_FALSE((!WireFormatLite::ReadRepeatedPrimitive< \
|
||||
CPPTYPE, WireFormatLite::TYPE_##TYPE>( \
|
||||
data->tag_size, tag, input, values)))) { \
|
||||
return false; \
|
||||
} \
|
||||
break; \
|
||||
} \
|
||||
case (WireFormatLite::TYPE_##TYPE) | kOneofMask: { \
|
||||
uint32* oneof_case = Raw<uint32>(msg, table.oneof_case_offset); \
|
||||
CPPTYPE value; \
|
||||
if (GOOGLE_PREDICT_FALSE( \
|
||||
(!WireFormatLite::ReadPrimitive< \
|
||||
CPPTYPE, WireFormatLite::TYPE_##TYPE>(input, &value)))) { \
|
||||
return false; \
|
||||
} \
|
||||
ClearOneofField(table.fields[oneof_case[presence_index]], \
|
||||
GetArena<InternalMetadata>(msg, table.arena_offset), msg); \
|
||||
SetOneofField(msg, oneof_case, presence_index, offset, field_number, \
|
||||
value); \
|
||||
break; \
|
||||
} |
||||
|
||||
HANDLE_TYPE(INT32, int32) |
||||
HANDLE_TYPE(INT64, int64) |
||||
HANDLE_TYPE(SINT32, int32) |
||||
HANDLE_TYPE(SINT64, int64) |
||||
HANDLE_TYPE(UINT32, uint32) |
||||
HANDLE_TYPE(UINT64, uint64) |
||||
|
||||
HANDLE_TYPE(FIXED32, uint32) |
||||
HANDLE_TYPE(FIXED64, uint64) |
||||
HANDLE_TYPE(SFIXED32, int32) |
||||
HANDLE_TYPE(SFIXED64, int64) |
||||
|
||||
HANDLE_TYPE(FLOAT, float) |
||||
HANDLE_TYPE(DOUBLE, double) |
||||
|
||||
HANDLE_TYPE(BOOL, bool) |
||||
#undef HANDLE_TYPE |
||||
case WireFormatLite::TYPE_BYTES: |
||||
#ifndef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED |
||||
case WireFormatLite::TYPE_STRING: |
||||
#endif |
||||
{ |
||||
Arena* const arena = |
||||
GetArena<InternalMetadata>(msg, table.arena_offset); |
||||
const void* default_ptr = table.aux[field_number].strings.default_ptr; |
||||
|
||||
if (GOOGLE_PREDICT_FALSE(( |
||||
!HandleString<Cardinality_SINGULAR, false, StringType_STRING>( |
||||
input, msg, arena, has_bits, presence_index, offset, |
||||
default_ptr, NULL)))) { |
||||
return false; |
||||
} |
||||
break; |
||||
} |
||||
case WireFormatLite::TYPE_BYTES | kOneofMask: |
||||
#ifndef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED |
||||
case WireFormatLite::TYPE_STRING | kOneofMask: |
||||
#endif |
||||
{ |
||||
Arena* const arena = |
||||
GetArena<InternalMetadata>(msg, table.arena_offset); |
||||
uint32* oneof_case = Raw<uint32>(msg, table.oneof_case_offset); |
||||
const void* default_ptr = table.aux[field_number].strings.default_ptr; |
||||
|
||||
ResetOneofField<ProcessingType_STRING>( |
||||
table, field_number, arena, msg, oneof_case + presence_index, |
||||
offset, default_ptr); |
||||
|
||||
if (GOOGLE_PREDICT_FALSE( |
||||
(!HandleString<Cardinality_ONEOF, false, StringType_STRING>( |
||||
input, msg, arena, has_bits, presence_index, offset, |
||||
default_ptr, NULL)))) { |
||||
return false; |
||||
} |
||||
break; |
||||
} |
||||
case (WireFormatLite::TYPE_BYTES) | kRepeatedMask: |
||||
#ifndef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED |
||||
case (WireFormatLite::TYPE_STRING) | kRepeatedMask: |
||||
#endif |
||||
{ |
||||
Arena* const arena = |
||||
GetArena<InternalMetadata>(msg, table.arena_offset); |
||||
const void* default_ptr = |
||||
table.aux[field_number].strings.default_ptr; |
||||
|
||||
if (GOOGLE_PREDICT_FALSE(( |
||||
!HandleString<Cardinality_REPEATED, false, StringType_STRING>( |
||||
input, msg, arena, has_bits, presence_index, offset, |
||||
default_ptr, NULL)))) { |
||||
return false; |
||||
} |
||||
break; |
||||
} |
||||
#ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED |
||||
case (WireFormatLite::TYPE_STRING): { |
||||
Arena* const arena = |
||||
GetArena<InternalMetadata>(msg, table.arena_offset); |
||||
const void* default_ptr = table.aux[field_number].strings.default_ptr; |
||||
const char* field_name = table.aux[field_number].strings.field_name; |
||||
|
||||
if (GOOGLE_PREDICT_FALSE( |
||||
(!HandleString<Cardinality_SINGULAR, true, StringType_STRING>( |
||||
input, msg, arena, has_bits, presence_index, offset, |
||||
default_ptr, field_name)))) { |
||||
return false; |
||||
} |
||||
break; |
||||
} |
||||
case (WireFormatLite::TYPE_STRING) | kRepeatedMask: { |
||||
Arena* const arena = |
||||
GetArena<InternalMetadata>(msg, table.arena_offset); |
||||
const void* default_ptr = table.aux[field_number].strings.default_ptr; |
||||
const char* field_name = table.aux[field_number].strings.field_name; |
||||
|
||||
if (GOOGLE_PREDICT_FALSE( |
||||
(!HandleString<Cardinality_REPEATED, true, StringType_STRING>( |
||||
input, msg, arena, has_bits, presence_index, offset, |
||||
default_ptr, field_name)))) { |
||||
return false; |
||||
} |
||||
break; |
||||
} |
||||
case (WireFormatLite::TYPE_STRING) | kOneofMask: { |
||||
Arena* const arena = |
||||
GetArena<InternalMetadata>(msg, table.arena_offset); |
||||
uint32* oneof_case = Raw<uint32>(msg, table.oneof_case_offset); |
||||
const void* default_ptr = table.aux[field_number].strings.default_ptr; |
||||
const char* field_name = table.aux[field_number].strings.field_name; |
||||
|
||||
ResetOneofField<ProcessingType_STRING>( |
||||
table, field_number, arena, msg, oneof_case + presence_index, |
||||
offset, default_ptr); |
||||
|
||||
if (GOOGLE_PREDICT_FALSE( |
||||
(!HandleString<Cardinality_ONEOF, true, StringType_STRING>( |
||||
input, msg, arena, has_bits, presence_index, offset, |
||||
default_ptr, field_name)))) { |
||||
return false; |
||||
} |
||||
break; |
||||
} |
||||
#endif |
||||
case WireFormatLite::TYPE_ENUM: { |
||||
if (GOOGLE_PREDICT_FALSE((!HandleEnum<UnknownFieldHandler, InternalMetadata, |
||||
Cardinality_SINGULAR>( |
||||
table, input, msg, has_bits, presence_index, offset, tag, |
||||
field_number)))) { |
||||
return false; |
||||
} |
||||
break; |
||||
} |
||||
case WireFormatLite::TYPE_ENUM | kRepeatedMask: { |
||||
if (GOOGLE_PREDICT_FALSE((!HandleEnum<UnknownFieldHandler, InternalMetadata, |
||||
Cardinality_REPEATED>( |
||||
table, input, msg, has_bits, presence_index, offset, tag, |
||||
field_number)))) { |
||||
return false; |
||||
} |
||||
break; |
||||
} |
||||
case WireFormatLite::TYPE_ENUM | kOneofMask: { |
||||
uint32* oneof_case = Raw<uint32>(msg, table.oneof_case_offset); |
||||
if (GOOGLE_PREDICT_FALSE((!HandleEnum<UnknownFieldHandler, InternalMetadata, |
||||
Cardinality_ONEOF>( |
||||
table, input, msg, oneof_case, presence_index, offset, tag, |
||||
field_number)))) { |
||||
return false; |
||||
} |
||||
break; |
||||
} |
||||
case WireFormatLite::TYPE_GROUP: { |
||||
MessageLite** submsg_holder = |
||||
MutableField<MessageLite*>(msg, has_bits, presence_index, offset); |
||||
MessageLite* submsg = *submsg_holder; |
||||
|
||||
if (submsg == NULL) { |
||||
Arena* const arena = |
||||
GetArena<InternalMetadata>(msg, table.arena_offset); |
||||
const MessageLite* prototype = |
||||
table.aux[field_number].messages.default_message(); |
||||
submsg = prototype->New(arena); |
||||
*submsg_holder = submsg; |
||||
} |
||||
|
||||
if (GOOGLE_PREDICT_FALSE(!WireFormatLite::ReadGroup( |
||||
field_number, input, submsg))) { |
||||
return false; |
||||
} |
||||
|
||||
break; |
||||
} |
||||
case WireFormatLite::TYPE_GROUP | kRepeatedMask: { |
||||
RepeatedPtrFieldBase* field = Raw<RepeatedPtrFieldBase>(msg, offset); |
||||
const MessageLite* prototype = |
||||
table.aux[field_number].messages.default_message(); |
||||
GOOGLE_DCHECK(prototype != NULL); |
||||
|
||||
MessageLite* submsg = |
||||
MergePartialFromCodedStreamHelper::Add(field, prototype); |
||||
|
||||
if (GOOGLE_PREDICT_FALSE(!WireFormatLite::ReadGroup( |
||||
field_number, input, submsg))) { |
||||
return false; |
||||
} |
||||
|
||||
break; |
||||
} |
||||
case WireFormatLite::TYPE_MESSAGE: { |
||||
MessageLite** submsg_holder = |
||||
MutableField<MessageLite*>(msg, has_bits, presence_index, offset); |
||||
MessageLite* submsg = *submsg_holder; |
||||
|
||||
if (submsg == NULL) { |
||||
Arena* const arena = |
||||
GetArena<InternalMetadata>(msg, table.arena_offset); |
||||
const MessageLite* prototype = |
||||
table.aux[field_number].messages.default_message(); |
||||
submsg = prototype->New(arena); |
||||
*submsg_holder = submsg; |
||||
} |
||||
|
||||
if (GOOGLE_PREDICT_FALSE(!WireFormatLite::ReadMessage(input, submsg))) { |
||||
return false; |
||||
} |
||||
|
||||
break; |
||||
} |
||||
// TODO(ckennelly): Adapt ReadMessageNoVirtualNoRecursionDepth and
|
||||
// manage input->IncrementRecursionDepth() here.
|
||||
case WireFormatLite::TYPE_MESSAGE | kRepeatedMask: { |
||||
RepeatedPtrFieldBase* field = Raw<RepeatedPtrFieldBase>(msg, offset); |
||||
const MessageLite* prototype = |
||||
table.aux[field_number].messages.default_message(); |
||||
GOOGLE_DCHECK(prototype != NULL); |
||||
|
||||
MessageLite* submsg = |
||||
MergePartialFromCodedStreamHelper::Add(field, prototype); |
||||
|
||||
if (GOOGLE_PREDICT_FALSE(!WireFormatLite::ReadMessage(input, submsg))) { |
||||
return false; |
||||
} |
||||
|
||||
break; |
||||
} |
||||
case WireFormatLite::TYPE_MESSAGE | kOneofMask: { |
||||
Arena* const arena = |
||||
GetArena<InternalMetadata>(msg, table.arena_offset); |
||||
uint32* oneof_case = Raw<uint32>(msg, table.oneof_case_offset); |
||||
MessageLite** submsg_holder = Raw<MessageLite*>(msg, offset); |
||||
ResetOneofField<ProcessingType_MESSAGE>( |
||||
table, field_number, arena, msg, oneof_case + presence_index, |
||||
offset, NULL); |
||||
MessageLite* submsg = *submsg_holder; |
||||
|
||||
if (GOOGLE_PREDICT_FALSE(!WireFormatLite::ReadMessage(input, submsg))) { |
||||
return false; |
||||
} |
||||
|
||||
break; |
||||
} |
||||
case TYPE_MAP: { |
||||
if (GOOGLE_PREDICT_FALSE(!(*table.aux[field_number].maps.parse_map)( |
||||
input, Raw<void>(msg, offset)))) { |
||||
return false; |
||||
} |
||||
break; |
||||
} |
||||
case 0: { |
||||
// Done.
|
||||
return true; |
||||
} |
||||
default: |
||||
break; |
||||
} |
||||
} else if (data->packed_wiretype == static_cast<unsigned char>(wire_type)) { |
||||
// Non-packable fields have their packed_wiretype masked with
|
||||
// kNotPackedMask, which is impossible to match here.
|
||||
GOOGLE_DCHECK(processing_type & kRepeatedMask); |
||||
GOOGLE_DCHECK_NE(processing_type, kRepeatedMask); |
||||
GOOGLE_DCHECK_EQ(0, processing_type & kOneofMask); |
||||
|
||||
|
||||
|
||||
// TODO(ckennelly): Use a computed goto on GCC/LLVM.
|
||||
//
|
||||
// Mask out kRepeatedMask bit, allowing the jump table to be smaller.
|
||||
switch (static_cast<WireFormatLite::FieldType>( |
||||
processing_type ^ kRepeatedMask)) { |
||||
#define HANDLE_PACKED_TYPE(TYPE, CPPTYPE, CPPTYPE_METHOD) \ |
||||
case WireFormatLite::TYPE_##TYPE: { \
|
||||
google::protobuf::RepeatedField<CPPTYPE>* values = \
|
||||
Raw<google::protobuf::RepeatedField<CPPTYPE> >(msg, offset); \
|
||||
if (GOOGLE_PREDICT_FALSE( \
|
||||
(!WireFormatLite::ReadPackedPrimitive< \
|
||||
CPPTYPE, WireFormatLite::TYPE_##TYPE>(input, values)))) { \
|
||||
return false; \
|
||||
} \
|
||||
break; \
|
||||
} |
||||
|
||||
HANDLE_PACKED_TYPE(INT32, int32, Int32) |
||||
HANDLE_PACKED_TYPE(INT64, int64, Int64) |
||||
HANDLE_PACKED_TYPE(SINT32, int32, Int32) |
||||
HANDLE_PACKED_TYPE(SINT64, int64, Int64) |
||||
HANDLE_PACKED_TYPE(UINT32, uint32, UInt32) |
||||
HANDLE_PACKED_TYPE(UINT64, uint64, UInt64) |
||||
|
||||
HANDLE_PACKED_TYPE(FIXED32, uint32, UInt32) |
||||
HANDLE_PACKED_TYPE(FIXED64, uint64, UInt64) |
||||
HANDLE_PACKED_TYPE(SFIXED32, int32, Int32) |
||||
HANDLE_PACKED_TYPE(SFIXED64, int64, Int64) |
||||
|
||||
HANDLE_PACKED_TYPE(FLOAT, float, Float) |
||||
HANDLE_PACKED_TYPE(DOUBLE, double, Double) |
||||
|
||||
HANDLE_PACKED_TYPE(BOOL, bool, Bool) |
||||
#undef HANDLE_PACKED_TYPE |
||||
case WireFormatLite::TYPE_ENUM: { |
||||
// To avoid unnecessarily calling MutableUnknownFields (which mutates
|
||||
// InternalMetadataWithArena) when all inputs in the repeated series
|
||||
// are valid, we implement our own parser rather than call
|
||||
// WireFormat::ReadPackedEnumPreserveUnknowns.
|
||||
uint32 length; |
||||
if (GOOGLE_PREDICT_FALSE(!input->ReadVarint32(&length))) { |
||||
return false; |
||||
} |
||||
|
||||
AuxillaryParseTableField::EnumValidator validator = |
||||
table.aux[field_number].enums.validator; |
||||
google::protobuf::RepeatedField<int>* values = |
||||
Raw<google::protobuf::RepeatedField<int> >(msg, offset); |
||||
|
||||
io::CodedInputStream::Limit limit = input->PushLimit(length); |
||||
while (input->BytesUntilLimit() > 0) { |
||||
int value; |
||||
if (GOOGLE_PREDICT_FALSE( |
||||
(!google::protobuf::internal::WireFormatLite::ReadPrimitive< |
||||
int, WireFormatLite::TYPE_ENUM>(input, &value)))) { |
||||
return false; |
||||
} |
||||
|
||||
if (validator(value)) { |
||||
values->Add(value); |
||||
} else { |
||||
// TODO(ckennelly): Consider caching here.
|
||||
UnknownFieldHandler::Varint(msg, table, tag, value); |
||||
} |
||||
} |
||||
input->PopLimit(limit); |
||||
|
||||
break; |
||||
} |
||||
case WireFormatLite::TYPE_STRING: |
||||
case WireFormatLite::TYPE_GROUP: |
||||
case WireFormatLite::TYPE_MESSAGE: |
||||
case WireFormatLite::TYPE_BYTES: |
||||
GOOGLE_DCHECK(false); |
||||
return false; |
||||
default: |
||||
break; |
||||
} |
||||
} else { |
||||
if (wire_type == WireFormatLite::WIRETYPE_END_GROUP) { |
||||
// Must be the end of the message.
|
||||
return true; |
||||
} |
||||
|
||||
// check for possible extensions
|
||||
if (UnknownFieldHandler::ParseExtension(msg, table, input, tag)) { |
||||
// successfully parsed
|
||||
continue; |
||||
} |
||||
|
||||
// process unknown field.
|
||||
if (GOOGLE_PREDICT_FALSE(!UnknownFieldHandler::Skip(msg, table, input, tag))) { |
||||
return false; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_GENERATED_MESSAGE_TABLE_DRIVEN_LITE_H__
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,224 @@ |
||||
// 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_METADATA_LITE_H__ |
||||
#define GOOGLE_PROTOBUF_METADATA_LITE_H__ |
||||
|
||||
#include <google/protobuf/stubs/common.h> |
||||
#include <google/protobuf/arena.h> |
||||
#include <google/protobuf/message_lite.h> |
||||
#include <google/protobuf/stubs/port.h> |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
// This is the representation for messages that support arena allocation. It
|
||||
// uses a tagged pointer to either store the Arena pointer, if there are no
|
||||
// unknown fields, or a pointer to a block of memory with both the Arena pointer
|
||||
// and the UnknownFieldSet, if there are unknown fields. This optimization
|
||||
// allows for "zero-overhead" storage of the Arena pointer, relative to the
|
||||
// above baseline implementation.
|
||||
//
|
||||
// The tagged pointer uses the LSB to disambiguate cases, and uses bit 0 == 0 to
|
||||
// indicate an arena pointer and bit 0 == 1 to indicate a UFS+Arena-container
|
||||
// pointer.
|
||||
template <class T, class Derived> |
||||
class InternalMetadataWithArenaBase { |
||||
public: |
||||
InternalMetadataWithArenaBase() : ptr_(NULL) {} |
||||
explicit InternalMetadataWithArenaBase(Arena* arena) : ptr_(arena) {} |
||||
|
||||
~InternalMetadataWithArenaBase() { |
||||
if (have_unknown_fields() && arena() == NULL) { |
||||
delete PtrValue<Container>(); |
||||
} |
||||
ptr_ = NULL; |
||||
} |
||||
|
||||
GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE const T& unknown_fields() const { |
||||
if (GOOGLE_PREDICT_FALSE(have_unknown_fields())) { |
||||
return PtrValue<Container>()->unknown_fields; |
||||
} else { |
||||
return Derived::default_instance(); |
||||
} |
||||
} |
||||
|
||||
GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE T* mutable_unknown_fields() { |
||||
if (GOOGLE_PREDICT_TRUE(have_unknown_fields())) { |
||||
return &PtrValue<Container>()->unknown_fields; |
||||
} else { |
||||
return mutable_unknown_fields_slow(); |
||||
} |
||||
} |
||||
|
||||
GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE Arena* arena() const { |
||||
if (GOOGLE_PREDICT_FALSE(have_unknown_fields())) { |
||||
return PtrValue<Container>()->arena; |
||||
} else { |
||||
return PtrValue<Arena>(); |
||||
} |
||||
} |
||||
|
||||
GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE bool have_unknown_fields() const { |
||||
return PtrTag() == kTagContainer; |
||||
} |
||||
|
||||
GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE void Swap(Derived* other) { |
||||
// Semantics here are that we swap only the unknown fields, not the arena
|
||||
// pointer. We cannot simply swap ptr_ with other->ptr_ because we need to
|
||||
// maintain our own arena ptr. Also, our ptr_ and other's ptr_ may be in
|
||||
// different states (direct arena pointer vs. container with UFS) so we
|
||||
// cannot simply swap ptr_ and then restore the arena pointers. We reuse
|
||||
// UFS's swap implementation instead.
|
||||
if (have_unknown_fields() || other->have_unknown_fields()) { |
||||
static_cast<Derived*>(this)->DoSwap(other->mutable_unknown_fields()); |
||||
} |
||||
} |
||||
|
||||
GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE void MergeFrom(const Derived& other) { |
||||
if (other.have_unknown_fields()) { |
||||
static_cast<Derived*>(this)->DoMergeFrom(other.unknown_fields()); |
||||
} |
||||
} |
||||
|
||||
GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE void Clear() { |
||||
if (have_unknown_fields()) { |
||||
static_cast<Derived*>(this)->DoClear(); |
||||
} |
||||
} |
||||
|
||||
GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE void* raw_arena_ptr() const { |
||||
return ptr_; |
||||
} |
||||
|
||||
private: |
||||
void* ptr_; |
||||
|
||||
// Tagged pointer implementation.
|
||||
enum { |
||||
// ptr_ is an Arena*.
|
||||
kTagArena = 0, |
||||
// ptr_ is a Container*.
|
||||
kTagContainer = 1, |
||||
}; |
||||
static const intptr_t kPtrTagMask = 1; |
||||
static const intptr_t kPtrValueMask = ~kPtrTagMask; |
||||
|
||||
// Accessors for pointer tag and pointer value.
|
||||
GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE int PtrTag() const { |
||||
return reinterpret_cast<intptr_t>(ptr_) & kPtrTagMask; |
||||
} |
||||
|
||||
template<typename U> U* PtrValue() const { |
||||
return reinterpret_cast<U*>( |
||||
reinterpret_cast<intptr_t>(ptr_) & kPtrValueMask); |
||||
} |
||||
|
||||
// If ptr_'s tag is kTagContainer, it points to an instance of this struct.
|
||||
struct Container { |
||||
T unknown_fields; |
||||
Arena* arena; |
||||
}; |
||||
|
||||
GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE T* mutable_unknown_fields_slow() { |
||||
Arena* my_arena = arena(); |
||||
Container* container = Arena::Create<Container>(my_arena); |
||||
// Two-step assignment works around a bug in clang's static analyzer:
|
||||
// https://bugs.llvm.org/show_bug.cgi?id=34198.
|
||||
ptr_ = container; |
||||
ptr_ = reinterpret_cast<void*>( |
||||
reinterpret_cast<intptr_t>(ptr_) | kTagContainer); |
||||
container->arena = my_arena; |
||||
return &(container->unknown_fields); |
||||
} |
||||
}; |
||||
|
||||
// We store unknown fields as a string right now, because there is currently no
|
||||
// good interface for reading unknown fields into an ArenaString. We may want
|
||||
// to revisit this to allow unknown fields to be parsed onto the Arena.
|
||||
class InternalMetadataWithArenaLite |
||||
: public InternalMetadataWithArenaBase<string, |
||||
InternalMetadataWithArenaLite> { |
||||
public: |
||||
InternalMetadataWithArenaLite() {} |
||||
|
||||
explicit InternalMetadataWithArenaLite(Arena* arena) |
||||
: InternalMetadataWithArenaBase<string, |
||||
InternalMetadataWithArenaLite>(arena) {} |
||||
|
||||
void DoSwap(string* other) { |
||||
mutable_unknown_fields()->swap(*other); |
||||
} |
||||
|
||||
void DoMergeFrom(const string& other) { |
||||
mutable_unknown_fields()->append(other); |
||||
} |
||||
|
||||
void DoClear() { |
||||
mutable_unknown_fields()->clear(); |
||||
} |
||||
|
||||
static const string& default_instance() { |
||||
return GetEmptyStringAlreadyInited(); |
||||
} |
||||
}; |
||||
|
||||
// This helper RAII class is needed to efficiently parse unknown fields. We
|
||||
// should only call mutable_unknown_fields if there are actual unknown fields.
|
||||
// The obvious thing to just use a stack string and swap it at the end of the
|
||||
// parse won't work, because the destructor of StringOutputStream needs to be
|
||||
// called before we can modify the string (it check-fails). Using
|
||||
// LiteUnknownFieldSetter setter(&_internal_metadata_);
|
||||
// StringOutputStream stream(setter.buffer());
|
||||
// guarantees that the string is only swapped after stream is destroyed.
|
||||
class LIBPROTOBUF_EXPORT LiteUnknownFieldSetter { |
||||
public: |
||||
explicit LiteUnknownFieldSetter(InternalMetadataWithArenaLite* metadata) |
||||
: metadata_(metadata) { |
||||
if (metadata->have_unknown_fields()) { |
||||
buffer_.swap(*metadata->mutable_unknown_fields()); |
||||
} |
||||
} |
||||
~LiteUnknownFieldSetter() { |
||||
if (!buffer_.empty()) metadata_->mutable_unknown_fields()->swap(buffer_); |
||||
} |
||||
string* buffer() { return &buffer_; } |
||||
|
||||
private: |
||||
InternalMetadataWithArenaLite* metadata_; |
||||
string buffer_; |
||||
}; |
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_METADATA_LITE_H__
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,122 +0,0 @@ |
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2012 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 is an internal atomic implementation, use atomicops.h instead.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_ATOMICWORD_COMPAT_H_ |
||||
#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_ATOMICWORD_COMPAT_H_ |
||||
|
||||
// AtomicWord is a synonym for intptr_t, and Atomic32 is a synonym for int32,
|
||||
// which in turn means int. On some LP32 platforms, intptr_t is an int, but
|
||||
// on others, it's a long. When AtomicWord and Atomic32 are based on different
|
||||
// fundamental types, their pointers are incompatible.
|
||||
//
|
||||
// This file defines function overloads to allow both AtomicWord and Atomic32
|
||||
// data to be used with this interface.
|
||||
//
|
||||
// On LP64 platforms, AtomicWord and Atomic64 are both always long,
|
||||
// so this problem doesn't occur.
|
||||
|
||||
#if !defined(GOOGLE_PROTOBUF_ARCH_64_BIT) |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
inline AtomicWord NoBarrier_CompareAndSwap(volatile AtomicWord* ptr, |
||||
AtomicWord old_value, |
||||
AtomicWord new_value) { |
||||
return NoBarrier_CompareAndSwap( |
||||
reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value); |
||||
} |
||||
|
||||
inline AtomicWord NoBarrier_AtomicExchange(volatile AtomicWord* ptr, |
||||
AtomicWord new_value) { |
||||
return NoBarrier_AtomicExchange( |
||||
reinterpret_cast<volatile Atomic32*>(ptr), new_value); |
||||
} |
||||
|
||||
inline AtomicWord NoBarrier_AtomicIncrement(volatile AtomicWord* ptr, |
||||
AtomicWord increment) { |
||||
return NoBarrier_AtomicIncrement( |
||||
reinterpret_cast<volatile Atomic32*>(ptr), increment); |
||||
} |
||||
|
||||
inline AtomicWord Barrier_AtomicIncrement(volatile AtomicWord* ptr, |
||||
AtomicWord increment) { |
||||
return Barrier_AtomicIncrement( |
||||
reinterpret_cast<volatile Atomic32*>(ptr), increment); |
||||
} |
||||
|
||||
inline AtomicWord Acquire_CompareAndSwap(volatile AtomicWord* ptr, |
||||
AtomicWord old_value, |
||||
AtomicWord new_value) { |
||||
return Acquire_CompareAndSwap( |
||||
reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value); |
||||
} |
||||
|
||||
inline AtomicWord Release_CompareAndSwap(volatile AtomicWord* ptr, |
||||
AtomicWord old_value, |
||||
AtomicWord new_value) { |
||||
return Release_CompareAndSwap( |
||||
reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value); |
||||
} |
||||
|
||||
inline void NoBarrier_Store(volatile AtomicWord *ptr, AtomicWord value) { |
||||
NoBarrier_Store(reinterpret_cast<volatile Atomic32*>(ptr), value); |
||||
} |
||||
|
||||
inline void Acquire_Store(volatile AtomicWord* ptr, AtomicWord value) { |
||||
return Acquire_Store(reinterpret_cast<volatile Atomic32*>(ptr), value); |
||||
} |
||||
|
||||
inline void Release_Store(volatile AtomicWord* ptr, AtomicWord value) { |
||||
return Release_Store(reinterpret_cast<volatile Atomic32*>(ptr), value); |
||||
} |
||||
|
||||
inline AtomicWord NoBarrier_Load(volatile const AtomicWord *ptr) { |
||||
return NoBarrier_Load(reinterpret_cast<volatile const Atomic32*>(ptr)); |
||||
} |
||||
|
||||
inline AtomicWord Acquire_Load(volatile const AtomicWord* ptr) { |
||||
return Acquire_Load(reinterpret_cast<volatile const Atomic32*>(ptr)); |
||||
} |
||||
|
||||
inline AtomicWord Release_Load(volatile const AtomicWord* ptr) { |
||||
return Release_Load(reinterpret_cast<volatile const Atomic32*>(ptr)); |
||||
} |
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // !defined(GOOGLE_PROTOBUF_ARCH_64_BIT)
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_ATOMICWORD_COMPAT_H_
|
||||
@ -1,225 +0,0 @@ |
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2012 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 is an internal atomic implementation, use atomicops.h instead.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_MACOSX_H_ |
||||
#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_MACOSX_H_ |
||||
|
||||
#include <libkern/OSAtomic.h> |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value) { |
||||
Atomic32 prev_value; |
||||
do { |
||||
if (OSAtomicCompareAndSwap32(old_value, new_value, |
||||
const_cast<Atomic32*>(ptr))) { |
||||
return old_value; |
||||
} |
||||
prev_value = *ptr; |
||||
} while (prev_value == old_value); |
||||
return prev_value; |
||||
} |
||||
|
||||
inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, |
||||
Atomic32 new_value) { |
||||
Atomic32 old_value; |
||||
do { |
||||
old_value = *ptr; |
||||
} while (!OSAtomicCompareAndSwap32(old_value, new_value, |
||||
const_cast<Atomic32*>(ptr))); |
||||
return old_value; |
||||
} |
||||
|
||||
inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, |
||||
Atomic32 increment) { |
||||
return OSAtomicAdd32(increment, const_cast<Atomic32*>(ptr)); |
||||
} |
||||
|
||||
inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, |
||||
Atomic32 increment) { |
||||
return OSAtomicAdd32Barrier(increment, const_cast<Atomic32*>(ptr)); |
||||
} |
||||
|
||||
inline void MemoryBarrier() { |
||||
OSMemoryBarrier(); |
||||
} |
||||
|
||||
inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value) { |
||||
Atomic32 prev_value; |
||||
do { |
||||
if (OSAtomicCompareAndSwap32Barrier(old_value, new_value, |
||||
const_cast<Atomic32*>(ptr))) { |
||||
return old_value; |
||||
} |
||||
prev_value = *ptr; |
||||
} while (prev_value == old_value); |
||||
return prev_value; |
||||
} |
||||
|
||||
inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value) { |
||||
return Acquire_CompareAndSwap(ptr, old_value, new_value); |
||||
} |
||||
|
||||
inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
*ptr = value; |
||||
} |
||||
|
||||
inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
*ptr = value; |
||||
MemoryBarrier(); |
||||
} |
||||
|
||||
inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
MemoryBarrier(); |
||||
*ptr = value; |
||||
} |
||||
|
||||
inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) { |
||||
return *ptr; |
||||
} |
||||
|
||||
inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) { |
||||
Atomic32 value = *ptr; |
||||
MemoryBarrier(); |
||||
return value; |
||||
} |
||||
|
||||
inline Atomic32 Release_Load(volatile const Atomic32* ptr) { |
||||
MemoryBarrier(); |
||||
return *ptr; |
||||
} |
||||
|
||||
#ifdef __LP64__ |
||||
|
||||
// 64-bit implementation on 64-bit platform
|
||||
|
||||
inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr, |
||||
Atomic64 old_value, |
||||
Atomic64 new_value) { |
||||
Atomic64 prev_value; |
||||
do { |
||||
if (OSAtomicCompareAndSwap64(old_value, new_value, |
||||
reinterpret_cast<volatile int64_t*>(ptr))) { |
||||
return old_value; |
||||
} |
||||
prev_value = *ptr; |
||||
} while (prev_value == old_value); |
||||
return prev_value; |
||||
} |
||||
|
||||
inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, |
||||
Atomic64 new_value) { |
||||
Atomic64 old_value; |
||||
do { |
||||
old_value = *ptr; |
||||
} while (!OSAtomicCompareAndSwap64(old_value, new_value, |
||||
reinterpret_cast<volatile int64_t*>(ptr))); |
||||
return old_value; |
||||
} |
||||
|
||||
inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, |
||||
Atomic64 increment) { |
||||
return OSAtomicAdd64(increment, reinterpret_cast<volatile int64_t*>(ptr)); |
||||
} |
||||
|
||||
inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, |
||||
Atomic64 increment) { |
||||
return OSAtomicAdd64Barrier(increment, |
||||
reinterpret_cast<volatile int64_t*>(ptr)); |
||||
} |
||||
|
||||
inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr, |
||||
Atomic64 old_value, |
||||
Atomic64 new_value) { |
||||
Atomic64 prev_value; |
||||
do { |
||||
if (OSAtomicCompareAndSwap64Barrier( |
||||
old_value, new_value, reinterpret_cast<volatile int64_t*>(ptr))) { |
||||
return old_value; |
||||
} |
||||
prev_value = *ptr; |
||||
} while (prev_value == old_value); |
||||
return prev_value; |
||||
} |
||||
|
||||
inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr, |
||||
Atomic64 old_value, |
||||
Atomic64 new_value) { |
||||
// The lib kern interface does not distinguish between
|
||||
// Acquire and Release memory barriers; they are equivalent.
|
||||
return Acquire_CompareAndSwap(ptr, old_value, new_value); |
||||
} |
||||
|
||||
inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) { |
||||
*ptr = value; |
||||
} |
||||
|
||||
inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) { |
||||
*ptr = value; |
||||
MemoryBarrier(); |
||||
} |
||||
|
||||
inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) { |
||||
MemoryBarrier(); |
||||
*ptr = value; |
||||
} |
||||
|
||||
inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) { |
||||
return *ptr; |
||||
} |
||||
|
||||
inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) { |
||||
Atomic64 value = *ptr; |
||||
MemoryBarrier(); |
||||
return value; |
||||
} |
||||
|
||||
inline Atomic64 Release_Load(volatile const Atomic64* ptr) { |
||||
MemoryBarrier(); |
||||
return *ptr; |
||||
} |
||||
|
||||
#endif // defined(__LP64__)
|
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_MACOSX_H_
|
||||
@ -0,0 +1,413 @@ |
||||
// 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: laszlocsomor@google.com (Laszlo Csomor)
|
||||
//
|
||||
// Implementation for long-path-aware open/mkdir/access/etc. on Windows, as well
|
||||
// as for the supporting utility functions.
|
||||
//
|
||||
// These functions convert the input path to an absolute Windows path
|
||||
// with "\\?\" prefix, then pass that to _wopen/_wmkdir/_waccess/etc.
|
||||
// (declared in <io.h>) respectively. This allows working with files/directories
|
||||
// whose paths are longer than MAX_PATH (260 chars).
|
||||
//
|
||||
// This file is only used on Windows, it's empty on other platforms.
|
||||
|
||||
#if defined(_WIN32) |
||||
|
||||
// Comment this out to fall back to using the ANSI versions (open, mkdir, ...)
|
||||
// instead of the Unicode ones (_wopen, _wmkdir, ...). Doing so can be useful to
|
||||
// debug failing tests if that's caused by the long path support.
|
||||
#define SUPPORT_LONGPATHS |
||||
|
||||
#include <ctype.h> |
||||
#include <direct.h> |
||||
#include <errno.h> |
||||
#include <fcntl.h> |
||||
#include <io.h> |
||||
#include <sys/stat.h> |
||||
#include <sys/types.h> |
||||
#include <wctype.h> |
||||
#include <windows.h> |
||||
|
||||
#include <google/protobuf/stubs/io_win32.h> |
||||
#include <google/protobuf/stubs/scoped_ptr.h> |
||||
|
||||
#include <memory> |
||||
#include <sstream> |
||||
#include <string> |
||||
#include <vector> |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
namespace win32 { |
||||
namespace { |
||||
|
||||
using std::string; |
||||
using std::wstring; |
||||
|
||||
template <typename char_type> |
||||
struct CharTraits { |
||||
static bool is_alpha(char_type ch); |
||||
}; |
||||
|
||||
template <> |
||||
struct CharTraits<char> { |
||||
static bool is_alpha(char ch) { return isalpha(ch); } |
||||
}; |
||||
|
||||
template <> |
||||
struct CharTraits<wchar_t> { |
||||
static bool is_alpha(wchar_t ch) { return iswalpha(ch); } |
||||
}; |
||||
|
||||
template <typename char_type> |
||||
bool null_or_empty(const char_type* s) { |
||||
return s == nullptr || *s == 0; |
||||
} |
||||
|
||||
// Returns true if the path starts with a drive letter, e.g. "c:".
|
||||
// Note that this won't check for the "\" after the drive letter, so this also
|
||||
// returns true for "c:foo" (which is "c:\${PWD}\foo").
|
||||
// This check requires that a path not have a longpath prefix ("\\?\").
|
||||
template <typename char_type> |
||||
bool has_drive_letter(const char_type* ch) { |
||||
return CharTraits<char_type>::is_alpha(ch[0]) && ch[1] == ':'; |
||||
} |
||||
|
||||
// Returns true if the path starts with a longpath prefix ("\\?\").
|
||||
template <typename char_type> |
||||
bool has_longpath_prefix(const char_type* path) { |
||||
return path[0] == '\\' && path[1] == '\\' && path[2] == '?' && |
||||
path[3] == '\\'; |
||||
} |
||||
|
||||
template <typename char_type> |
||||
bool is_separator(char_type c) { |
||||
return c == '/' || c == '\\'; |
||||
} |
||||
|
||||
// Returns true if the path starts with a drive specifier (e.g. "c:\").
|
||||
template <typename char_type> |
||||
bool is_path_absolute(const char_type* path) { |
||||
return has_drive_letter(path) && is_separator(path[2]); |
||||
} |
||||
|
||||
template <typename char_type> |
||||
bool is_drive_relative(const char_type* path) { |
||||
return has_drive_letter(path) && (path[2] == 0 || !is_separator(path[2])); |
||||
} |
||||
|
||||
wstring join_paths(const wstring& path1, const wstring& path2) { |
||||
if (path1.empty() || is_path_absolute(path2.c_str()) || |
||||
has_longpath_prefix(path2.c_str())) { |
||||
return path2; |
||||
} |
||||
if (path2.empty()) { |
||||
return path1; |
||||
} |
||||
|
||||
if (is_separator(path1[path1.size() - 1])) { |
||||
return is_separator(path2[0]) ? (path1 + path2.substr(1)) |
||||
: (path1 + path2); |
||||
} else { |
||||
return is_separator(path2[0]) ? (path1 + path2) |
||||
: (path1 + L'\\' + path2); |
||||
} |
||||
} |
||||
|
||||
wstring normalize(wstring path) { |
||||
if (has_longpath_prefix(path.c_str())) { |
||||
path = path.substr(4); |
||||
} |
||||
|
||||
static const wstring dot(L"."); |
||||
static const wstring dotdot(L".."); |
||||
|
||||
std::vector<wstring> segments; |
||||
int segment_start = -1; |
||||
// Find the path segments in `path` (separated by "/").
|
||||
for (int i = 0;; ++i) { |
||||
if (!is_separator(path[i]) && path[i] != L'\0') { |
||||
// The current character does not end a segment, so start one unless it's
|
||||
// already started.
|
||||
if (segment_start < 0) { |
||||
segment_start = i; |
||||
} |
||||
} else if (segment_start >= 0 && i > segment_start) { |
||||
// The current character is "/" or "\0", so this ends a segment.
|
||||
// Add that to `segments` if there's anything to add; handle "." and "..".
|
||||
wstring segment(path, segment_start, i - segment_start); |
||||
segment_start = -1; |
||||
if (segment == dotdot) { |
||||
if (!segments.empty() && |
||||
(!has_drive_letter(segments[0].c_str()) || segments.size() > 1)) { |
||||
segments.pop_back(); |
||||
} |
||||
} else if (segment != dot && !segment.empty()) { |
||||
segments.push_back(segment); |
||||
} |
||||
} |
||||
if (path[i] == L'\0') { |
||||
break; |
||||
} |
||||
} |
||||
|
||||
// Handle the case when `path` is just a drive specifier (or some degenerate
|
||||
// form of it, e.g. "c:\..").
|
||||
if (segments.size() == 1 && segments[0].size() == 2 && |
||||
has_drive_letter(segments[0].c_str())) { |
||||
return segments[0] + L'\\'; |
||||
} |
||||
|
||||
// Join all segments.
|
||||
bool first = true; |
||||
std::wstringstream result; |
||||
for (int i = 0; i < segments.size(); ++i) { |
||||
if (!first) { |
||||
result << L'\\'; |
||||
} |
||||
first = false; |
||||
result << segments[i]; |
||||
} |
||||
// Preserve trailing separator if the input contained it.
|
||||
if (!path.empty() && is_separator(path[path.size() - 1])) { |
||||
result << L'\\'; |
||||
} |
||||
return result.str(); |
||||
} |
||||
|
||||
bool as_windows_path(const char* path, wstring* result) { |
||||
if (null_or_empty(path)) { |
||||
result->clear(); |
||||
return true; |
||||
} |
||||
wstring wpath; |
||||
if (!strings::utf8_to_wcs(path, &wpath)) { |
||||
return false; |
||||
} |
||||
if (has_longpath_prefix(wpath.c_str())) { |
||||
*result = wpath; |
||||
return true; |
||||
} |
||||
if (is_separator(path[0]) || is_drive_relative(path)) { |
||||
return false; |
||||
} |
||||
|
||||
|
||||
if (!is_path_absolute(wpath.c_str())) { |
||||
int size = ::GetCurrentDirectoryW(0, NULL); |
||||
if (size == 0 && GetLastError() != ERROR_INSUFFICIENT_BUFFER) { |
||||
return false; |
||||
} |
||||
scoped_array<WCHAR> wcwd(new WCHAR[size]); |
||||
::GetCurrentDirectoryW(size, wcwd.get()); |
||||
wpath = join_paths(wcwd.get(), wpath); |
||||
} |
||||
wpath = normalize(wpath); |
||||
if (!has_longpath_prefix(wpath.c_str())) { |
||||
// Add the "\\?\" prefix unconditionally. This way we prevent the Win32 API
|
||||
// from processing the path and "helpfully" removing trailing dots from the
|
||||
// path, for example.
|
||||
// See https://github.com/bazelbuild/bazel/issues/2935
|
||||
wpath = wstring(L"\\\\?\\") + wpath; |
||||
} |
||||
*result = wpath; |
||||
return true; |
||||
} |
||||
|
||||
} // namespace
|
||||
|
||||
int open(const char* path, int flags, int mode) { |
||||
#ifdef SUPPORT_LONGPATHS |
||||
wstring wpath; |
||||
if (!as_windows_path(path, &wpath)) { |
||||
errno = ENOENT; |
||||
return -1; |
||||
} |
||||
return ::_wopen(wpath.c_str(), flags, mode); |
||||
#else |
||||
return ::_open(path, flags, mode); |
||||
#endif |
||||
} |
||||
|
||||
int mkdir(const char* path, int _mode) { |
||||
#ifdef SUPPORT_LONGPATHS |
||||
wstring wpath; |
||||
if (!as_windows_path(path, &wpath)) { |
||||
errno = ENOENT; |
||||
return -1; |
||||
} |
||||
return ::_wmkdir(wpath.c_str()); |
||||
#else // not SUPPORT_LONGPATHS
|
||||
return ::_mkdir(path); |
||||
#endif // not SUPPORT_LONGPATHS
|
||||
} |
||||
|
||||
int access(const char* path, int mode) { |
||||
#ifdef SUPPORT_LONGPATHS |
||||
wstring wpath; |
||||
if (!as_windows_path(path, &wpath)) { |
||||
errno = ENOENT; |
||||
return -1; |
||||
} |
||||
return ::_waccess(wpath.c_str(), mode); |
||||
#else |
||||
return ::_access(path, mode); |
||||
#endif |
||||
} |
||||
|
||||
int chdir(const char* path) { |
||||
#ifdef SUPPORT_LONGPATHS |
||||
wstring wpath; |
||||
if (!as_windows_path(path, &wpath)) { |
||||
errno = ENOENT; |
||||
return -1; |
||||
} |
||||
return ::_wchdir(wpath.c_str()); |
||||
#else |
||||
return ::_chdir(path); |
||||
#endif |
||||
} |
||||
|
||||
int stat(const char* path, struct _stat* buffer) { |
||||
#ifdef SUPPORT_LONGPATHS |
||||
wstring wpath; |
||||
if (!as_windows_path(path, &wpath)) { |
||||
errno = ENOENT; |
||||
return -1; |
||||
} |
||||
return ::_wstat(wpath.c_str(), buffer); |
||||
#else // not SUPPORT_LONGPATHS
|
||||
return ::_stat(path, buffer); |
||||
#endif // not SUPPORT_LONGPATHS
|
||||
} |
||||
|
||||
FILE* fopen(const char* path, const char* mode) { |
||||
#ifdef SUPPORT_LONGPATHS |
||||
if (null_or_empty(path)) { |
||||
errno = EINVAL; |
||||
return NULL; |
||||
} |
||||
wstring wpath; |
||||
if (!as_windows_path(path, &wpath)) { |
||||
errno = ENOENT; |
||||
return NULL; |
||||
} |
||||
wstring wmode; |
||||
if (!strings::utf8_to_wcs(mode, &wmode)) { |
||||
errno = EINVAL; |
||||
return NULL; |
||||
} |
||||
return ::_wfopen(wpath.c_str(), wmode.c_str()); |
||||
#else |
||||
return ::fopen(path, mode); |
||||
#endif |
||||
} |
||||
|
||||
int close(int fd) { return ::close(fd); } |
||||
|
||||
int dup(int fd) { return ::_dup(fd); } |
||||
|
||||
int dup2(int fd1, int fd2) { return ::_dup2(fd1, fd2); } |
||||
|
||||
int read(int fd, void* buffer, size_t size) { |
||||
return ::_read(fd, buffer, size); |
||||
} |
||||
|
||||
int setmode(int fd, int mode) { return ::_setmode(fd, mode); } |
||||
|
||||
int write(int fd, const void* buffer, size_t size) { |
||||
return ::_write(fd, buffer, size); |
||||
} |
||||
|
||||
wstring testonly_utf8_to_winpath(const char* path) { |
||||
wstring wpath; |
||||
return as_windows_path(path, &wpath) ? wpath : wstring(); |
||||
} |
||||
|
||||
namespace strings { |
||||
|
||||
bool wcs_to_mbs(const WCHAR* s, string* out, bool outUtf8) { |
||||
if (null_or_empty(s)) { |
||||
out->clear(); |
||||
return true; |
||||
} |
||||
BOOL usedDefaultChar = FALSE; |
||||
SetLastError(0); |
||||
int size = WideCharToMultiByte( |
||||
outUtf8 ? CP_UTF8 : CP_ACP, 0, s, -1, NULL, 0, NULL, |
||||
outUtf8 ? NULL : &usedDefaultChar); |
||||
if ((size == 0 && GetLastError() != ERROR_INSUFFICIENT_BUFFER) |
||||
|| usedDefaultChar) { |
||||
return false; |
||||
} |
||||
scoped_array<CHAR> astr(new CHAR[size]); |
||||
WideCharToMultiByte( |
||||
outUtf8 ? CP_UTF8 : CP_ACP, 0, s, -1, astr.get(), size, NULL, NULL); |
||||
out->assign(astr.get()); |
||||
return true; |
||||
} |
||||
|
||||
bool mbs_to_wcs(const char* s, wstring* out, bool inUtf8) { |
||||
if (null_or_empty(s)) { |
||||
out->clear(); |
||||
return true; |
||||
} |
||||
|
||||
SetLastError(0); |
||||
int size = |
||||
MultiByteToWideChar(inUtf8 ? CP_UTF8 : CP_ACP, 0, s, -1, NULL, 0); |
||||
if (size == 0 && GetLastError() != ERROR_INSUFFICIENT_BUFFER) { |
||||
return false; |
||||
} |
||||
scoped_array<WCHAR> wstr(new WCHAR[size]); |
||||
MultiByteToWideChar( |
||||
inUtf8 ? CP_UTF8 : CP_ACP, 0, s, -1, wstr.get(), size + 1); |
||||
out->assign(wstr.get()); |
||||
return true; |
||||
} |
||||
|
||||
bool utf8_to_wcs(const char* input, wstring* out) { |
||||
return mbs_to_wcs(input, out, true); |
||||
} |
||||
|
||||
bool wcs_to_utf8(const wchar_t* input, string* out) { |
||||
return wcs_to_mbs(input, out, true); |
||||
} |
||||
|
||||
} // namespace strings
|
||||
} // namespace win32
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // defined(_WIN32)
|
||||
@ -0,0 +1,115 @@ |
||||
// 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: laszlocsomor@google.com (Laszlo Csomor)
|
||||
//
|
||||
// This file contains the declarations for Windows implementations of
|
||||
// commonly used POSIX functions such as open(2) and access(2), as well
|
||||
// as macro definitions for flags of these functions.
|
||||
//
|
||||
// By including this file you'll redefine open/access/etc. to
|
||||
// ::google::protobuf::internal::win32::{open/access/etc.}.
|
||||
// Make sure you don't include a header that attempts to redeclare or
|
||||
// redefine these functions, that'll lead to confusing compilation
|
||||
// errors. It's best to #include this file as the last one to ensure that.
|
||||
//
|
||||
// This file is only used on Windows, it's empty on other platforms.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_STUBS_IO_WIN32_H__ |
||||
#define GOOGLE_PROTOBUF_STUBS_IO_WIN32_H__ |
||||
|
||||
#if defined(_WIN32) |
||||
|
||||
#include <string> |
||||
#include <google/protobuf/stubs/port.h> |
||||
|
||||
// Compilers on Windows other than MSVC (e.g. Cygwin, MinGW32) define the
|
||||
// following functions already, except for mkdir.
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
namespace win32 { |
||||
|
||||
LIBPROTOBUF_EXPORT FILE* fopen(const char* path, const char* mode); |
||||
LIBPROTOBUF_EXPORT int access(const char* path, int mode); |
||||
LIBPROTOBUF_EXPORT int chdir(const char* path); |
||||
LIBPROTOBUF_EXPORT int close(int fd); |
||||
LIBPROTOBUF_EXPORT int dup(int fd); |
||||
LIBPROTOBUF_EXPORT int dup2(int fd1, int fd2); |
||||
LIBPROTOBUF_EXPORT int mkdir(const char* path, int _mode); |
||||
LIBPROTOBUF_EXPORT int open(const char* path, int flags, int mode = 0); |
||||
LIBPROTOBUF_EXPORT int read(int fd, void* buffer, size_t size); |
||||
LIBPROTOBUF_EXPORT int setmode(int fd, int mode); |
||||
LIBPROTOBUF_EXPORT int stat(const char* path, struct _stat* buffer); |
||||
LIBPROTOBUF_EXPORT int write(int fd, const void* buffer, size_t size); |
||||
LIBPROTOBUF_EXPORT std::wstring testonly_utf8_to_winpath(const char* path); |
||||
|
||||
namespace strings { |
||||
|
||||
// Convert from UTF-16 to Active-Code-Page-encoded or to UTF-8-encoded text.
|
||||
LIBPROTOBUF_EXPORT bool wcs_to_mbs( |
||||
const wchar_t* s, std::string* out, bool outUtf8); |
||||
|
||||
// Convert from Active-Code-Page-encoded or UTF-8-encoded text to UTF-16.
|
||||
LIBPROTOBUF_EXPORT bool mbs_to_wcs( |
||||
const char* s, std::wstring* out, bool inUtf8); |
||||
|
||||
// Convert from UTF-8-encoded text to UTF-16.
|
||||
LIBPROTOBUF_EXPORT bool utf8_to_wcs(const char* input, std::wstring* out); |
||||
|
||||
// Convert from UTF-16-encoded text to UTF-8.
|
||||
LIBPROTOBUF_EXPORT bool wcs_to_utf8(const wchar_t* input, std::string* out); |
||||
|
||||
} // namespace strings
|
||||
|
||||
} // namespace win32
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#ifndef W_OK |
||||
#define W_OK 02 // not defined by MSVC for whatever reason
|
||||
#endif |
||||
|
||||
#ifndef F_OK |
||||
#define F_OK 00 // not defined by MSVC for whatever reason
|
||||
#endif |
||||
|
||||
#ifndef STDIN_FILENO |
||||
#define STDIN_FILENO 0 |
||||
#endif |
||||
|
||||
#ifndef STDOUT_FILENO |
||||
#define STDOUT_FILENO 1 |
||||
#endif |
||||
|
||||
#endif // defined(_WIN32)
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_STUBS_IO_WIN32_H__
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue