@sentryware/s2-node 0.0.6

package/third_party/s2geometry/src/s2/_fp_contract_off.h

@@ -0,0 +1,60 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// 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
+//
+//     http://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.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#ifndef S2__FP_CONTRACT_OFF_H_
+#define S2__FP_CONTRACT_OFF_H_
+
+// Turn off the fused multiply-add optimization ("fp-contract").  With
+// fp-contract on, any expression of the form "a * b + c" has two possible
+// results, and the compiler is free to choose either of them.  Effectively
+// this makes it impossible to write deterministic functions that involve
+// floating-point math.
+//
+// S2 requires deterministic arithmetic for correctness.  We need to turn off
+// fp-contract for the entire compilation unit, because S2 has public inline
+// functions, and the optimization is controlled by the setting in effect when
+// inline functions are instantiated (not when they are defined).
+//
+// Note that there is a standard C pragma to turn off FP contraction:
+//   #pragma STDC FP_CONTRACT OFF
+// but it is not implemented in GCC because the standard pragma allows control
+// at the level of compound statements rather than entire functions.
+//
+// This file may be included with other files in any order, as long as it
+// appears before the first non-inline function definition.  It is
+// named with an underscore so that it is included first among the S2 headers.
+
+// TODO(compiler-team): Figure out how to do this in a portable way.
+#if defined(HAVE_ARMEABI_V7A)
+// Some android builds use a buggy compiler that runs out of memory while
+// parsing the pragma (--cpu=armeabi-v7a).
+
+#elif defined(__ANDROID__)
+// Other android builds use a buggy compiler that crashes with an internal
+// error (Android NDK R9).
+
+#elif defined(__clang__)
+// Clang supports the standard C++ pragma for turning off this optimization.
+#pragma STDC FP_CONTRACT OFF
+
+#elif defined(__GNUC__)
+// GCC defines its own pragma that operates at the function level rather than
+// the statement level.
+#pragma GCC optimize("fp-contract=off")
+#endif
+
+#endif  // S2__FP_CONTRACT_OFF_H_

package/third_party/s2geometry/src/s2/base/casts.h

