diff options
Diffstat (limited to 'NorthstarDedicatedTest/include/protobuf/port_def.inc')
| -rw-r--r-- | NorthstarDedicatedTest/include/protobuf/port_def.inc | 824 |
1 files changed, 824 insertions, 0 deletions
diff --git a/NorthstarDedicatedTest/include/protobuf/port_def.inc b/NorthstarDedicatedTest/include/protobuf/port_def.inc new file mode 100644 index 00000000..37632cf5 --- /dev/null +++ b/NorthstarDedicatedTest/include/protobuf/port_def.inc @@ -0,0 +1,824 @@ +// 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 common macros that are used in protobuf. +// +// To hide these definitions from the outside world (and to prevent collisions +// if more than one version of protobuf is #included in the same project) you +// must follow this pattern when #including port_def.inc in a header file: +// +// #include "other_header.h" +// #include "message.h" +// // etc. +// +// #include "port_def.inc" // MUST be last header included +// +// // Definitions for this header. +// +// #include "port_undef.inc" +// +// This is a textual header with no include guard, because we want to +// detect/prohibit anytime it is #included twice without a corresponding +// #undef. + +// The definitions in this file are intended to be portable across Clang, +// GCC, and MSVC. Function-like macros are usable without an #ifdef guard. +// Syntax macros (for example, attributes) are always defined, although +// they may be empty. +// +// Some definitions rely on the NDEBUG macro and/or (in MSVC) _DEBUG: +// - https://en.cppreference.com/w/c/error/assert +// - https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros#microsoft-specific-predefined-macros +// +// References for predefined macros: +// - Standard: https://en.cppreference.com/w/cpp/preprocessor/replace +// - Clang: https://clang.llvm.org/docs/LanguageExtensions.html +// (see also GCC predefined macros) +// - GCC: https://gcc.gnu.org/onlinedocs/cpp/Predefined-Macros.html +// - MSVC: https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros +// - Interactive (Clang/GCC only): https://www.compiler-explorer.com/z/hc6jKd3sj +// +// References for attributes (and extension attributes): +// - Standard: https://en.cppreference.com/w/cpp/language/attributes +// - Clang: https://clang.llvm.org/docs/AttributeReference.html +// - GCC: https://gcc.gnu.org/onlinedocs/gcc/Attribute-Syntax.html +// (see Clang attribute docs as well) +// +// References for standard C++ language conformance (and minimum versions): +// - Clang: https://clang.llvm.org/cxx_status.html +// - GCC: https://gcc.gnu.org/projects/cxx-status.html +// - MSVC: https://docs.microsoft.com/en-us/cpp/overview/visual-cpp-language-conformance +// +// Historical release notes (which can help to determine minimum versions): +// - Clang: https://releases.llvm.org/ +// - GCC: https://gcc.gnu.org/releases.html +// - MSVC: https://docs.microsoft.com/en-us/visualstudio/releases/2019/release-notes-history +// https://docs.microsoft.com/en-us/visualstudio/releasenotes/vs2017-relnotes-history + +// Portable fallbacks for C++20 feature test macros: +// https://en.cppreference.com/w/cpp/feature_test +#ifndef __has_cpp_attribute +#define __has_cpp_attribute(x) 0 +#define PROTOBUF_has_cpp_attribute_DEFINED_ +#endif + +// Portable fallback for Clang's __has_feature macro: +// https://clang.llvm.org/docs/LanguageExtensions.html#has-feature-and-has-extension +#ifndef __has_feature +#define __has_feature(x) 0 +#define PROTOBUF_has_feature_DEFINED_ +#endif + +// Portable fallback for Clang's __has_warning macro: +#ifndef __has_warning +#define __has_warning(x) 0 +#define PROTOBUF_has_warning_DEFINED_ +#endif + +// Portable fallbacks for the __has_attribute macro (GCC and Clang): +// https://clang.llvm.org/docs/LanguageExtensions.html#has-attribute +// https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005fattribute.html +#ifndef __has_attribute +#define __has_attribute(x) 0 +#define PROTOBUF_has_attribute_DEFINED_ +#endif + +// Portable fallback for __has_builtin (GCC and Clang): +// https://clang.llvm.org/docs/LanguageExtensions.html#has-builtin +// https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005fbuiltin.html +#ifndef __has_builtin +#define __has_builtin(x) 0 +#define PROTOBUF_has_builtin_DEFINED_ +#endif + +// Portable check for GCC minimum version: +// https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html +#if defined(__GNUC__) && defined(__GNUC_MINOR__) \ + && defined(__GNUC_PATCHLEVEL__) +# define PROTOBUF_GNUC_MIN(x, y) \ + (__GNUC__ > (x) || __GNUC__ == (x) && __GNUC_MINOR__ >= (y)) +#else +# define PROTOBUF_GNUC_MIN(x, y) 0 +#endif + +// Portable check for MSVC minimum version: +// https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros +#if defined(_MSC_VER) +#define PROTOBUF_MSC_VER_MIN(x) (_MSC_VER >= x) +#else +#define PROTOBUF_MSC_VER_MIN(x) 0 +#endif + +// Portable check for minimum C++ language version: +// https://en.cppreference.com/w/cpp/preprocessor/replace +// https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros +#if !defined(_MSVC_LANG) +#define PROTOBUF_CPLUSPLUS_MIN(x) (__cplusplus >= x) +#else +#define PROTOBUF_CPLUSPLUS_MIN(x) (_MSVC_LANG >= x) +#endif + +// Future versions of protobuf will include breaking changes to some APIs. +// This macro can be set to enable these API changes ahead of time, so that +// user code can be updated before upgrading versions of protobuf. +// #define PROTOBUF_FUTURE_BREAKING_CHANGES 1 + +#ifdef PROTOBUF_VERSION +#error PROTOBUF_VERSION was previously defined +#endif +#define PROTOBUF_VERSION 3019004 + +#ifdef PROTOBUF_MIN_HEADER_VERSION_FOR_PROTOC +#error PROTOBUF_MIN_HEADER_VERSION_FOR_PROTOC was previously defined +#endif +#define PROTOBUF_MIN_HEADER_VERSION_FOR_PROTOC 3019000 + +#ifdef PROTOBUF_MIN_PROTOC_VERSION +#error PROTOBUF_MIN_PROTOC_VERSION was previously defined +#endif +#define PROTOBUF_MIN_PROTOC_VERSION 3019000 + +#ifdef PROTOBUF_VERSION_SUFFIX +#error PROTOBUF_VERSION_SUFFIX was previously defined +#endif +#define PROTOBUF_VERSION_SUFFIX "" + +#if defined(PROTOBUF_NAMESPACE) || defined(PROTOBUF_NAMESPACE_ID) +#error PROTOBUF_NAMESPACE or PROTOBUF_NAMESPACE_ID was previously defined +#endif +#define PROTOBUF_NAMESPACE "google::protobuf" +#define PROTOBUF_NAMESPACE_ID google::protobuf +#define PROTOBUF_NAMESPACE_OPEN \ + namespace google { \ + namespace protobuf { +#define PROTOBUF_NAMESPACE_CLOSE \ + } /* namespace protobuf */ \ + } /* namespace google */ + +#ifdef PROTOBUF_ALWAYS_INLINE +#error PROTOBUF_ALWAYS_INLINE was previously defined +#endif +// For functions we want to force inline. +#if defined(PROTOBUF_NO_INLINE) +# define PROTOBUF_ALWAYS_INLINE +#elif PROTOBUF_GNUC_MIN(3, 1) +# define PROTOBUF_ALWAYS_INLINE __attribute__((always_inline)) +#elif defined(_MSC_VER) +# define PROTOBUF_ALWAYS_INLINE __forceinline +#else +# define PROTOBUF_ALWAYS_INLINE +#endif + +#ifdef PROTOBUF_NDEBUG_INLINE +#error PROTOBUF_NDEBUG_INLINE was previously defined +#endif +// Avoid excessive inlining in non-optimized builds. Without other optimizations +// the inlining is not going to provide benefits anyway and the huge resulting +// functions, especially in the proto-generated serialization functions, produce +// stack frames so large that many tests run into stack overflows (b/32192897). +#if defined(NDEBUG) || (defined(_MSC_VER) && !defined(_DEBUG)) +# define PROTOBUF_NDEBUG_INLINE PROTOBUF_ALWAYS_INLINE +#else +# define PROTOBUF_NDEBUG_INLINE +#endif + +// Note that PROTOBUF_NOINLINE is an attribute applied to functions, to prevent +// them from being inlined by the compiler. This is different from +// PROTOBUF_NO_INLINE, which is a user-supplied macro that disables forced +// inlining by PROTOBUF_(ALWAYS|NDEBUG)_INLINE. +#ifdef PROTOBUF_NOINLINE +#error PROTOBUF_NOINLINE was previously defined +#endif +#if PROTOBUF_GNUC_MIN(3, 1) +# define PROTOBUF_NOINLINE __attribute__((noinline)) +#elif defined(_MSC_VER) +// Seems to have been around since at least Visual Studio 2005 +# define PROTOBUF_NOINLINE __declspec(noinline) +#endif + +#ifdef PROTOBUF_MUSTTAIL +#error PROTOBUF_MUSTTAIL was previously defined +#endif +#ifdef PROTOBUF_TAILCALL +#error PROTOBUF_TAILCALL was previously defined +#endif +#if __has_cpp_attribute(clang::musttail) && \ + !defined(__arm__) && !defined(_ARCH_PPC) && !defined(__wasm__) +# ifndef PROTO2_OPENSOURCE +// Compilation fails on ARM32: b/195943306 +// Compilation fails on powerpc64le: b/187985113 +# endif +#define PROTOBUF_MUSTTAIL [[clang::musttail]] +#define PROTOBUF_TAILCALL true +#else +#define PROTOBUF_MUSTTAIL +#define PROTOBUF_TAILCALL false +#endif + +#ifdef PROTOBUF_EXCLUSIVE_LOCKS_REQUIRED +#error PROTOBUF_EXCLUSIVE_LOCKS_REQUIRED was previously defined +#endif +#if __has_attribute(exclusive_locks_required) +#define PROTOBUF_EXCLUSIVE_LOCKS_REQUIRED(...) \ + __attribute__((exclusive_locks_required(__VA_ARGS__))) +#else +#define PROTOBUF_EXCLUSIVE_LOCKS_REQUIRED(...) +#endif + +#ifdef PROTOBUF_NO_THREAD_SAFETY_ANALYSIS +#error PROTOBUF_NO_THREAD_SAFETY_ANALYSIS was previously defined +#endif +#if __has_attribute(no_thread_safety_analysis) +#define PROTOBUF_NO_THREAD_SAFETY_ANALYSIS \ + __attribute__((no_thread_safety_analysis)) +#else +#define PROTOBUF_NO_THREAD_SAFETY_ANALYSIS +#endif + +#ifdef PROTOBUF_GUARDED_BY +#error PROTOBUF_GUARDED_BY was previously defined +#endif +#if __has_attribute(guarded_by) +#define PROTOBUF_GUARDED_BY(x) __attribute__((guarded_by(x))) +#else +#define PROTOBUF_GUARDED_BY(x) +#endif + +#ifdef PROTOBUF_LOCKS_EXCLUDED +#error PROTOBUF_LOCKS_EXCLUDED was previously defined +#endif +#if __has_attribute(locks_excluded) +#define PROTOBUF_LOCKS_EXCLUDED(...) \ + __attribute__((locks_excluded(__VA_ARGS__))) +#else +#define PROTOBUF_LOCKS_EXCLUDED(...) +#endif + +#ifdef PROTOBUF_COLD +#error PROTOBUF_COLD was previously defined +#endif +#if __has_attribute(cold) || PROTOBUF_GNUC_MIN(4, 3) +# define PROTOBUF_COLD __attribute__((cold)) +#else +# define PROTOBUF_COLD +#endif + +#ifdef PROTOBUF_SECTION_VARIABLE +#error PROTOBUF_SECTION_VARIABLE was previously defined +#endif +#if (__has_attribute(section) || defined(__GNUC__)) && defined(__ELF__) +// Place a variable in the given ELF section. +# define PROTOBUF_SECTION_VARIABLE(x) __attribute__((section(#x))) +#else +# define PROTOBUF_SECTION_VARIABLE(x) +#endif + +#if defined(PROTOBUF_DEPRECATED) +#error PROTOBUF_DEPRECATED was previously defined +#endif +#if defined(PROTOBUF_DEPRECATED_MSG) +#error PROTOBUF_DEPRECATED_MSG was previously defined +#endif +#if __has_attribute(deprecated) || PROTOBUF_GNUC_MIN(3, 0) +# define PROTOBUF_DEPRECATED __attribute__((deprecated)) +# define PROTOBUF_DEPRECATED_MSG(msg) __attribute__((deprecated(msg))) +#elif defined(_MSC_VER) +# define PROTOBUF_DEPRECATED __declspec(deprecated) +# define PROTOBUF_DEPRECATED_MSG(msg) __declspec(deprecated(msg)) +#else +# define PROTOBUF_DEPRECATED +# define PROTOBUF_DEPRECATED_MSG(msg) +#endif + +#if defined(PROTOBUF_DEPRECATED_ENUM) +#error PROTOBUF_DEPRECATED_ENUM was previously defined +#endif +#if defined(__clang__) || PROTOBUF_GNUC_MIN(6, 0) +// https://gcc.gnu.org/gcc-6/changes.html +# define PROTOBUF_DEPRECATED_ENUM __attribute__((deprecated)) +#else +# define PROTOBUF_DEPRECATED_ENUM +#endif + +#ifdef PROTOBUF_FUNC_ALIGN +#error PROTOBUF_FUNC_ALIGN was previously defined +#endif +#if __has_attribute(aligned) || PROTOBUF_GNUC_MIN(4, 3) +#define PROTOBUF_FUNC_ALIGN(bytes) __attribute__((aligned(bytes))) +#else +#define PROTOBUF_FUNC_ALIGN(bytes) +#endif + +#ifdef PROTOBUF_RETURNS_NONNULL +#error PROTOBUF_RETURNS_NONNULL was previously defined +#endif +#if __has_attribute(returns_nonnull) || PROTOBUF_GNUC_MIN(4, 9) +#define PROTOBUF_RETURNS_NONNULL __attribute__((returns_nonnull)) +#else +#define PROTOBUF_RETURNS_NONNULL +#endif + +#ifdef PROTOBUF_ATTRIBUTE_REINITIALIZES +#error PROTOBUF_ATTRIBUTE_REINITIALIZES was previously defined +#endif +#if __has_cpp_attribute(clang::reinitializes) +#define PROTOBUF_ATTRIBUTE_REINITIALIZES [[clang::reinitializes]] +#else +#define PROTOBUF_ATTRIBUTE_REINITIALIZES +#endif + +// The minimum library version which works with the current version of the +// headers. +#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3019000 + +#ifdef PROTOBUF_RTTI +#error PROTOBUF_RTTI was previously defined +#endif +#if defined(GOOGLE_PROTOBUF_NO_RTTI) && GOOGLE_PROTOBUF_NO_RTTI +#define PROTOBUF_RTTI 0 +#elif __has_feature(cxx_rtti) +#define PROTOBUF_RTTI 1 +#elif defined(__cxx_rtti) +// https://en.cppreference.com/w/User:D41D8CD98F/feature_testing_macros#C.2B.2B98 +#define PROTOBUF_RTTI 1 +#else +#define PROTOBUF_RTTI 0 +#endif + +// Returns the offset of the given field within the given aggregate type. +// This is equivalent to the ANSI C offsetof() macro. However, according +// to the C++ standard, offsetof() only works on POD types, and GCC +// enforces this requirement with a warning. In practice, this rule is +// unnecessarily strict; there is probably no compiler or platform on +// which the offsets of the direct fields of a class are non-constant. +// Fields inherited from superclasses *can* have non-constant offsets, +// but that's not what this macro will be used for. +#ifdef PROTOBUF_FIELD_OFFSET +#error PROTOBUF_FIELD_OFFSET was previously defined +#endif +#if defined(__clang__) +// For Clang we use __builtin_offsetof() and suppress the warning, +// to avoid Control Flow Integrity and UBSan vptr sanitizers from +// crashing while trying to validate the invalid reinterpret_casts. +#define PROTOBUF_FIELD_OFFSET(TYPE, FIELD) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ + __builtin_offsetof(TYPE, FIELD) \ + _Pragma("clang diagnostic pop") +#elif PROTOBUF_GNUC_MIN(4, 8) +#define PROTOBUF_FIELD_OFFSET(TYPE, FIELD) __builtin_offsetof(TYPE, FIELD) +#else // defined(__clang__) +// Note that we calculate relative to the pointer value 16 here since if we +// just use zero, GCC complains about dereferencing a NULL pointer. We +// choose 16 rather than some other number just in case the compiler would +// be confused by an unaligned pointer. +#define PROTOBUF_FIELD_OFFSET(TYPE, FIELD) \ + static_cast< ::uint32_t>(reinterpret_cast<const char*>( \ + &reinterpret_cast<const TYPE*>(16)->FIELD) - \ + reinterpret_cast<const char*>(16)) +#endif + +#ifdef PROTOBUF_EXPORT +#error PROTOBUF_EXPORT was previously defined +#endif + +#if defined(PROTOBUF_USE_DLLS) && defined(_MSC_VER) +# if defined(LIBPROTOBUF_EXPORTS) +# define PROTOBUF_EXPORT __declspec(dllexport) +# define PROTOBUF_EXPORT_TEMPLATE_DECLARE +# define PROTOBUF_EXPORT_TEMPLATE_DEFINE __declspec(dllexport) +# else +# define PROTOBUF_EXPORT __declspec(dllimport) +# define PROTOBUF_EXPORT_TEMPLATE_DECLARE +# define PROTOBUF_EXPORT_TEMPLATE_DEFINE __declspec(dllimport) +# endif // defined(LIBPROTOBUF_EXPORTS) +#elif defined(PROTOBUF_USE_DLLS) && defined(LIBPROTOBUF_EXPORTS) +# define PROTOBUF_EXPORT __attribute__((visibility("default"))) +# define PROTOBUF_EXPORT_TEMPLATE_DECLARE __attribute__((visibility("default"))) +# define PROTOBUF_EXPORT_TEMPLATE_DEFINE +#else +# define PROTOBUF_EXPORT +# define PROTOBUF_EXPORT_TEMPLATE_DECLARE +# define PROTOBUF_EXPORT_TEMPLATE_DEFINE +#endif + +#ifdef PROTOC_EXPORT +#error PROTOC_EXPORT was previously defined +#endif + +#if defined(PROTOBUF_USE_DLLS) && defined(_MSC_VER) +# if defined(LIBPROTOC_EXPORTS) +# define PROTOC_EXPORT __declspec(dllexport) +# else +# define PROTOC_EXPORT __declspec(dllimport) +# endif // defined(LIBPROTOC_EXPORTS) +#elif defined(PROTOBUF_USE_DLLS) && defined(LIBPROTOBUF_EXPORTS) +# define PROTOC_EXPORT __attribute__((visibility("default"))) +#else +# define PROTOC_EXPORT +#endif + +#if defined(PROTOBUF_PREDICT_TRUE) || defined(PROTOBUF_PREDICT_FALSE) +#error PROTOBUF_PREDICT_(TRUE|FALSE) was previously defined +#endif +#if PROTOBUF_GNUC_MIN(3, 0) +# define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(false || (x), true)) +# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) +#else +# define PROTOBUF_PREDICT_TRUE(x) (x) +# define PROTOBUF_PREDICT_FALSE(x) (x) +#endif + +#ifdef PROTOBUF_NODISCARD +#error PROTOBUF_NODISCARD was previously defined +#endif +#if __has_cpp_attribute(nodiscard) +#define PROTOBUF_NODISCARD [[nodiscard]] +#elif __has_attribute(warn_unused_result) || PROTOBUF_GNUC_MIN(4, 8) +#define PROTOBUF_NODISCARD __attribute__((warn_unused_result)) +#else +#define PROTOBUF_NODISCARD +#endif + +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE +#error PROTOBUF_FORCE_COPY_IN_RELEASE was previously defined +#endif + +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP +#error PROTOBUF_FORCE_COPY_IN_SWAP was previously defined +#endif + +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE +#error PROTOBUF_FORCE_COPY_IN_MOVE was previously defined +#endif + +// Force copy the default string to a string field so that non-optimized builds +// have harder-to-rely-on address stability. +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING +#error PROTOBUF_FORCE_COPY_DEFAULT_STRING was previously defined +#endif + +#ifdef PROTOBUF_FALLTHROUGH_INTENDED +#error PROTOBUF_FALLTHROUGH_INTENDED was previously defined +#endif +#if __has_cpp_attribute(fallthrough) +#define PROTOBUF_FALLTHROUGH_INTENDED [[fallthrough]] +#elif __has_feature(cxx_attributes) && __has_warning("-Wimplicit-fallthrough") +#define PROTOBUF_FALLTHROUGH_INTENDED [[clang::fallthrough]] +#elif PROTOBUF_GNUC_MIN(7, 0) +#define PROTOBUF_FALLTHROUGH_INTENDED [[gnu::fallthrough]] +#else +#define PROTOBUF_FALLTHROUGH_INTENDED +#endif + +// PROTOBUF_ASSUME(pred) tells the compiler that it can assume pred is true. To +// be safe, we also validate the assumption with a GOOGLE_DCHECK in unoptimized +// builds. The macro does not do anything useful if the compiler does not +// support __builtin_assume. +#ifdef PROTOBUF_ASSUME +#error PROTOBUF_ASSUME was previously defined +#endif +#if __has_builtin(__builtin_assume) +#define PROTOBUF_ASSUME(pred) \ + GOOGLE_DCHECK(pred); \ + __builtin_assume(pred) +#else +#define PROTOBUF_ASSUME(pred) GOOGLE_DCHECK(pred) +#endif + +// Specify memory alignment for structs, classes, etc. +// Use like: +// class PROTOBUF_ALIGNAS(16) MyClass { ... } +// PROTOBUF_ALIGNAS(16) int array[4]; +// +// In most places you can use the C++11 keyword "alignas", which is preferred. +// +// But compilers have trouble mixing __attribute__((...)) syntax with +// alignas(...) syntax. +// +// Doesn't work in clang or gcc: +// struct alignas(16) __attribute__((packed)) S { char c; }; +// Works in clang but not gcc: +// struct __attribute__((packed)) alignas(16) S2 { char c; }; +// Works in clang and gcc: +// struct alignas(16) S3 { char c; } __attribute__((packed)); +// +// There are also some attributes that must be specified *before* a class +// definition: visibility (used for exporting functions/classes) is one of +// these attributes. This means that it is not possible to use alignas() with a +// class that is marked as exported. +#ifdef PROTOBUF_ALIGNAS +#error PROTOBUF_ALIGNAS was previously defined +#endif +#if defined(_MSC_VER) +#define PROTOBUF_ALIGNAS(byte_alignment) __declspec(align(byte_alignment)) +#elif PROTOBUF_GNUC_MIN(3, 0) +#define PROTOBUF_ALIGNAS(byte_alignment) \ + __attribute__((aligned(byte_alignment))) +#else +#define PROTOBUF_ALIGNAS(byte_alignment) alignas(byte_alignment) +#endif + +#ifdef PROTOBUF_FINAL +#error PROTOBUF_FINAL was previously defined +#endif +#define PROTOBUF_FINAL final + +#ifdef PROTOBUF_THREAD_LOCAL +#error PROTOBUF_THREAD_LOCAL was previously defined +#endif +#if defined(_MSC_VER) +#define PROTOBUF_THREAD_LOCAL __declspec(thread) +#else +#define PROTOBUF_THREAD_LOCAL __thread +#endif + +// For enabling message owned arena, one major blocker is semantic change from +// moving to copying when there is ownership transfer (e.g., move ctor, swap, +// set allocated, release). This change not only causes performance regression +// but also breaks users code (e.g., dangling reference). For top-level +// messages, since it owns the arena, we can mitigate the issue by transferring +// ownership of arena. However, we cannot do that for nested messages. In order +// to tell how many usages of nested messages affected by message owned arena, +// we need to simulate the arena ownership. +// This experiment is purely for the purpose of gathering data. All code guarded +// by this flag is supposed to be removed after this experiment. +#define PROTOBUF_MESSAGE_OWNED_ARENA_EXPERIMENT +#ifdef PROTOBUF_CONSTINIT +#error PROTOBUF_CONSTINIT was previously defined +#endif +#if defined(__cpp_constinit) && !PROTOBUF_GNUC_MIN(3, 0) && !defined(_MSC_VER) +// Our use of constinit does not yet work with GCC: +// https://github.com/protocolbuffers/protobuf/issues/8310 +// Does not work yet with Visual Studio 2019 Update 16.10 +#define PROTOBUF_CONSTINIT constinit +#elif !defined(_MSC_VER) && \ + __has_cpp_attribute(clang::require_constant_initialization) +#define PROTOBUF_CONSTINIT [[clang::require_constant_initialization]] +#else +#define PROTOBUF_CONSTINIT +#endif + +// Some globals with an empty non-trivial destructor are annotated with +// no_destroy for performance reasons. It reduces the cost of these globals in +// non-opt mode and under sanitizers. +#ifdef PROTOBUF_ATTRIBUTE_NO_DESTROY +#error PROTOBUF_ATTRIBUTE_NO_DESTROY was previously defined +#endif +#if __has_cpp_attribute(clang::no_destroy) +#define PROTOBUF_ATTRIBUTE_NO_DESTROY [[clang::no_destroy]] +#else +#define PROTOBUF_ATTRIBUTE_NO_DESTROY +#endif + +// Protobuf extensions and reflection require registration of the protos linked +// in the binary. Not until everything is registered does the runtime have a +// complete view on all protos. When code is using reflection or extensions +// in between registration calls this can lead to surprising behavior. By +// having the registration run first we mitigate this scenario. +// Highest priority is 101. We use 102 to allow code that really wants to +// higher priority to still beat us. +#ifdef PROTOBUF_ATTRIBUTE_INIT_PRIORITY +#error PROTOBUF_ATTRIBUTE_INIT_PRIORITY was previously defined +#endif +#if PROTOBUF_GNUC_MIN(3, 0) && (!defined(__APPLE__) || defined(__clang__)) && !((defined(sun) || defined(__sun)) && (defined(__SVR4) || defined(__svr4__))) +#define PROTOBUF_ATTRIBUTE_INIT_PRIORITY __attribute__((init_priority((102)))) +#else +#define PROTOBUF_ATTRIBUTE_INIT_PRIORITY +#endif + +#ifdef PROTOBUF_PRAGMA_INIT_SEG +#error PROTOBUF_PRAGMA_INIT_SEG was previously defined +#endif +#if _MSC_VER +#define PROTOBUF_PRAGMA_INIT_SEG __pragma(init_seg(lib)) +#else +#define PROTOBUF_PRAGMA_INIT_SEG +#endif + +#ifdef PROTOBUF_ATTRIBUTE_WEAK +#error PROTOBUF_ATTRIBUTE_WEAK was previously defined +#endif +#if __has_attribute(weak) && \ + !defined(__APPLE__) && \ + (!defined(_WIN32) || __clang_major__ < 9) && \ + !defined(__MINGW32__) +#define PROTOBUF_ATTRIBUTE_WEAK __attribute__((weak)) +#define PROTOBUF_HAVE_ATTRIBUTE_WEAK 1 +#else +#define PROTOBUF_ATTRIBUTE_WEAK +#define PROTOBUF_HAVE_ATTRIBUTE_WEAK 0 +#endif + +// Macros to detect sanitizers. +#ifdef PROTOBUF_ASAN +#error PROTOBUF_ASAN was previously defined +#endif +#ifdef PROTOBUF_MSAN +#error PROTOBUF_MSAN was previously defined +#endif +#ifdef PROTOBUF_TSAN +#error PROTOBUF_TSAN was previously defined +#endif +#if defined(__clang__) +# if __has_feature(address_sanitizer) +# define PROTOBUF_ASAN 1 +# endif +# if __has_feature(thread_sanitizer) +# define PROTOBUF_TSAN 1 +# endif +# if __has_feature(memory_sanitizer) +# define PROTOBUF_MSAN 1 +# endif +#elif PROTOBUF_GNUC_MIN(3, 0) +// Double-guard is needed for -Wundef: +# ifdef __SANITIZE_ADDRESS__ +# if __SANITIZE_ADDRESS__ +# define PROTOBUF_ASAN 1 +# endif +# endif +# ifdef __SANITIZE_THREAD__ +# if __SANITIZE_THREAD__ +# define PROTOBUF_TSAN 1 +# endif +# endif +#endif + +// Tail call table-driven parsing can be enabled by defining +// PROTOBUF_EXPERIMENTAL_USE_TAIL_CALL_TABLE_PARSER at compilation time. Note +// that this macro is for small-scale testing only, and is not supported. +#ifdef PROTOBUF_TAIL_CALL_TABLE_PARSER_ENABLED +#error PROTOBUF_TAIL_CALL_TABLE_PARSER_ENABLED was previously declared +#endif +#if defined(PROTOBUF_EXPERIMENTAL_USE_TAIL_CALL_TABLE_PARSER) +#define PROTOBUF_TAIL_CALL_TABLE_PARSER_ENABLED 1 +// Selectively use static member functions instead of templates: +#ifndef PROTOBUF_TC_STATIC_PARSE_SINGULAR1 +# define PROTOBUF_TC_STATIC_PARSE_SINGULAR1 1 +#endif +#ifndef PROTOBUF_TC_STATIC_PARSE_SINGULAR2 +# define PROTOBUF_TC_STATIC_PARSE_SINGULAR2 0 +#endif +#ifndef PROTOBUF_TC_STATIC_PARSE_REPEATED1 +# define PROTOBUF_TC_STATIC_PARSE_REPEATED1 0 +#endif +#ifndef PROTOBUF_TC_STATIC_PARSE_REPEATED2 +# define PROTOBUF_TC_STATIC_PARSE_REPEATED2 0 +#endif +#endif + +#define PROTOBUF_TC_PARAM_DECL \ + ::google::protobuf::MessageLite *msg, const char *ptr, \ + ::google::protobuf::internal::ParseContext *ctx, \ + const ::google::protobuf::internal::TcParseTableBase *table, \ + uint64_t hasbits, ::google::protobuf::internal::TcFieldData data + +#ifdef PROTOBUF_UNUSED +#error PROTOBUF_UNUSED was previously defined +#endif +#if __has_cpp_attribute(maybe_unused) || \ + (PROTOBUF_MSC_VER_MIN(1911) && PROTOBUF_CPLUSPLUS_MIN(201703L)) +#define PROTOBUF_UNUSED [[maybe_unused]] +#elif __has_attribute(unused) || PROTOBUF_GNUC_MIN(3, 0) +#define PROTOBUF_UNUSED __attribute__((__unused__)) +#else +#define PROTOBUF_UNUSED +#endif + +// Windows declares several inconvenient macro names. We #undef them and then +// restore them in port_undef.inc. +#ifdef _MSC_VER +#pragma push_macro("CREATE_NEW") +#undef CREATE_NEW +#pragma push_macro("DELETE") +#undef DELETE +#pragma push_macro("DOUBLE_CLICK") +#undef DOUBLE_CLICK +#pragma push_macro("ERROR") +#undef ERROR +#pragma push_macro("ERROR_BUSY") +#undef ERROR_BUSY +#pragma push_macro("ERROR_INSTALL_FAILED") +#undef ERROR_INSTALL_FAILED +#pragma push_macro("ERROR_NOT_FOUND") +#undef ERROR_NOT_FOUND +#pragma push_macro("GetMessage") +#undef GetMessage +#pragma push_macro("IGNORE") +#undef IGNORE +#pragma push_macro("IN") +#undef IN +#pragma push_macro("INPUT_KEYBOARD") +#undef INPUT_KEYBOARD +#pragma push_macro("NO_ERROR") +#undef NO_ERROR +#pragma push_macro("OUT") +#undef OUT +#pragma push_macro("OPTIONAL") +#undef OPTIONAL +#pragma push_macro("min") +#undef min +#pragma push_macro("max") +#undef max +#pragma push_macro("NEAR") +#undef NEAR +#pragma push_macro("NO_DATA") +#undef NO_DATA +#pragma push_macro("REASON_UNKNOWN") +#undef REASON_UNKNOWN +#pragma push_macro("SERVICE_DISABLED") +#undef SERVICE_DISABLED +#pragma push_macro("SEVERITY_ERROR") +#undef SEVERITY_ERROR +#pragma push_macro("STRICT") +#undef STRICT +#pragma push_macro("timezone") +#undef timezone +#endif // _MSC_VER + +#if defined(__clang__) || PROTOBUF_GNUC_MIN(3, 0) || defined(_MSC_VER) +// Don't let Objective-C Macros interfere with proto identifiers with the same +// name. +#pragma push_macro("DEBUG") +#undef DEBUG +#endif // defined(__clang__) || PROTOBUF_GNUC_MIN(3, 0) || defined(_MSC_VER) + +#if defined(__clang__) +#pragma clang diagnostic push +// TODO(gerbens) ideally we cleanup the code. But a cursory try shows many +// violations. So let's ignore for now. +#pragma clang diagnostic ignored "-Wshorten-64-to-32" +#elif PROTOBUF_GNUC_MIN(3, 0) +// GCC does not allow disabling diagnostics within an expression: +// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60875, so we disable this one +// globally even though it's only used for PROTOBUF_FIELD_OFFSET. +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Winvalid-offsetof" +#endif + +// Silence some MSVC warnings in all our code. +#if _MSC_VER +#pragma warning(push) +// For non-trivial unions +#pragma warning(disable : 4582) +#pragma warning(disable : 4583) +// For init_seg(lib) +#pragma warning(disable : 4073) +// To silence the fact that we will pop this push from another file +#pragma warning(disable : 5031) +// Conditional expression is constant +#pragma warning(disable: 4127) +// decimal digit terminates octal escape sequence +#pragma warning(disable: 4125) +#endif + +// We don't want code outside port_def doing complex testing, so +// remove our portable condition test macros to nudge folks away from +// using it themselves. +#ifdef PROTOBUF_has_cpp_attribute_DEFINED_ +# undef __has_cpp_attribute +# undef PROTOBUF_has_cpp_attribute_DEFINED_ +#endif +#ifdef PROTOBUF_has_feature_DEFINED_ +# undef __has_feature +# undef PROTOBUF_has_feature_DEFINED_ +#endif +#ifdef PROTOBUF_has_warning_DEFINED_ +# undef __has_warning +# undef PROTOBUF_has_warning_DEFINED_ +#endif +#ifdef PROTOBUF_has_attribute_DEFINED_ +# undef __has_attribute +# undef PROTOBUF_has_attribute_DEFINED_ +#endif +#ifdef PROTOBUF_has_builtin_DEFINED_ +# undef __has_builtin +# undef PROTOBUF_has_builtin_DEFINED_ +#endif |