| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255 | //// Copyright 2017 The Abseil Authors.//// Licensed under the Apache License, Version 2.0 (the "License");// you may not use this file except in compliance with the License.// You may obtain a copy of the License at////      https://www.apache.org/licenses/LICENSE-2.0//// Unless required by applicable law or agreed to in writing, software// distributed under the License is distributed on an "AS IS" BASIS,// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.// See the License for the specific language governing permissions and// limitations under the License.//// -----------------------------------------------------------------------------// File: macros.h// -----------------------------------------------------------------------------//// This header file defines the set of language macros used within Abseil code.// For the set of macros used to determine supported compilers and platforms,// see absl/base/config.h instead.//// This code is compiled directly on many platforms, including client// platforms like Windows, Mac, and embedded systems.  Before making// any changes here, make sure that you're not breaking any platforms.#ifndef ABSL_BASE_MACROS_H_#define ABSL_BASE_MACROS_H_#include <cassert>#include <cstddef>#include "absl/base/attributes.h"#include "absl/base/config.h"#include "absl/base/optimization.h"#include "absl/base/port.h"// ABSL_ARRAYSIZE()//// Returns the number of elements in an array as a compile-time constant, which// can be used in defining new arrays. If you use this macro on a pointer by// mistake, you will get a compile-time error.#define ABSL_ARRAYSIZE(array) \  (sizeof(::absl::macros_internal::ArraySizeHelper(array)))namespace absl {ABSL_NAMESPACE_BEGINnamespace macros_internal {// Note: this internal template function declaration is used by ABSL_ARRAYSIZE.// The function doesn't need a definition, as we only use its type.template <typename T, size_t N>auto ArraySizeHelper(const T (&array)[N]) -> char (&)[N];}  // namespace macros_internalABSL_NAMESPACE_END}  // namespace absl// kLinkerInitialized//// An enum used only as a constructor argument to indicate that a variable has// static storage duration, and that the constructor should do nothing to its// state. Use of this macro indicates to the reader that it is legal to// declare a static instance of the class, provided the constructor is given// the absl::base_internal::kLinkerInitialized argument.//// Normally, it is unsafe to declare a static variable that has a constructor or// a destructor because invocation order is undefined. However, if the type can// be zero-initialized (which the loader does for static variables) into a valid// state and the type's destructor does not affect storage, then a constructor// for static initialization can be declared.//// Example://       // Declaration//       explicit MyClass(absl::base_internal:LinkerInitialized x) {}////       // Invocation//       static MyClass my_global(absl::base_internal::kLinkerInitialized);namespace absl {ABSL_NAMESPACE_BEGINnamespace base_internal {enum LinkerInitialized {  kLinkerInitialized = 0,};}  // namespace base_internalABSL_NAMESPACE_END}  // namespace absl// ABSL_FALLTHROUGH_INTENDED//// Annotates implicit fall-through between switch labels, allowing a case to// indicate intentional fallthrough and turn off warnings about any lack of a// `break` statement. The ABSL_FALLTHROUGH_INTENDED macro should be followed by// a semicolon and can be used in most places where `break` can, provided that// no statements exist between it and the next switch label.//// Example:////  switch (x) {//    case 40://    case 41://      if (truth_is_out_there) {//        ++x;//        ABSL_FALLTHROUGH_INTENDED;  // Use instead of/along with annotations//                                    // in comments//      } else {//        return x;//      }//    case 42://      ...//// Notes: when compiled with clang in C++11 mode, the ABSL_FALLTHROUGH_INTENDED// macro is expanded to the [[clang::fallthrough]] attribute, which is analysed// when  performing switch labels fall-through diagnostic// (`-Wimplicit-fallthrough`). See clang documentation on language extensions// for details:// https://clang.llvm.org/docs/AttributeReference.html#fallthrough-clang-fallthrough//// When used with unsupported compilers, the ABSL_FALLTHROUGH_INTENDED macro// has no effect on diagnostics. In any case this macro has no effect on runtime// behavior and performance of code.#ifdef ABSL_FALLTHROUGH_INTENDED#error "ABSL_FALLTHROUGH_INTENDED should not be defined."#endif// TODO(zhangxy): Use c++17 standard [[fallthrough]] macro, when supported.#if defined(__clang__) && defined(__has_warning)#if __has_feature(cxx_attributes) && __has_warning("-Wimplicit-fallthrough")#define ABSL_FALLTHROUGH_INTENDED [[clang::fallthrough]]#endif#elif defined(__GNUC__) && __GNUC__ >= 7#define ABSL_FALLTHROUGH_INTENDED [[gnu::fallthrough]]#endif#ifndef ABSL_FALLTHROUGH_INTENDED#define ABSL_FALLTHROUGH_INTENDED \  do {                            \  } while (0)#endif// ABSL_DEPRECATED()//// Marks a deprecated class, struct, enum, function, method and variable// declarations. The macro argument is used as a custom diagnostic message (e.g.// suggestion of a better alternative).//// Examples:////   class ABSL_DEPRECATED("Use Bar instead") Foo {...};////   ABSL_DEPRECATED("Use Baz() instead") void Bar() {...}////   template <typename T>//   ABSL_DEPRECATED("Use DoThat() instead")//   void DoThis();//// Every usage of a deprecated entity will trigger a warning when compiled with// clang's `-Wdeprecated-declarations` option. This option is turned off by// default, but the warnings will be reported by clang-tidy.#if defined(__clang__) && __cplusplus >= 201103L#define ABSL_DEPRECATED(message) __attribute__((deprecated(message)))#endif#ifndef ABSL_DEPRECATED#define ABSL_DEPRECATED(message)#endif// ABSL_BAD_CALL_IF()//// Used on a function overload to trap bad calls: any call that matches the// overload will cause a compile-time error. This macro uses a clang-specific// "enable_if" attribute, as described at// https://clang.llvm.org/docs/AttributeReference.html#enable-if//// Overloads which use this macro should be bracketed by// `#ifdef ABSL_BAD_CALL_IF`.//// Example:////   int isdigit(int c);//   #ifdef ABSL_BAD_CALL_IF//   int isdigit(int c)//     ABSL_BAD_CALL_IF(c <= -1 || c > 255,//                       "'c' must have the value of an unsigned char or EOF");//   #endif // ABSL_BAD_CALL_IF#if ABSL_HAVE_ATTRIBUTE(enable_if)#define ABSL_BAD_CALL_IF(expr, msg) \  __attribute__((enable_if(expr, "Bad call trap"), unavailable(msg)))#endif// ABSL_ASSERT()//// In C++11, `assert` can't be used portably within constexpr functions.// ABSL_ASSERT functions as a runtime assert but works in C++11 constexpr// functions.  Example://// constexpr double Divide(double a, double b) {//   return ABSL_ASSERT(b != 0), a / b;// }//// This macro is inspired by// https://akrzemi1.wordpress.com/2017/05/18/asserts-in-constexpr-functions/#if defined(NDEBUG)#define ABSL_ASSERT(expr) \  (false ? static_cast<void>(expr) : static_cast<void>(0))#else#define ABSL_ASSERT(expr)                           \  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \                             : [] { assert(false && #expr); }())  // NOLINT#endif// `ABSL_INTERNAL_HARDENING_ABORT()` controls how `ABSL_HARDENING_ASSERT()`// aborts the program in release mode (when NDEBUG is defined). The// implementation should abort the program as quickly as possible and ideally it// should not be possible to ignore the abort request.#if ABSL_HAVE_BUILTIN(__builtin_trap) || \    (defined(__GNUC__) && !defined(__clang__))#define ABSL_INTERNAL_HARDENING_ABORT() \  do {                                  \    __builtin_trap();                   \    __builtin_unreachable();            \  } while (false)#else#define ABSL_INTERNAL_HARDENING_ABORT() abort()#endif// ABSL_HARDENING_ASSERT()//// `ABSL_HARDENED_ASSERT()` is like `ABSL_ASSERT()`, but used to implement// runtime assertions that should be enabled in hardened builds even when// `NDEBUG` is defined.//// When `NDEBUG` is not defined, `ABSL_HARDENED_ASSERT()` is identical to// `ABSL_ASSERT()`.//// See `ABSL_OPTION_HARDENED` in `absl/base/options.h` for more information on// hardened mode.#if ABSL_OPTION_HARDENED == 1 && defined(NDEBUG)#define ABSL_HARDENING_ASSERT(expr)                 \  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \                             : [] { ABSL_INTERNAL_HARDENING_ABORT(); }())#else#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)#endif#ifdef ABSL_HAVE_EXCEPTIONS#define ABSL_INTERNAL_TRY try#define ABSL_INTERNAL_CATCH_ANY catch (...)#define ABSL_INTERNAL_RETHROW do { throw; } while (false)#else  // ABSL_HAVE_EXCEPTIONS#define ABSL_INTERNAL_TRY if (true)#define ABSL_INTERNAL_CATCH_ANY else if (false)#define ABSL_INTERNAL_RETHROW do {} while (false)#endif  // ABSL_HAVE_EXCEPTIONS#endif  // ABSL_BASE_MACROS_H_
 |