@@ -0,0 +1,318 @@
+// Copyright 2009 Google Inc. All Rights Reserved.
+//
+// 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
+//
+//     http://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.
+//
+
+
+//
+// Various Google-specific casting templates.
+//
+// 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 S2_BASE_CASTS_H_
+#define S2_BASE_CASTS_H_
+
+#include <cassert>         // for use with down_cast<>
+#include <climits>         // for enumeration casts and tests
+#include <type_traits>
+
+#include "s2/third_party/absl/base/casts.h"
+#include "s2/third_party/absl/base/macros.h"
+
+// An "upcast", i.e. a conversion from a pointer to an object to a pointer to a
+// base subobject, always succeeds if the base is unambiguous and accessible,
+// and so it's fine to use implicit_cast.
+//
+// A "downcast", i.e. a conversion from a pointer to an object to a pointer
+// to a more-derived object that may contain the original object as a base
+// subobject, cannot safely be done using static_cast, because you do not
+// generally know whether the source object is really the base subobject of
+// a containing, more-derived object of the target type. Thus, when you
+// downcast in a polymorphic type hierarchy, you should use the following
+// function template.
+//
+// In debug mode, we use dynamic_cast to double-check whether the downcast is
+// legal (we die if it's not). In normal mode, we do the efficient static_cast
+// instead. Thus, it's important to test in debug mode to make sure the cast is
+// legal!
+//
+// This is the only place in the codebase we should use dynamic_cast.
+// In particular, you should NOT use dynamic_cast for RTTI, e.g. for
+// code like this:
+//    if (auto* p = dynamic_cast<Subclass1*>(foo)) HandleASubclass1Object(p);
+//    if (auto* p = dynamic_cast<Subclass2*>(foo)) HandleASubclass2Object(p);
+// You should design the code some other way not to need this.
+
+template<typename To, typename From>     // use like this: down_cast<T*>(foo);
+inline To down_cast(From* f) {           // so we only accept pointers
+  static_assert(
+      (std::is_base_of<From, typename std::remove_pointer<To>::type>::value),
+      "target type not derived from source type");
+
+  // We skip the assert and hence the dynamic_cast if RTTI is disabled.
+#if !defined(__GNUC__) || defined(__GXX_RTTI)
+  // Uses RTTI in dbg and fastbuild. asserts are disabled in opt builds.
+  assert(f == nullptr || dynamic_cast<To>(f) != nullptr);
+#endif  // !defined(__GNUC__) || defined(__GXX_RTTI)
+
+  return static_cast<To>(f);
+}
+
+// Overload of down_cast for references. Use like this: down_cast<T&>(foo).
+// The code is slightly convoluted because we're still using the pointer
+// form of dynamic cast. (The reference form throws an exception if it
+// fails.)
+//
+// There's no need for a special const overload either for the pointer
+// or the reference form. If you call down_cast with a const T&, the
+// compiler will just bind From to const T.
+template<typename To, typename From>
+inline To down_cast(From& f) {
+  static_assert(
+      std::is_lvalue_reference<To>::value, "target type not a reference");
+  static_assert(
+      (std::is_base_of<From, typename std::remove_reference<To>::type>::value),
+      "target type not derived from source type");
+
+  // We skip the assert and hence the dynamic_cast if RTTI is disabled.
+#if !defined(__GNUC__) || defined(__GXX_RTTI)
+  // RTTI: debug mode only
+  assert(dynamic_cast<typename std::remove_reference<To>::type*>(&f) !=
+         nullptr);
+#endif  // !defined(__GNUC__) || defined(__GXX_RTTI)
+
+  return static_cast<To>(f);
+}
+
+// **** Enumeration Casts and Tests
+//
+// C++ requires that the value of an integer that is converted to an
+// enumeration be within the value bounds of the enumeration.  Modern
+// compilers can and do take advantage of this requirement to optimize
+// programs.  So, using a raw static_cast with enums can be bad.  See
+//
+// The following templates and macros enable casting from an int to an enum
+// with checking against the appropriate bounds.  First, when defining an
+// enumeration, identify the limits of the values of its enumerators.
+//
+//   enum A { A_min = -18, A_max = 33 };
+//   MAKE_ENUM_LIMITS(A, A_min, A_max)
+//
+// Convert an int to an enum in one of two ways.  The prefered way is a
+// tight conversion, which ensures that A_min <= value <= A_max.
+//
+//   A var = tight_enum_cast<A>(3);
+//
+// However, the C++ language defines the set of possible values for an
+// enumeration to be essentially the range of a bitfield that can represent
+// all the enumerators, i.e. those within the nearest containing power
+// of two.  In the example above, the nearest positive power of two is 64,
+// and so the upper bound is 63.  The nearest negative power of two is
+// -32 and so the lower bound is -32 (two's complement), which is upgraded
+// to match the upper bound, becoming -64.  The values within this range
+// of -64 to 63 are valid, according to the C++ standard.  You can cast
+// values within this range as follows.
+//
+//   A var = loose_enum_cast<A>(45);
+//
+// These casts will log a message if the value does not reside within the
+// specified range, and will be fatal when in debug mode.
+//
+// For those times when an assert too strong, there are test functions.
+//
+//   bool var = tight_enum_test<A>(3);
+//   bool var = loose_enum_test<A>(45);
+//
+// For code that needs to use the enumeration value if and only if
+// it is good, there is a function that both tests and casts.
+//
+//   int i = ....;
+//   A var;
+//   if (tight_enum_test_cast<A>(i, &var))
+//     .... // use valid var with value as indicated by i
+//   else
+//     .... // handle invalid enum cast
+//
+// The enum test/cast facility is currently limited to enumerations that
+// fit within an int.  It is also limited to two's complement ints.
+
+// ** Implementation Description
+//
+// The enum_limits template class captures the minimum and maximum
+// enumerator.  All uses of this template are intended to be of
+// specializations, so the generic has a field to identify itself as
+// not specialized.  The test/cast templates assert specialization.
+
+template <typename Enum>
+class enum_limits {
+ public:
+  static const Enum min_enumerator = 0;
+  static const Enum max_enumerator = 0;
+  static const bool is_specialized = false;
+};
+
+// Now we define the macro to define the specialization for enum_limits.
+// The specialization checks that the enumerators fit within an int.
+// This checking relies on integral promotion.
+
+#define MAKE_ENUM_LIMITS(ENUM_TYPE, ENUM_MIN, ENUM_MAX) \
+template <> \
+class enum_limits<ENUM_TYPE> { \
+public: \
+  static const ENUM_TYPE min_enumerator = ENUM_MIN; \
+  static const ENUM_TYPE max_enumerator = ENUM_MAX; \
+  static const bool is_specialized = true; \
+  static_assert(ENUM_MIN >= INT_MIN, "enumerator too negative for int"); \
+  static_assert(ENUM_MAX <= INT_MAX, "enumerator too positive for int"); \
+};
+
+// The loose enum test/cast is actually the more complicated one,
+// because of the problem of finding the bounds.
+//
+// The unary upper bound, ub, on a positive number is its positive
+// saturation, i.e. for a value v within pow(2,k-1) <= v < pow(2,k),
+// the upper bound is pow(2,k)-1.
+//
+// The unary lower bound, lb, on a negative number is its negative
+// saturation, i.e. for a value v within -pow(2,k) <= v < -pow(2,k-1),
+// the lower bound is -pow(2,k).
+//
+// The actual bounds are (1) the binary upper bound over the maximum
+// enumerator and the one's complement of a negative minimum enumerator
+// and (2) the binary lower bound over the minimum enumerator and the
+// one's complement of the positive maximum enumerator, except that if no
+// enumerators are negative, the lower bound is zero.
+//
+// The algorithm relies heavily on the observation that
+//
+//   a,b>0 then ub(a,b) == ub(a) | ub(b) == ub(a|b)
+//   a,b<0 then lb(a,b) == lb(a) & lb(b) == lb(a&b)
+//
+// Note that the compiler will boil most of this code away
+// because of value propagation on the constant enumerator bounds.
+
+template <typename Enum>
+inline bool loose_enum_test(int e_val) {
+  static_assert(enum_limits<Enum>::is_specialized, "missing MAKE_ENUM_LIMITS");
+  const Enum e_min = enum_limits<Enum>::min_enumerator;
+  const Enum e_max = enum_limits<Enum>::max_enumerator;
+  static_assert(sizeof(e_val) == 4 || sizeof(e_val) == 8,
+                "unexpected int size");
+
+  // Find the unary bounding negative number of e_min and e_max.
+
+  // Find the unary bounding negative number of e_max.
+  // This would be b_min = e_max < 0 ? e_max : ~e_max,
+  // but we want to avoid branches to help the compiler.
+  int e_max_sign = e_max >> (sizeof(e_val)*8 - 1);
+  int b_min = ~e_max_sign ^ e_max;
+
+  // Find the binary bounding negative of both e_min and e_max.
+  b_min &= e_min;
+
+  // However, if e_min is positive, the result will be positive.
+  // Now clear all bits right of the most significant clear bit,
+  // which is a negative saturation for negative numbers.
+  // In the case of positive numbers, this is flush to zero.
+  b_min &= b_min >> 1;
+  b_min &= b_min >> 2;
+  b_min &= b_min >> 4;
+  b_min &= b_min >> 8;
+  b_min &= b_min >> 16;
+#if INT_MAX > 2147483647
+  b_min &= b_min >> 32;
+#endif
+
+  // Find the unary bounding positive number of e_max.
+  int b_max = e_max_sign ^ e_max;
+
+  // Find the binary bounding positive number of that
+  // and the unary bounding positive number of e_min.
+  int e_min_sign = e_min >> (sizeof(e_val)*8 - 1);
+  b_max |= e_min_sign ^ e_min;
+
+  // Now set all bits right of the most significant set bit,
+  // which is a positive saturation for positive numbers.
+  b_max |= b_max >> 1;
+  b_max |= b_max >> 2;
+  b_max |= b_max >> 4;
+  b_max |= b_max >> 8;
+  b_max |= b_max >> 16;
+#if INT_MAX > 2147483647
+  b_max |= b_max >> 32;
+#endif
+
+  // Finally test the bounds.
+  return b_min <= e_val && e_val <= b_max;
+}
+
+template <typename Enum>
+inline bool tight_enum_test(int e_val) {
+  static_assert(enum_limits<Enum>::is_specialized, "missing MAKE_ENUM_LIMITS");
+  const Enum e_min = enum_limits<Enum>::min_enumerator;
+  const Enum e_max = enum_limits<Enum>::max_enumerator;
+  return e_min <= e_val && e_val <= e_max;
+}
+
+template <typename Enum>
+inline bool loose_enum_test_cast(int e_val, Enum* e_var) {
+  if (loose_enum_test<Enum>(e_val)) {
+     *e_var = static_cast<Enum>(e_val);
+     return true;
+  } else {
+     return false;
+  }
+}
+
+template <typename Enum>
+inline bool tight_enum_test_cast(int e_val, Enum* e_var) {
+  if (tight_enum_test<Enum>(e_val)) {
+     *e_var = static_cast<Enum>(e_val);
+     return true;
+  } else {
+     return false;
+  }
+}
+
+// The plain casts require logging, and we get header recursion if
+// it is done directly.  So, we do it indirectly.
+// The following function is defined in logging.cc.
+
+namespace base {
+namespace internal {
+
+void WarnEnumCastError(int value_of_int);
+
+}  // namespace internal
+}  // namespace base
+
+template <typename Enum>
+inline Enum loose_enum_cast(int e_val) {
+  if (!loose_enum_test<Enum>(e_val)) {
+    base::internal::WarnEnumCastError(e_val);
+  }
+  return static_cast<Enum>(e_val);
+}
+
+template <typename Enum>
+inline Enum tight_enum_cast(int e_val) {
+  if (!tight_enum_test<Enum>(e_val)) {
+    base::internal::WarnEnumCastError(e_val);
+  }
+  return static_cast<Enum>(e_val);
+}
+
+#endif  // S2_BASE_CASTS_H_

