fc8dc48020
git-subtree-dir: third_party/abseil_cpp git-subtree-mainline:ffb2ae54begit-subtree-split:768eb2ca28
226 lines
8 KiB
C++
226 lines
8 KiB
C++
//
|
|
// 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_BEGIN
|
|
namespace 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_internal
|
|
ABSL_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) && \
|
|
ABSL_HAVE_BUILTIN(__builtin_unreachable)) || \
|
|
(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_HARDENING_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_HARDENING_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_
|