1//
2// Copyright 2017 The Abseil Authors.
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// https://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15//
16// -----------------------------------------------------------------------------
17// File: macros.h
18// -----------------------------------------------------------------------------
19//
20// This header file defines the set of language macros used within Abseil code.
21// For the set of macros used to determine supported compilers and platforms,
22// see absl/base/config.h instead.
23//
24// This code is compiled directly on many platforms, including client
25// platforms like Windows, Mac, and embedded systems. Before making
26// any changes here, make sure that you're not breaking any platforms.
27
28#ifndef ABSL_BASE_MACROS_H_
29#define ABSL_BASE_MACROS_H_
30
31#include <cassert>
32#include <cstddef>
33
34#include "absl/base/attributes.h"
35#include "absl/base/config.h"
36#include "absl/base/optimization.h"
37#include "absl/base/port.h"
38
39// ABSL_ARRAYSIZE()
40//
41// Returns the number of elements in an array as a compile-time constant, which
42// can be used in defining new arrays. If you use this macro on a pointer by
43// mistake, you will get a compile-time error.
44#define ABSL_ARRAYSIZE(array) \
45 (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
46
47namespace absl {
48ABSL_NAMESPACE_BEGIN
49namespace macros_internal {
50// Note: this internal template function declaration is used by ABSL_ARRAYSIZE.
51// The function doesn't need a definition, as we only use its type.
52template <typename T, size_t N>
53auto ArraySizeHelper(const T (&array)[N]) -> char (&)[N];
54} // namespace macros_internal
55ABSL_NAMESPACE_END
56} // namespace absl
57
58// ABSL_BAD_CALL_IF()
59//
60// Used on a function overload to trap bad calls: any call that matches the
61// overload will cause a compile-time error. This macro uses a clang-specific
62// "enable_if" attribute, as described at
63// https://clang.llvm.org/docs/AttributeReference.html#enable-if
64//
65// Overloads which use this macro should be bracketed by
66// `#ifdef ABSL_BAD_CALL_IF`.
67//
68// Example:
69//
70// int isdigit(int c);
71// #ifdef ABSL_BAD_CALL_IF
72// int isdigit(int c)
73// ABSL_BAD_CALL_IF(c <= -1 || c > 255,
74// "'c' must have the value of an unsigned char or EOF");
75// #endif // ABSL_BAD_CALL_IF
76#if ABSL_HAVE_ATTRIBUTE(enable_if)
77#define ABSL_BAD_CALL_IF(expr, msg) \
78 __attribute__((enable_if(expr, "Bad call trap"), unavailable(msg)))
79#endif
80
81// ABSL_ASSERT()
82//
83// In C++11, `assert` can't be used portably within constexpr functions.
84// ABSL_ASSERT functions as a runtime assert but works in C++11 constexpr
85// functions. Example:
86//
87// constexpr double Divide(double a, double b) {
88// return ABSL_ASSERT(b != 0), a / b;
89// }
90//
91// This macro is inspired by
92// https://akrzemi1.wordpress.com/2017/05/18/asserts-in-constexpr-functions/
93#if defined(NDEBUG)
94#define ABSL_ASSERT(expr) \
95 (false ? static_cast<void>(expr) : static_cast<void>(0))
96#else
97#define ABSL_ASSERT(expr) \
98 (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
99 : [] { assert(false && #expr); }()) // NOLINT
100#endif
101
102// `ABSL_INTERNAL_HARDENING_ABORT()` controls how `ABSL_HARDENING_ASSERT()`
103// aborts the program in release mode (when NDEBUG is defined). The
104// implementation should abort the program as quickly as possible and ideally it
105// should not be possible to ignore the abort request.
106#define ABSL_INTERNAL_HARDENING_ABORT() \
107 do { \
108 ABSL_INTERNAL_IMMEDIATE_ABORT_IMPL(); \
109 ABSL_INTERNAL_UNREACHABLE_IMPL(); \
110 } while (false)
111
112// ABSL_HARDENING_ASSERT()
113//
114// `ABSL_HARDENING_ASSERT()` is like `ABSL_ASSERT()`, but used to implement
115// runtime assertions that should be enabled in hardened builds even when
116// `NDEBUG` is defined.
117//
118// When `NDEBUG` is not defined, `ABSL_HARDENING_ASSERT()` is identical to
119// `ABSL_ASSERT()`.
120//
121// See `ABSL_OPTION_HARDENED` in `absl/base/options.h` for more information on
122// hardened mode.
123#if ABSL_OPTION_HARDENED == 1 && defined(NDEBUG)
124#define ABSL_HARDENING_ASSERT(expr) \
125 (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
126 : [] { ABSL_INTERNAL_HARDENING_ABORT(); }())
127#else
128#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
129#endif
130
131#ifdef ABSL_HAVE_EXCEPTIONS
132#define ABSL_INTERNAL_TRY try
133#define ABSL_INTERNAL_CATCH_ANY catch (...)
134#define ABSL_INTERNAL_RETHROW do { throw; } while (false)
135#else // ABSL_HAVE_EXCEPTIONS
136#define ABSL_INTERNAL_TRY if (true)
137#define ABSL_INTERNAL_CATCH_ANY else if (false)
138#define ABSL_INTERNAL_RETHROW do {} while (false)
139#endif // ABSL_HAVE_EXCEPTIONS
140
141#endif // ABSL_BASE_MACROS_H_
142