package/third_party/s2geometry/src/s2/base/commandlineflags.h

@@ -0,0 +1,67 @@
+// Copyright Google Inc. All Rights Reserved.
+//
+// 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
+//
+//     http://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.
+//
+
+#ifndef S2_BASE_COMMANDLINEFLAGS_H_
+#define S2_BASE_COMMANDLINEFLAGS_H_
+
+#ifdef S2_USE_GFLAGS
+
+#include <gflags/gflags.h>
+
+// If the GFlags library is available, map the local macro names to
+// GFlags macros.
+#define S2_DEFINE_bool  DEFINE_bool
+#define S2_DECLARE_bool  DECLARE_bool
+
+#define S2_DEFINE_double  DEFINE_double
+#define S2_DECLARE_double  DECLARE_double
+
+#define S2_DEFINE_int32  DEFINE_int32
+#define S2_DECLARE_int32  DECLARE_int32
+
+#define S2_DEFINE_string  DEFINE_string
+#define S2_DECLARE_string  DECLARE_string
+
+#else  // !defined(S2_USE_GFLAGS)
+
+#include <string>
+
+#include "s2/base/integral_types.h"
+
+// Create a set of gflags-like macros for declaring/defining flags. Use
+// a library-specific name to potential minimize clashes with GFlags.
+
+#define S2_DEFINE_bool(name, default_value, description) \
+  bool FLAGS_##name = default_value
+#define S2_DECLARE_bool(name) \
+  extern bool FLAGS_##name
+#define S2_DEFINE_double(name, default_value, description) \
+  double FLAGS_##name = default_value
+#define S2_DECLARE_double(name) \
+  extern double FLAGS_##name
+
+#define S2_DEFINE_int32(name, default_value, description) \
+  int32 FLAGS_##name = default_value
+#define S2_DECLARE_int32(name) \
+  extern int32 FLAGS_##name
+
+#define S2_DEFINE_string(name, default_value, description) \
+  std::string FLAGS_##name = default_value
+#define S2_DECLARE_string(name) \
+  extern std::string FLAGS_##name
+
+#endif  // !defined(S2_USE_GFLAGS)
+
+#endif  // S2_BASE_COMMANDLINEFLAGS_H_

