//

// 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 <atomic>

#include <cassert>

#include <cstddef>

#include "absl/base/attributes.h"

#include "absl/base/config.h"

#include "absl/base/optimization.h"

#include "absl/base/options.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.

//

// NOTE: Avoid using this macro. Instead, use std::size(a) if possible, or

// std::extent_v<decltype(a)> otherwise.

#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

namespace base_internal {

#if ABSL_HAVE_CPP_ATTRIBUTE(clang::nomerge)

[[clang::nomerge]]  // Needed when this function is not inlined

#endif

[[noreturn]] inline void HardeningAbort() {

#if ABSL_HAVE_CPP_ATTRIBUTE(clang::nomerge)

  [[clang::nomerge]]  // Needed when this function is inlined

#endif

  ABSL_INTERNAL_IMMEDIATE_ABORT_IMPL();

  ABSL_INTERNAL_UNREACHABLE_IMPL();

}

}  // namespace base_internal

ABSL_NAMESPACE_END

}  // namespace absl

// ABSL_INTERNAL_UNEVALUATED()

//

// Expands into a no-op expression that contains the given expression. Used to

// avoid unused-variable warnings in configurations that don't need to evaluate

// the given expression (e.g., NDEBUG).

#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L

// We use `decltype` here to avoid generating unnecessary code that the

// optimizer then has to optimize away.

// This not only improves compilation performance by reducing codegen bloat

// and optimization work, but also guarantees fast run-time performance without

// having to rely on the optimizer.

#define ABSL_INTERNAL_UNEVALUATED(expr) (decltype((void)(expr))())

#else

// Pre-C++20, lambdas can't be inside unevaluated operands, so we're forced to

// rely on the optimizer.

#define ABSL_INTERNAL_UNEVALUATED(expr) (false ? (void)(expr) : void())

#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()

//

// `assert` generates spurious unused-symbol warnings when NDEBUG is defined.

// ABSL_ASSERT functions as a runtime assert but maintains references to

// symbols even under NDEBUG.  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) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())

#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 defined(__CUDACC__) || defined(__CUDA_ARCH__) || defined(__CUDA__)

#define ABSL_INTERNAL_HARDENING_ABORT()   \

  do {                                    \

    ABSL_INTERNAL_IMMEDIATE_ABORT_IMPL(); \

    ABSL_INTERNAL_UNREACHABLE_IMPL();     \

  } while (false)

#else

#define ABSL_INTERNAL_HARDENING_ABORT() ::absl::base_internal::HardeningAbort()

#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 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)

#define ABSL_HARDENING_ASSERT(expr)    \

  do {                                 \

    if (!ABSL_PREDICT_TRUE((expr))) {  \

      ABSL_INTERNAL_HARDENING_ABORT(); \

    }                                  \

  } while (false)

#else

#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)

#endif

// ABSL_HARDENING_ASSERT_SLOW()

//

// `ABSL_HARDENING_ASSERT()` is like `ABSL_HARDENING_ASSERT()`,

//  but specifically for assertions whose predicates are too slow

//  to be enabled in many applications.

//

// When `NDEBUG` is not defined, `ABSL_HARDENING_ASSERT_SLOW()` 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_SLOW(expr) ABSL_HARDENING_ASSERT(expr)

#else

#define ABSL_HARDENING_ASSERT_SLOW(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

// ABSL_REFACTOR_INLINE

//

// Marks a function or type for automated refactoring by go/cpp-inliner. It can

// be used on inline function definitions or type aliases in header files and

// should be combined with the `[[deprecated]]` attribute.

//

// Using `ABSL_REFACTOR_INLINE` differs from using the `[[deprecated]]` alone in

// the following ways:

//

// 1. New uses of the function or type will be discouraged via Tricorder

//    warnings.

// 2. If enabled via `METADATA`, automated changes will be sent out inlining the

//    functions's body or replacing the type where it is used.

//

// Examples:

//

// [[deprecated("Use NewFunc() instead")]] ABSL_REFACTOR_INLINE

// inline int OldFunc(int x) {

//   return NewFunc(x, 0);

// }

//

// using OldType [[deprecated("Use NewType instead")]] ABSL_REFACTOR_INLINE =

//     NewType;

//

// will mark `OldFunc` and `OldType` as deprecated, and the go/cpp-inliner

// service will replace calls to `OldFunc(x)` with calls to `NewFunc(x, 0)` and

// `OldType` with `NewType`. Once all replacements have been completed, the old

// function or type can be deleted.

//

// Internal note: Clang also allows `ABSL_REFACTOR_INLINE` to be used on

// using-declarations, but attributes on using-declarations are invalid in C++.

// (NOTE: This note refers to `using a::b ABSL_REFACTOR_INLINE;` and not

// `using b ABSL_REFACTOR_INLINE = a::b;`, which is OK.) Therefore:

//

// 1. In OSS: Do not use this on using-declarations. Such usage is invalid and

//    unsupported usage, and may break at any time.

// 2. In Google: Avoid such usage except as a last resort. Instead, prefer other

//    inlining approaches (such as type aliases or forwarding functions,

//    illustrated above) whenever possible. This is because Clang (currently)

//    does not honor the [[deprecated]] attribute on using-declarations, and

//    therefore cannot surface the deprecation to users in the middle of a

//    migration.

//

// See go/cpp-inliner for more information.

//

// Note: go/cpp-inliner is Google-internal service for automated refactoring.

// While open-source users do not have access to this service, the macro is

// provided for compatibility.

#if ABSL_HAVE_CPP_ATTRIBUTE(clang::annotate) && !defined(__NVCC__)

#define ABSL_REFACTOR_INLINE                                                \

  _Pragma("clang diagnostic push") /* Avoid errors on using-declarations */ \

      _Pragma("clang diagnostic ignored \"-Wcxx-attribute-extension\"")     \

          [[clang::annotate("inline-me")]] _Pragma("clang diagnostic pop")

#else

#define ABSL_REFACTOR_INLINE

#endif

// ABSL_DEPRECATE_AND_INLINE()

//

// This is the original macro used by go/cpp-inliner that combines

// [[deprecated]] and ABSL_REFACTOR_INLINE.

//

// Examples:

//

// ABSL_DEPRECATE_AND_INLINE() inline int OldFunc(int x) {

//   return NewFunc(x, 0);

// }

//

// using OldType ABSL_DEPRECATE_AND_INLINE() = NewType;

//

// The combination of `[[deprecated("Use X instead")]]` and

// `ABSL_REFACTOR_INLINE` is preferred because it provides a more informative

// deprecation message to developers, especially those that do not have access

// to the automated refactoring capabilities of go/cpp-inliner.

#define ABSL_DEPRECATE_AND_INLINE() [[deprecated]] ABSL_REFACTOR_INLINE

// Requires the compiler to prove that the size of the given object is at least

// the expected amount.

#if ABSL_HAVE_ATTRIBUTE(diagnose_if) && ABSL_HAVE_BUILTIN(__builtin_object_size)

#define ABSL_INTERNAL_NEED_MIN_SIZE(Obj, N)                     \

  __attribute__((diagnose_if(__builtin_object_size(Obj, 0) < N, \

                             "object size provably too small "  \

                             "(this would corrupt memory)",     \

                             "error")))

#else

#define ABSL_INTERNAL_NEED_MIN_SIZE(Obj, N)

#endif

#endif  // ABSL_BASE_MACROS_H_