package/third_party/s2geometry/src/s2/base/integral_types.h

@@ -0,0 +1,31 @@
+// Copyright 2018 Google Inc. All Rights Reserved.
+//
+// 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
+//
+//     http://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.
+//
+
+#ifndef S2_BASE_INTEGRAL_TYPES_H_
+#define S2_BASE_INTEGRAL_TYPES_H_
+
+using int8 = signed char;
+using int16 = short;
+using int32 = int;
+using int64 = long long;
+
+using uint8 = unsigned char;
+using uint16 = unsigned short;
+using uint32 = unsigned int;
+using uint64 = unsigned long long;
+
+using uword_t = unsigned long;
+
+#endif  // S2_BASE_INTEGRAL_TYPES_H_

package/third_party/s2geometry/src/s2/base/log_severity.h

@@ -0,0 +1,40 @@
+// Copyright Google Inc. All Rights Reserved.
+//
+// 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
+//
+//     http://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.
+//
+
+#ifndef S2_BASE_LOG_SEVERITY_H_
+#define S2_BASE_LOG_SEVERITY_H_
+
+#ifdef S2_USE_GLOG
+
+#include <glog/log_severity.h>
+
+#else  // !defined(S2_USE_GLOG)
+
+#include "s2/third_party/absl/base/log_severity.h"
+
+// Stay compatible with glog.
+namespace google {
+
+#ifdef NDEBUG
+constexpr bool DEBUG_MODE = false;
+#else
+constexpr bool DEBUG_MODE = true;
+#endif
+
+}  // namespace google
+
+#endif  // !defined(S2_USE_GLOG)
+
+#endif  // S2_BASE_LOG_SEVERITY_H_

package/third_party/s2geometry/src/s2/base/logging.h

@@ -0,0 +1,173 @@
+// Copyright Google Inc. All Rights Reserved.
+//
+// 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
+//
+//     http://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.
+//
+
+#ifndef S2_BASE_LOGGING_H_
+#define S2_BASE_LOGGING_H_
+
+#ifdef S2_USE_GLOG
+
+#include <glog/logging.h>
+
+// The names CHECK, etc. are too common and may conflict with other
+// packages.  We use S2_CHECK to make it easier to switch to
+// something other than GLOG for logging.
+
+#define S2_LOG LOG
+#define S2_LOG_IF LOG_IF
+#define S2_DLOG_IF DLOG_IF
+
+#define S2_CHECK CHECK
+#define S2_CHECK_EQ CHECK_EQ
+#define S2_CHECK_NE CHECK_NE
+#define S2_CHECK_LT CHECK_LT
+#define S2_CHECK_LE CHECK_LE
+#define S2_CHECK_GT CHECK_GT
+#define S2_CHECK_GE CHECK_GE
+
+#define S2_DCHECK DCHECK
+#define S2_DCHECK_EQ DCHECK_EQ
+#define S2_DCHECK_NE DCHECK_NE
+#define S2_DCHECK_LT DCHECK_LT
+#define S2_DCHECK_LE DCHECK_LE
+#define S2_DCHECK_GT DCHECK_GT
+#define S2_DCHECK_GE DCHECK_GE
+
+#define S2_VLOG VLOG
+#define S2_VLOG_IS_ON VLOG_IS_ON
+
+#else  // !defined(S2_USE_GLOG)
+
+#include <iostream>
+
+#include "s2/base/log_severity.h"
+#include "s2/third_party/absl/base/attributes.h"
+#include "s2/third_party/absl/base/log_severity.h"
+
+class S2LogMessage {
+ public:
+  S2LogMessage(const char* file, int line,
+               absl::LogSeverity severity, std::ostream& stream)
+    : severity_(severity), stream_(stream) {
+    if (enabled()) {
+      stream_ << file << ":" << line << " "
+              << absl::LogSeverityName(severity) << " ";
+    }
+  }
+  ~S2LogMessage() { if (enabled()) stream_ << std::endl; }
+
+  std::ostream& stream() { return stream_; }
+
+ private:
+  bool enabled() const {
+#ifdef ABSL_MIN_LOG_LEVEL
+    return (static_cast<int>(severity_) >= ABSL_MIN_LOG_LEVEL ||
+            severity_ >= absl::LogSeverity::kFatal);
+#else
+    return true;
+#endif
+  }
+
+  absl::LogSeverity severity_;
+  std::ostream& stream_;
+};
+
+// Same as S2LogMessage, but destructor is marked no-return to avoid
+// "no return value warnings" in functions that return non-void.
+class S2FatalLogMessage : public S2LogMessage {
+ public:
+  S2FatalLogMessage(const char* file, int line,
+                    absl::LogSeverity severity, std::ostream& stream)
+      ABSL_ATTRIBUTE_COLD
+    : S2LogMessage(file, line, severity, stream) {}
+  ABSL_ATTRIBUTE_NORETURN ~S2FatalLogMessage() { abort(); }
+};
+
+// Logging stream that does nothing.
+struct S2NullStream {
+  template <typename T>
+  S2NullStream& operator<<(const T& v) { return *this; }
+};
+
+// Used to suppress "unused value" warnings.
+struct S2LogMessageVoidify {
+  // Must have precedence lower than << but higher than ?:.
+  void operator&(std::ostream&) {}
+};
+
+#define S2_LOG_MESSAGE_(LogMessageClass, log_severity) \
+    LogMessageClass(__FILE__, __LINE__, log_severity, std::cerr)
+#define S2_LOG_INFO \
+    S2_LOG_MESSAGE_(S2LogMessage, absl::LogSeverity::kInfo)
+#define S2_LOG_WARNING \
+    S2_LOG_MESSAGE_(S2LogMessage, absl::LogSeverity::kWarning)
+#define S2_LOG_ERROR \
+    S2_LOG_MESSAGE_(S2LogMessage, absl::LogSeverity::kError)
+#define S2_LOG_FATAL \
+    S2_LOG_MESSAGE_(S2FatalLogMessage, absl::LogSeverity::kFatal)
+#ifndef NDEBUG
+#define S2_LOG_DFATAL S2_LOG_FATAL
+#else
+#define S2_LOG_DFATAL S2_LOG_ERROR
+#endif
+
+#define S2_LOG(severity) S2_LOG_##severity.stream()
+
+// Implementing this as if (...) {} else S2_LOG(...) will cause dangling else
+// warnings when someone does if (...) S2_LOG_IF(...), so do this tricky
+// thing instead.
+#define S2_LOG_IF(severity, condition) \
+    !(condition) ? (void)0 : S2LogMessageVoidify() & S2_LOG(severity)
+
+#define S2_CHECK(condition) \
+    S2_LOG_IF(FATAL, ABSL_PREDICT_FALSE(!(condition))) \
+        << ("Check failed: " #condition " ")
+
+#ifndef NDEBUG
+
+#define S2_DLOG_IF S2_LOG_IF
+#define S2_DCHECK S2_CHECK
+
+#else  // defined(NDEBUG)
+
+#define S2_DLOG_IF(severity, condition) \
+    while (false && (condition)) S2NullStream()
+#define S2_DCHECK(condition) \
+    while (false && (condition)) S2NullStream()
+
+#endif  // defined(NDEBUG)
+
+#define S2_CHECK_OP(op, val1, val2) S2_CHECK((val1) op (val2))
+#define S2_CHECK_EQ(val1, val2) S2_CHECK_OP(==, val1, val2)
+#define S2_CHECK_NE(val1, val2) S2_CHECK_OP(!=, val1, val2)
+#define S2_CHECK_LT(val1, val2) S2_CHECK_OP(<, val1, val2)
+#define S2_CHECK_LE(val1, val2) S2_CHECK_OP(<=, val1, val2)
+#define S2_CHECK_GT(val1, val2) S2_CHECK_OP(>, val1, val2)
+#define S2_CHECK_GE(val1, val2) S2_CHECK_OP(>=, val1, val2)
+
+#define S2_DCHECK_OP(op, val1, val2) S2_DCHECK((val1) op (val2))
+#define S2_DCHECK_EQ(val1, val2) S2_DCHECK_OP(==, val1, val2)
+#define S2_DCHECK_NE(val1, val2) S2_DCHECK_OP(!=, val1, val2)
+#define S2_DCHECK_LT(val1, val2) S2_DCHECK_OP(<, val1, val2)
+#define S2_DCHECK_LE(val1, val2) S2_DCHECK_OP(<=, val1, val2)
+#define S2_DCHECK_GT(val1, val2) S2_DCHECK_OP(>, val1, val2)
+#define S2_DCHECK_GE(val1, val2) S2_DCHECK_OP(>=, val1, val2)
+
+// We don't support VLOG.
+#define S2_VLOG(verbose_level) S2NullStream()
+#define S2_VLOG_IS_ON(verbose_level) (false)
+
+#endif  // !defined(S2_USE_GLOG)
+
+#endif  // S2_BASE_LOGGING_H_