diff --git a/.clang-format b/.clang-format index 9448dc8d8c80d..abd823c103904 100644 --- a/.clang-format +++ b/.clang-format @@ -19,3 +19,4 @@ BasedOnStyle: Google ColumnLimit: 90 DerivePointerAlignment: false IncludeBlocks: Preserve +IndentPPDirectives: AfterHash diff --git a/cpp/src/arrow/acero/aggregate_benchmark.cc b/cpp/src/arrow/acero/aggregate_benchmark.cc index 854862e3e48ca..c0dfba66336af 100644 --- a/cpp/src/arrow/acero/aggregate_benchmark.cc +++ b/cpp/src/arrow/acero/aggregate_benchmark.cc @@ -165,11 +165,11 @@ struct SumSentinelUnrolled : public Summer { static void Sum(const ArrayType& array, SumState* state) { SumState local; -#define SUM_NOT_NULL(ITEM) \ - do { \ - local.total += values[i + ITEM] * Traits::NotNull(values[i + ITEM]); \ - local.valid_count++; \ - } while (0) +# define SUM_NOT_NULL(ITEM) \ + do { \ + local.total += values[i + ITEM] * Traits::NotNull(values[i + ITEM]); \ + local.valid_count++; \ + } while (0) const auto values = array.raw_values(); const auto length = array.length(); @@ -185,7 +185,7 @@ struct SumSentinelUnrolled : public Summer { SUM_NOT_NULL(7); } -#undef SUM_NOT_NULL +# undef SUM_NOT_NULL for (int64_t i = length_rounded * 8; i < length; ++i) { local.total += values[i] * Traits::NotNull(values[i]); @@ -256,7 +256,7 @@ struct SumBitmapVectorizeUnroll : public Summer { for (int64_t i = 0; i < length_rounded; i += 8) { const uint8_t valid_byte = bitmap[i / 8]; -#define SUM_SHIFT(ITEM) (values[i + ITEM] * ((valid_byte >> ITEM) & 1)) +# define SUM_SHIFT(ITEM) (values[i + ITEM] * ((valid_byte >> ITEM) & 1)) if (valid_byte < 0xFF) { // Some nulls @@ -277,7 +277,7 @@ struct SumBitmapVectorizeUnroll : public Summer { } } -#undef SUM_SHIFT +# undef SUM_SHIFT for (int64_t i = length_rounded; i < length; ++i) { if (bit_util::GetBit(bitmap, i)) { diff --git a/cpp/src/arrow/acero/asof_join_node.cc b/cpp/src/arrow/acero/asof_join_node.cc index 2248362241cd7..c4f11d01f3d5c 100644 --- a/cpp/src/arrow/acero/asof_join_node.cc +++ b/cpp/src/arrow/acero/asof_join_node.cc @@ -34,7 +34,7 @@ #include "arrow/acero/options.h" #include "arrow/acero/unmaterialized_table_internal.h" #ifndef NDEBUG -#include "arrow/acero/options_internal.h" +# include "arrow/acero/options_internal.h" #endif #include "arrow/acero/query_context.h" #include "arrow/acero/schema_util.h" @@ -42,7 +42,7 @@ #include "arrow/array/builder_binary.h" #include "arrow/array/builder_primitive.h" #ifndef NDEBUG -#include "arrow/compute/function_internal.h" +# include "arrow/compute/function_internal.h" #endif #include "arrow/acero/time_series_util.h" #include "arrow/compute/key_hash_internal.h" @@ -207,16 +207,16 @@ class DebugSync { std::unique_lock debug_lock_; }; -#define DEBUG_SYNC(node, ...) DebugSync(node).insert(__VA_ARGS__) -#define DEBUG_MANIP(manip) \ - DebugSync::Manip([](DebugSync& d) -> DebugSync& { return d << manip; }) -#define NDEBUG_EXPLICIT -#define DEBUG_ADD(ndebug, ...) ndebug, __VA_ARGS__ +# define DEBUG_SYNC(node, ...) DebugSync(node).insert(__VA_ARGS__) +# define DEBUG_MANIP(manip) \ + DebugSync::Manip([](DebugSync& d) -> DebugSync& { return d << manip; }) +# define NDEBUG_EXPLICIT +# define DEBUG_ADD(ndebug, ...) ndebug, __VA_ARGS__ #else -#define DEBUG_SYNC(...) -#define DEBUG_MANIP(...) -#define NDEBUG_EXPLICIT explicit -#define DEBUG_ADD(ndebug, ...) ndebug +# define DEBUG_SYNC(...) +# define DEBUG_MANIP(...) +# define NDEBUG_EXPLICIT explicit +# define DEBUG_ADD(ndebug, ...) ndebug #endif struct MemoStore { diff --git a/cpp/src/arrow/acero/asof_join_node_test.cc b/cpp/src/arrow/acero/asof_join_node_test.cc index 555f580028fac..5d3e9fba08bbf 100644 --- a/cpp/src/arrow/acero/asof_join_node_test.cc +++ b/cpp/src/arrow/acero/asof_join_node_test.cc @@ -26,13 +26,13 @@ #include "arrow/acero/exec_plan.h" #include "arrow/testing/future_util.h" #ifndef NDEBUG -#include +# include #endif #include #include "arrow/acero/options.h" #ifndef NDEBUG -#include "arrow/acero/options_internal.h" +# include "arrow/acero/options_internal.h" #endif #include "arrow/acero/map_node.h" #include "arrow/acero/query_context.h" diff --git a/cpp/src/arrow/acero/bloom_filter.h b/cpp/src/arrow/acero/bloom_filter.h index 50d07bfd948e0..530beaea64827 100644 --- a/cpp/src/arrow/acero/bloom_filter.h +++ b/cpp/src/arrow/acero/bloom_filter.h @@ -18,7 +18,7 @@ #pragma once #if defined(ARROW_HAVE_RUNTIME_AVX2) -#include +# include #endif #include diff --git a/cpp/src/arrow/acero/bloom_filter_test.cc b/cpp/src/arrow/acero/bloom_filter_test.cc index a2d6e9575a1aa..30cafd120caea 100644 --- a/cpp/src/arrow/acero/bloom_filter_test.cc +++ b/cpp/src/arrow/acero/bloom_filter_test.cc @@ -503,9 +503,9 @@ TEST(BloomFilter, Scaling) { num_build.push_back(4000000); std::vector strategies; -#ifdef ARROW_ENABLE_THREADING +# ifdef ARROW_ENABLE_THREADING strategies.push_back(BloomFilterBuildStrategy::PARALLEL); -#endif +# endif strategies.push_back(BloomFilterBuildStrategy::SINGLE_THREADED); for (const auto hardware_flags : HardwareFlagsForTesting()) { diff --git a/cpp/src/arrow/acero/options_internal.h b/cpp/src/arrow/acero/options_internal.h index d4bf79a7cd008..fd3ea78116572 100644 --- a/cpp/src/arrow/acero/options_internal.h +++ b/cpp/src/arrow/acero/options_internal.h @@ -18,8 +18,8 @@ #pragma once #ifndef NDEBUG -#include -#include +# include +# include #endif namespace arrow { diff --git a/cpp/src/arrow/acero/visibility.h b/cpp/src/arrow/acero/visibility.h index 02382232b69dd..21a697a56eca9 100644 --- a/cpp/src/arrow/acero/visibility.h +++ b/cpp/src/arrow/acero/visibility.h @@ -20,31 +20,31 @@ #pragma once #if defined(_WIN32) || defined(__CYGWIN__) -#if defined(_MSC_VER) -#pragma warning(push) -#pragma warning(disable : 4251) -#else -#pragma GCC diagnostic ignored "-Wattributes" -#endif +# if defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable : 4251) +# else +# pragma GCC diagnostic ignored "-Wattributes" +# endif -#ifdef ARROW_ACERO_STATIC -#define ARROW_ACERO_EXPORT -#elif defined(ARROW_ACERO_EXPORTING) -#define ARROW_ACERO_EXPORT __declspec(dllexport) -#else -#define ARROW_ACERO_EXPORT __declspec(dllimport) -#endif +# ifdef ARROW_ACERO_STATIC +# define ARROW_ACERO_EXPORT +# elif defined(ARROW_ACERO_EXPORTING) +# define ARROW_ACERO_EXPORT __declspec(dllexport) +# else +# define ARROW_ACERO_EXPORT __declspec(dllimport) +# endif -#define ARROW_ACERO_NO_EXPORT +# define ARROW_ACERO_NO_EXPORT #else // Not Windows -#ifndef ARROW_ACERO_EXPORT -#define ARROW_ACERO_EXPORT __attribute__((visibility("default"))) -#endif -#ifndef ARROW_ACERO_NO_EXPORT -#define ARROW_ACERO_NO_EXPORT __attribute__((visibility("hidden"))) -#endif +# ifndef ARROW_ACERO_EXPORT +# define ARROW_ACERO_EXPORT __attribute__((visibility("default"))) +# endif +# ifndef ARROW_ACERO_NO_EXPORT +# define ARROW_ACERO_NO_EXPORT __attribute__((visibility("hidden"))) +# endif #endif // Not-Windows #if defined(_MSC_VER) -#pragma warning(pop) +# pragma warning(pop) #endif diff --git a/cpp/src/arrow/adapters/orc/adapter.cc b/cpp/src/arrow/adapters/orc/adapter.cc index 25759f8471365..d16b6cfd2e97d 100644 --- a/cpp/src/arrow/adapters/orc/adapter.cc +++ b/cpp/src/arrow/adapters/orc/adapter.cc @@ -25,7 +25,7 @@ #include #ifdef ARROW_ORC_NEED_TIME_ZONE_DATABASE_CHECK -#include +# include #endif #include "arrow/adapters/orc/util.h" diff --git a/cpp/src/arrow/c/abi.h b/cpp/src/arrow/c/abi.h index 6abe866b5f6f6..db051fff5ff05 100644 --- a/cpp/src/arrow/c/abi.h +++ b/cpp/src/arrow/c/abi.h @@ -41,11 +41,11 @@ extern "C" { #endif #ifndef ARROW_C_DATA_INTERFACE -#define ARROW_C_DATA_INTERFACE +# define ARROW_C_DATA_INTERFACE -#define ARROW_FLAG_DICTIONARY_ORDERED 1 -#define ARROW_FLAG_NULLABLE 2 -#define ARROW_FLAG_MAP_KEYS_SORTED 4 +# define ARROW_FLAG_DICTIONARY_ORDERED 1 +# define ARROW_FLAG_NULLABLE 2 +# define ARROW_FLAG_MAP_KEYS_SORTED 4 struct ArrowSchema { // Array type description @@ -83,7 +83,7 @@ struct ArrowArray { #endif // ARROW_C_DATA_INTERFACE #ifndef ARROW_C_DEVICE_DATA_INTERFACE -#define ARROW_C_DEVICE_DATA_INTERFACE +# define ARROW_C_DEVICE_DATA_INTERFACE // Spec and Documentation: https://arrow.apache.org/docs/format/CDeviceDataInterface.html @@ -91,33 +91,33 @@ struct ArrowArray { typedef int32_t ArrowDeviceType; // CPU device, same as using ArrowArray directly -#define ARROW_DEVICE_CPU 1 +# define ARROW_DEVICE_CPU 1 // CUDA GPU Device -#define ARROW_DEVICE_CUDA 2 +# define ARROW_DEVICE_CUDA 2 // Pinned CUDA CPU memory by cudaMallocHost -#define ARROW_DEVICE_CUDA_HOST 3 +# define ARROW_DEVICE_CUDA_HOST 3 // OpenCL Device -#define ARROW_DEVICE_OPENCL 4 +# define ARROW_DEVICE_OPENCL 4 // Vulkan buffer for next-gen graphics -#define ARROW_DEVICE_VULKAN 7 +# define ARROW_DEVICE_VULKAN 7 // Metal for Apple GPU -#define ARROW_DEVICE_METAL 8 +# define ARROW_DEVICE_METAL 8 // Verilog simulator buffer -#define ARROW_DEVICE_VPI 9 +# define ARROW_DEVICE_VPI 9 // ROCm GPUs for AMD GPUs -#define ARROW_DEVICE_ROCM 10 +# define ARROW_DEVICE_ROCM 10 // Pinned ROCm CPU memory allocated by hipMallocHost -#define ARROW_DEVICE_ROCM_HOST 11 +# define ARROW_DEVICE_ROCM_HOST 11 // Reserved for extension -#define ARROW_DEVICE_EXT_DEV 12 +# define ARROW_DEVICE_EXT_DEV 12 // CUDA managed/unified memory allocated by cudaMallocManaged -#define ARROW_DEVICE_CUDA_MANAGED 13 +# define ARROW_DEVICE_CUDA_MANAGED 13 // unified shared memory allocated on a oneAPI non-partitioned device. -#define ARROW_DEVICE_ONEAPI 14 +# define ARROW_DEVICE_ONEAPI 14 // GPU support for next-gen WebGPU standard -#define ARROW_DEVICE_WEBGPU 15 +# define ARROW_DEVICE_WEBGPU 15 // Qualcomm Hexagon DSP -#define ARROW_DEVICE_HEXAGON 16 +# define ARROW_DEVICE_HEXAGON 16 struct ArrowDeviceArray { // the Allocated Array @@ -138,7 +138,7 @@ struct ArrowDeviceArray { #endif // ARROW_C_DEVICE_DATA_INTERFACE #ifndef ARROW_C_STREAM_INTERFACE -#define ARROW_C_STREAM_INTERFACE +# define ARROW_C_STREAM_INTERFACE struct ArrowArrayStream { // Callback to get the stream type @@ -179,7 +179,7 @@ struct ArrowArrayStream { #endif // ARROW_C_STREAM_INTERFACE #ifndef ARROW_C_DEVICE_STREAM_INTERFACE -#define ARROW_C_DEVICE_STREAM_INTERFACE +# define ARROW_C_DEVICE_STREAM_INTERFACE // Equivalent to ArrowArrayStream, but for ArrowDeviceArrays. // diff --git a/cpp/src/arrow/c/bridge_test.cc b/cpp/src/arrow/c/bridge_test.cc index 09bb524adbdf0..01fd56f631d99 100644 --- a/cpp/src/arrow/c/bridge_test.cc +++ b/cpp/src/arrow/c/bridge_test.cc @@ -48,7 +48,7 @@ // TODO(GH-37221): Remove these ifdef checks when compute dependency is removed #ifdef ARROW_COMPUTE -#include "arrow/compute/api_vector.h" +# include "arrow/compute/api_vector.h" #endif namespace arrow { diff --git a/cpp/src/arrow/c/dlpack_abi.h b/cpp/src/arrow/c/dlpack_abi.h index 4af557a7ed5d7..fbe2a56a344b3 100644 --- a/cpp/src/arrow/c/dlpack_abi.h +++ b/cpp/src/arrow/c/dlpack_abi.h @@ -12,9 +12,9 @@ * \brief Compatibility with C++ */ #ifdef __cplusplus -#define DLPACK_EXTERN_C extern "C" +# define DLPACK_EXTERN_C extern "C" #else -#define DLPACK_EXTERN_C +# define DLPACK_EXTERN_C #endif /*! \brief The current major version of dlpack */ @@ -25,13 +25,13 @@ /*! \brief DLPACK_DLL prefix for windows */ #ifdef _WIN32 -#ifdef DLPACK_EXPORTS -#define DLPACK_DLL __declspec(dllexport) +# ifdef DLPACK_EXPORTS +# define DLPACK_DLL __declspec(dllexport) +# else +# define DLPACK_DLL __declspec(dllimport) +# endif #else -#define DLPACK_DLL __declspec(dllimport) -#endif -#else -#define DLPACK_DLL +# define DLPACK_DLL #endif #include diff --git a/cpp/src/arrow/compute/kernel.h b/cpp/src/arrow/compute/kernel.h index cfa1cd8193f36..cfb6265f12904 100644 --- a/cpp/src/arrow/compute/kernel.h +++ b/cpp/src/arrow/compute/kernel.h @@ -42,7 +42,7 @@ // macOS defines PREALLOCATE as a preprocessor macro in the header sys/vnode.h. // No other BSD seems to do so. The name is used as an identifier in MemAllocation enum. #if defined(__APPLE__) && defined(PREALLOCATE) -#undef PREALLOCATE +# undef PREALLOCATE #endif namespace arrow { diff --git a/cpp/src/arrow/compute/kernels/scalar_cast_string.cc b/cpp/src/arrow/compute/kernels/scalar_cast_string.cc index dc3fe29a3dfae..11875522b42c9 100644 --- a/cpp/src/arrow/compute/kernels/scalar_cast_string.cc +++ b/cpp/src/arrow/compute/kernels/scalar_cast_string.cc @@ -217,8 +217,8 @@ struct TemporalToStringCastFunctor { #if defined(_MSC_VER) // Silence warning: """'visitor': unreferenced local variable""" -#pragma warning(push) -#pragma warning(disable : 4101) +# pragma warning(push) +# pragma warning(disable : 4101) #endif struct Utf8Validator { @@ -422,7 +422,7 @@ BinaryToBinaryCastExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* ou } #if defined(_MSC_VER) -#pragma warning(pop) +# pragma warning(pop) #endif // ---------------------------------------------------------------------- diff --git a/cpp/src/arrow/compute/kernels/scalar_round_benchmark.cc b/cpp/src/arrow/compute/kernels/scalar_round_benchmark.cc index 3c5bb76dc24e9..7f1b5ef710379 100644 --- a/cpp/src/arrow/compute/kernels/scalar_round_benchmark.cc +++ b/cpp/src/arrow/compute/kernels/scalar_round_benchmark.cc @@ -122,26 +122,28 @@ void SetRoundArgs(benchmark::internal::Benchmark* bench) { BENCHMARK_TEMPLATE(BENCHMARK, OP, DoubleType)->Apply(SetRoundArgs); #ifdef ALL_ROUND_BENCHMARKS -#define DECLARE_ROUND_BENCHMARKS_WITH_ROUNDMODE(BENCHMARK, OP, TYPE) \ - BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::DOWN)->Apply(SetRoundArgs); \ - BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::UP)->Apply(SetRoundArgs); \ - BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::TOWARDS_ZERO)->Apply(SetRoundArgs); \ - BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::TOWARDS_INFINITY) \ - ->Apply(SetRoundArgs); \ - BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::HALF_DOWN)->Apply(SetRoundArgs); \ - BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::HALF_UP)->Apply(SetRoundArgs); \ - BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::HALF_TOWARDS_ZERO) \ - ->Apply(SetRoundArgs); \ - BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::HALF_TOWARDS_INFINITY) \ - ->Apply(SetRoundArgs); \ - BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::HALF_TO_EVEN)->Apply(SetRoundArgs); \ - BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::HALF_TO_ODD)->Apply(SetRoundArgs) +# define DECLARE_ROUND_BENCHMARKS_WITH_ROUNDMODE(BENCHMARK, OP, TYPE) \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::DOWN)->Apply(SetRoundArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::UP)->Apply(SetRoundArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::TOWARDS_ZERO) \ + ->Apply(SetRoundArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::TOWARDS_INFINITY) \ + ->Apply(SetRoundArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::HALF_DOWN)->Apply(SetRoundArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::HALF_UP)->Apply(SetRoundArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::HALF_TOWARDS_ZERO) \ + ->Apply(SetRoundArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::HALF_TOWARDS_INFINITY) \ + ->Apply(SetRoundArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::HALF_TO_EVEN) \ + ->Apply(SetRoundArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::HALF_TO_ODD)->Apply(SetRoundArgs) #else -#define DECLARE_ROUND_BENCHMARKS_WITH_ROUNDMODE(BENCHMARK, OP, TYPE) \ - BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::DOWN)->Apply(SetRoundArgs); \ - BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::HALF_TOWARDS_ZERO) \ - ->Apply(SetRoundArgs); \ - BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::HALF_TO_ODD)->Apply(SetRoundArgs) +# define DECLARE_ROUND_BENCHMARKS_WITH_ROUNDMODE(BENCHMARK, OP, TYPE) \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::DOWN)->Apply(SetRoundArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::HALF_TOWARDS_ZERO) \ + ->Apply(SetRoundArgs); \ + BENCHMARK_TEMPLATE(BENCHMARK, OP, TYPE, RoundMode::HALF_TO_ODD)->Apply(SetRoundArgs) #endif #define DECLARE_ROUND_BENCHMARKS(BENCHMARK, OP) \ diff --git a/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc b/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc index fecd57412b436..e58f7b065a8e5 100644 --- a/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc +++ b/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc @@ -30,7 +30,7 @@ #include "arrow/util/value_parsing.h" #ifdef ARROW_WITH_RE2 -#include +# include #endif namespace arrow { diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc index 0a2261290846a..59a22b9926456 100644 --- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc +++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc @@ -34,7 +34,7 @@ #include "arrow/util/value_parsing.h" #ifdef ARROW_WITH_UTF8PROC -#include +# include #endif namespace arrow::compute { @@ -1415,7 +1415,7 @@ TYPED_TEST(TestStringKernels, IsTitleUnicode) { } // Older versions of utf8proc fail -#if !(UTF8PROC_VERSION_MAJOR <= 2 && UTF8PROC_VERSION_MINOR < 5) +# if !(UTF8PROC_VERSION_MAJOR <= 2 && UTF8PROC_VERSION_MINOR < 5) TYPED_TEST(TestStringKernels, IsUpperUnicode) { // ٣ is arabic 3 (decimal), Φ capital @@ -1437,7 +1437,7 @@ TYPED_TEST(TestStringKernels, IsUpperUnicode) { boolean(), "[true, true, true, false, true, false]"); } -#endif // UTF8PROC_VERSION_MINOR >= 5 +# endif // UTF8PROC_VERSION_MINOR >= 5 #endif // ARROW_WITH_UTF8PROC diff --git a/cpp/src/arrow/compute/kernels/scalar_string_utf8.cc b/cpp/src/arrow/compute/kernels/scalar_string_utf8.cc index 42762ca8b116f..cf248b7c9f879 100644 --- a/cpp/src/arrow/compute/kernels/scalar_string_utf8.cc +++ b/cpp/src/arrow/compute/kernels/scalar_string_utf8.cc @@ -24,7 +24,7 @@ #include "arrow/util/utf8_internal.h" #ifdef ARROW_WITH_UTF8PROC -#include +# include #endif namespace arrow { diff --git a/cpp/src/arrow/compute/key_hash_internal.h b/cpp/src/arrow/compute/key_hash_internal.h index 1f25beb0e1622..582cf28732352 100644 --- a/cpp/src/arrow/compute/key_hash_internal.h +++ b/cpp/src/arrow/compute/key_hash_internal.h @@ -18,7 +18,7 @@ #pragma once #if defined(ARROW_HAVE_RUNTIME_AVX2) -#include +# include #endif #include diff --git a/cpp/src/arrow/compute/util.h b/cpp/src/arrow/compute/util.h index d56e398667f66..9034849bbc36d 100644 --- a/cpp/src/arrow/compute/util.h +++ b/cpp/src/arrow/compute/util.h @@ -30,21 +30,22 @@ #include "arrow/util/cpu_info.h" #if defined(__clang__) || defined(__GNUC__) -#define BYTESWAP(x) __builtin_bswap64(x) -#define ROTL(x, n) (((x) << (n)) | ((x) >> ((-n) & 31))) -#define ROTL64(x, n) (((x) << (n)) | ((x) >> ((-n) & 63))) -#define PREFETCH(ptr) __builtin_prefetch((ptr), 0 /* rw==read */, 3 /* locality */) +# define BYTESWAP(x) __builtin_bswap64(x) +# define ROTL(x, n) (((x) << (n)) | ((x) >> ((-n) & 31))) +# define ROTL64(x, n) (((x) << (n)) | ((x) >> ((-n) & 63))) +# define PREFETCH(ptr) __builtin_prefetch((ptr), 0 /* rw==read */, 3 /* locality */) #elif defined(_MSC_VER) -#include -#define BYTESWAP(x) _byteswap_uint64(x) -#define ROTL(x, n) _rotl((x), (n)) -#define ROTL64(x, n) _rotl64((x), (n)) -#if defined(_M_X64) || defined(_M_I86) -#include // https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx -#define PREFETCH(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T0) -#else -#define PREFETCH(ptr) (void)(ptr) /* disabled */ -#endif +# include +# define BYTESWAP(x) _byteswap_uint64(x) +# define ROTL(x, n) _rotl((x), (n)) +# define ROTL64(x, n) _rotl64((x), (n)) +# if defined(_M_X64) || defined(_M_I86) +// https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx +# include +# define PREFETCH(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T0) +# else +# define PREFETCH(ptr) (void)(ptr) /* disabled */ +# endif #endif namespace arrow { diff --git a/cpp/src/arrow/compute/util_internal.cc b/cpp/src/arrow/compute/util_internal.cc index 7a7875162c434..7d6c41e092889 100644 --- a/cpp/src/arrow/compute/util_internal.cc +++ b/cpp/src/arrow/compute/util_internal.cc @@ -21,7 +21,7 @@ #include "arrow/memory_pool.h" #ifdef ADDRESS_SANITIZER -#include +# include #endif namespace arrow { diff --git a/cpp/src/arrow/csv/writer.cc b/cpp/src/arrow/csv/writer.cc index 5b9c51cda5576..4b5252076af53 100644 --- a/cpp/src/arrow/csv/writer.cc +++ b/cpp/src/arrow/csv/writer.cc @@ -32,7 +32,7 @@ #include #if defined(ARROW_HAVE_NEON) || defined(ARROW_HAVE_SSE4_2) -#include +# include #endif namespace arrow { diff --git a/cpp/src/arrow/dataset/api.h b/cpp/src/arrow/dataset/api.h index c2ebd9d300727..38caa1cff19de 100644 --- a/cpp/src/arrow/dataset/api.h +++ b/cpp/src/arrow/dataset/api.h @@ -24,16 +24,16 @@ #include "arrow/dataset/discovery.h" #include "arrow/dataset/file_base.h" #ifdef ARROW_CSV -#include "arrow/dataset/file_csv.h" +# include "arrow/dataset/file_csv.h" #endif #ifdef ARROW_JSON -#include "arrow/dataset/file_json.h" +# include "arrow/dataset/file_json.h" #endif #include "arrow/dataset/file_ipc.h" #ifdef ARROW_ORC -#include "arrow/dataset/file_orc.h" +# include "arrow/dataset/file_orc.h" #endif #ifdef ARROW_PARQUET -#include "arrow/dataset/file_parquet.h" +# include "arrow/dataset/file_parquet.h" #endif #include "arrow/dataset/scanner.h" diff --git a/cpp/src/arrow/dataset/file_csv_test.cc b/cpp/src/arrow/dataset/file_csv_test.cc index 60a6685dc22fd..e8e5838e6f93a 100644 --- a/cpp/src/arrow/dataset/file_csv_test.cc +++ b/cpp/src/arrow/dataset/file_csv_test.cc @@ -464,35 +464,35 @@ INSTANTIATE_TEST_SUITE_P(TestUncompressedCsvV2, TestCsvFileFormat, // codecs should be independently tested and so we do not need to cover those with // valgrind here. #ifndef ARROW_VALGRIND -#ifdef ARROW_WITH_BZ2 +# ifdef ARROW_WITH_BZ2 INSTANTIATE_TEST_SUITE_P(TestBZ2Csv, TestCsvFileFormat, ::testing::Values(CsvFileFormatParams{Compression::BZ2, false})); INSTANTIATE_TEST_SUITE_P(TestBZ2CsvV2, TestCsvFileFormat, ::testing::Values(CsvFileFormatParams{Compression::BZ2, true})); -#endif -#ifdef ARROW_WITH_LZ4 +# endif +# ifdef ARROW_WITH_LZ4 INSTANTIATE_TEST_SUITE_P(TestLZ4Csv, TestCsvFileFormat, ::testing::Values(CsvFileFormatParams{Compression::LZ4_FRAME, false})); INSTANTIATE_TEST_SUITE_P(TestLZ4CsvV2, TestCsvFileFormat, ::testing::Values(CsvFileFormatParams{Compression::LZ4_FRAME, true})); -#endif +# endif // Snappy does not support streaming compression -#ifdef ARROW_WITH_ZLIB +# ifdef ARROW_WITH_ZLIB INSTANTIATE_TEST_SUITE_P(TestGzipCsv, TestCsvFileFormat, ::testing::Values(CsvFileFormatParams{Compression::GZIP, false})); INSTANTIATE_TEST_SUITE_P(TestGzipCsvV2, TestCsvFileFormat, ::testing::Values(CsvFileFormatParams{Compression::GZIP, true})); -#endif -#ifdef ARROW_WITH_ZSTD +# endif +# ifdef ARROW_WITH_ZSTD INSTANTIATE_TEST_SUITE_P(TestZSTDCsv, TestCsvFileFormat, ::testing::Values(CsvFileFormatParams{Compression::ZSTD, false})); INSTANTIATE_TEST_SUITE_P(TestZSTDCsvV2, TestCsvFileFormat, ::testing::Values(CsvFileFormatParams{Compression::ZSTD, true})); -#endif +# endif #endif // ARROW_VALGRIND class TestCsvFileFormatScan : public FileFormatScanMixin {}; diff --git a/cpp/src/arrow/dataset/visibility.h b/cpp/src/arrow/dataset/visibility.h index b43a253050fd8..752907238ca07 100644 --- a/cpp/src/arrow/dataset/visibility.h +++ b/cpp/src/arrow/dataset/visibility.h @@ -20,31 +20,31 @@ #pragma once #if defined(_WIN32) || defined(__CYGWIN__) -#if defined(_MSC_VER) -#pragma warning(push) -#pragma warning(disable : 4251) -#else -#pragma GCC diagnostic ignored "-Wattributes" -#endif +# if defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable : 4251) +# else +# pragma GCC diagnostic ignored "-Wattributes" +# endif -#ifdef ARROW_DS_STATIC -#define ARROW_DS_EXPORT -#elif defined(ARROW_DS_EXPORTING) -#define ARROW_DS_EXPORT __declspec(dllexport) -#else -#define ARROW_DS_EXPORT __declspec(dllimport) -#endif +# ifdef ARROW_DS_STATIC +# define ARROW_DS_EXPORT +# elif defined(ARROW_DS_EXPORTING) +# define ARROW_DS_EXPORT __declspec(dllexport) +# else +# define ARROW_DS_EXPORT __declspec(dllimport) +# endif -#define ARROW_DS_NO_EXPORT +# define ARROW_DS_NO_EXPORT #else // Not Windows -#ifndef ARROW_DS_EXPORT -#define ARROW_DS_EXPORT __attribute__((visibility("default"))) -#endif -#ifndef ARROW_DS_NO_EXPORT -#define ARROW_DS_NO_EXPORT __attribute__((visibility("hidden"))) -#endif +# ifndef ARROW_DS_EXPORT +# define ARROW_DS_EXPORT __attribute__((visibility("default"))) +# endif +# ifndef ARROW_DS_NO_EXPORT +# define ARROW_DS_NO_EXPORT __attribute__((visibility("hidden"))) +# endif #endif // Non-Windows #if defined(_MSC_VER) -#pragma warning(pop) +# pragma warning(pop) #endif diff --git a/cpp/src/arrow/engine/substrait/visibility.h b/cpp/src/arrow/engine/substrait/visibility.h index d81d202ee6567..9ed1c67352d60 100644 --- a/cpp/src/arrow/engine/substrait/visibility.h +++ b/cpp/src/arrow/engine/substrait/visibility.h @@ -22,31 +22,31 @@ #pragma once #if defined(_WIN32) || defined(__CYGWIN__) -#if defined(_MSC_VER) -#pragma warning(push) -#pragma warning(disable : 4251) -#else -#pragma GCC diagnostic ignored "-Wattributes" -#endif +# if defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable : 4251) +# else +# pragma GCC diagnostic ignored "-Wattributes" +# endif -#ifdef ARROW_ENGINE_STATIC -#define ARROW_ENGINE_EXPORT -#elif defined(ARROW_ENGINE_EXPORTING) -#define ARROW_ENGINE_EXPORT __declspec(dllexport) -#else -#define ARROW_ENGINE_EXPORT __declspec(dllimport) -#endif +# ifdef ARROW_ENGINE_STATIC +# define ARROW_ENGINE_EXPORT +# elif defined(ARROW_ENGINE_EXPORTING) +# define ARROW_ENGINE_EXPORT __declspec(dllexport) +# else +# define ARROW_ENGINE_EXPORT __declspec(dllimport) +# endif -#define ARROW_ENGINE_NO_EXPORT +# define ARROW_ENGINE_NO_EXPORT #else // Not Windows -#ifndef ARROW_ENGINE_EXPORT -#define ARROW_ENGINE_EXPORT __attribute__((visibility("default"))) -#endif -#ifndef ARROW_ENGINE_NO_EXPORT -#define ARROW_ENGINE_NO_EXPORT __attribute__((visibility("hidden"))) -#endif +# ifndef ARROW_ENGINE_EXPORT +# define ARROW_ENGINE_EXPORT __attribute__((visibility("default"))) +# endif +# ifndef ARROW_ENGINE_NO_EXPORT +# define ARROW_ENGINE_NO_EXPORT __attribute__((visibility("hidden"))) +# endif #endif // Non-Windows #if defined(_MSC_VER) -#pragma warning(pop) +# pragma warning(pop) #endif diff --git a/cpp/src/arrow/extension_type.cc b/cpp/src/arrow/extension_type.cc index fc220f73a6beb..d0135e905a0c3 100644 --- a/cpp/src/arrow/extension_type.cc +++ b/cpp/src/arrow/extension_type.cc @@ -29,8 +29,8 @@ #include "arrow/config.h" #include "arrow/extension/bool8.h" #ifdef ARROW_JSON -#include "arrow/extension/fixed_shape_tensor.h" -#include "arrow/extension/opaque.h" +# include "arrow/extension/fixed_shape_tensor.h" +# include "arrow/extension/opaque.h" #endif #include "arrow/extension/uuid.h" #include "arrow/status.h" diff --git a/cpp/src/arrow/filesystem/api.h b/cpp/src/arrow/filesystem/api.h index 562b7c1808ec1..7211ad5c2ccdb 100644 --- a/cpp/src/arrow/filesystem/api.h +++ b/cpp/src/arrow/filesystem/api.h @@ -21,14 +21,14 @@ #include "arrow/filesystem/filesystem.h" // IWYU pragma: export #ifdef ARROW_AZURE -#include "arrow/filesystem/azurefs.h" // IWYU pragma: export +# include "arrow/filesystem/azurefs.h" // IWYU pragma: export #endif #ifdef ARROW_GCS -#include "arrow/filesystem/gcsfs.h" // IWYU pragma: export +# include "arrow/filesystem/gcsfs.h" // IWYU pragma: export #endif #include "arrow/filesystem/hdfs.h" // IWYU pragma: export #include "arrow/filesystem/localfs.h" // IWYU pragma: export #include "arrow/filesystem/mockfs.h" // IWYU pragma: export #ifdef ARROW_S3 -#include "arrow/filesystem/s3fs.h" // IWYU pragma: export +# include "arrow/filesystem/s3fs.h" // IWYU pragma: export #endif diff --git a/cpp/src/arrow/filesystem/azurefs.cc b/cpp/src/arrow/filesystem/azurefs.cc index 0bad856339729..d407b1654f5b5 100644 --- a/cpp/src/arrow/filesystem/azurefs.cc +++ b/cpp/src/arrow/filesystem/azurefs.cc @@ -27,12 +27,12 @@ // idenfity.hpp triggers -Wattributes warnings cause -Werror builds to fail, // so disable it for this file with pragmas. #if defined(__GNUC__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wattributes" +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wattributes" #endif #include #if defined(__GNUC__) -#pragma GCC diagnostic pop +# pragma GCC diagnostic pop #endif #include #include diff --git a/cpp/src/arrow/filesystem/filesystem.cc b/cpp/src/arrow/filesystem/filesystem.cc index 284be685fa800..b5765010ec7e9 100644 --- a/cpp/src/arrow/filesystem/filesystem.cc +++ b/cpp/src/arrow/filesystem/filesystem.cc @@ -26,16 +26,16 @@ #include "arrow/filesystem/filesystem.h" #ifdef ARROW_AZURE -#include "arrow/filesystem/azurefs.h" +# include "arrow/filesystem/azurefs.h" #endif #ifdef ARROW_GCS -#include "arrow/filesystem/gcsfs.h" +# include "arrow/filesystem/gcsfs.h" #endif #ifdef ARROW_HDFS -#include "arrow/filesystem/hdfs.h" +# include "arrow/filesystem/hdfs.h" #endif #ifdef ARROW_S3 -#include "arrow/filesystem/s3fs.h" +# include "arrow/filesystem/s3fs.h" #endif #include "arrow/filesystem/localfs.h" #include "arrow/filesystem/mockfs.h" diff --git a/cpp/src/arrow/filesystem/localfs.cc b/cpp/src/arrow/filesystem/localfs.cc index 22d802d8f9f7f..9fe19cbf25058 100644 --- a/cpp/src/arrow/filesystem/localfs.cc +++ b/cpp/src/arrow/filesystem/localfs.cc @@ -22,12 +22,12 @@ #include #ifdef _WIN32 -#include "arrow/util/windows_compatibility.h" +# include "arrow/util/windows_compatibility.h" #else -#include -#include -#include -#include +# include +# include +# include +# include #endif #include "arrow/filesystem/filesystem.h" @@ -157,12 +157,12 @@ FileInfo StatToFileInfo(const struct stat& s) { info.set_type(FileType::Unknown); info.set_size(kNoSize); } -#ifdef __APPLE__ +# ifdef __APPLE__ // macOS doesn't use the POSIX-compliant spelling info.set_mtime(ToTimePoint(s.st_mtimespec)); -#else +# else info.set_mtime(ToTimePoint(s.st_mtim)); -#endif +# endif return info; } diff --git a/cpp/src/arrow/filesystem/s3_test_util.cc b/cpp/src/arrow/filesystem/s3_test_util.cc index 003afa68f1e35..db0c60f2e80f2 100644 --- a/cpp/src/arrow/filesystem/s3_test_util.cc +++ b/cpp/src/arrow/filesystem/s3_test_util.cc @@ -16,7 +16,7 @@ // under the License. #ifndef _WIN32 -#include +# include #endif #include "arrow/filesystem/s3_test_util.h" diff --git a/cpp/src/arrow/filesystem/s3fs.cc b/cpp/src/arrow/filesystem/s3fs.cc index fd5b2e5be2a3a..96c771aeb61b8 100644 --- a/cpp/src/arrow/filesystem/s3fs.cc +++ b/cpp/src/arrow/filesystem/s3fs.cc @@ -34,12 +34,12 @@ #ifdef _WIN32 // Undefine preprocessor macros that interfere with AWS function / method names -#ifdef GetMessage -#undef GetMessage -#endif -#ifdef GetObject -#undef GetObject -#endif +# ifdef GetMessage +# undef GetMessage +# endif +# ifdef GetObject +# undef GetObject +# endif #endif #include @@ -84,13 +84,13 @@ // Redundant "(...)" are for suppressing "Weird number of spaces at // line-start. Are you using a 2-space indent? [whitespace/indent] // [3]" errors... -#define ARROW_AWS_SDK_VERSION_CHECK(major, minor, patch) \ - ((AWS_SDK_VERSION_MAJOR > (major) || \ - (AWS_SDK_VERSION_MAJOR == (major) && AWS_SDK_VERSION_MINOR > (minor)) || \ - ((AWS_SDK_VERSION_MAJOR == (major) && AWS_SDK_VERSION_MINOR == (minor) && \ - AWS_SDK_VERSION_PATCH >= (patch))))) +# define ARROW_AWS_SDK_VERSION_CHECK(major, minor, patch) \ + ((AWS_SDK_VERSION_MAJOR > (major) || \ + (AWS_SDK_VERSION_MAJOR == (major) && AWS_SDK_VERSION_MINOR > (minor)) || \ + ((AWS_SDK_VERSION_MAJOR == (major) && AWS_SDK_VERSION_MINOR == (minor) && \ + AWS_SDK_VERSION_PATCH >= (patch))))) #else -#define ARROW_AWS_SDK_VERSION_CHECK(major, minor, patch) 0 +# define ARROW_AWS_SDK_VERSION_CHECK(major, minor, patch) 0 #endif // This feature is available since 1.9.0 but @@ -98,22 +98,22 @@ // we can't use this feature for [1.9.0,1.9.6]. If it's a problem, // please report it to our issue tracker. #if ARROW_AWS_SDK_VERSION_CHECK(1, 9, 0) -#define ARROW_S3_HAS_CRT +# define ARROW_S3_HAS_CRT #endif #if ARROW_AWS_SDK_VERSION_CHECK(1, 10, 0) -#define ARROW_S3_HAS_S3CLIENT_CONFIGURATION +# define ARROW_S3_HAS_S3CLIENT_CONFIGURATION #endif #ifdef ARROW_S3_HAS_CRT -#include -#include -#include +# include +# include +# include #endif #ifdef ARROW_S3_HAS_S3CLIENT_CONFIGURATION -#include -#include +# include +# include #endif #include "arrow/util/windows_fixup.h" diff --git a/cpp/src/arrow/filesystem/s3fs_test.cc b/cpp/src/arrow/filesystem/s3fs_test.cc index c33fa4f5aac97..82a7d6e546ef3 100644 --- a/cpp/src/arrow/filesystem/s3fs_test.cc +++ b/cpp/src/arrow/filesystem/s3fs_test.cc @@ -28,12 +28,12 @@ #ifdef _WIN32 // Undefine preprocessor macros that interfere with AWS function / method names -#ifdef GetMessage -#undef GetMessage -#endif -#ifdef GetObject -#undef GetObject -#endif +# ifdef GetMessage +# undef GetMessage +# endif +# ifdef GetObject +# undef GetObject +# endif #endif #include diff --git a/cpp/src/arrow/flight/client.h b/cpp/src/arrow/flight/client.h index 613903108949e..ae6011b117aa7 100644 --- a/cpp/src/arrow/flight/client.h +++ b/cpp/src/arrow/flight/client.h @@ -146,8 +146,8 @@ class ARROW_FLIGHT_EXPORT FlightStreamReader : public MetadataRecordBatchReader // Silence warning // "non dll-interface class RecordBatchReader used as base for dll-interface class" #ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4275) +# pragma warning(push) +# pragma warning(disable : 4275) #endif /// \brief A RecordBatchWriter that also allows sending @@ -163,7 +163,7 @@ class ARROW_FLIGHT_EXPORT FlightStreamWriter : public MetadataRecordBatchWriter }; #ifdef _MSC_VER -#pragma warning(pop) +# pragma warning(pop) #endif /// \brief A reader for application-specific metadata sent back to the diff --git a/cpp/src/arrow/flight/client_tracing_middleware.cc b/cpp/src/arrow/flight/client_tracing_middleware.cc index a45784bd31ecd..9433ed48509aa 100644 --- a/cpp/src/arrow/flight/client_tracing_middleware.cc +++ b/cpp/src/arrow/flight/client_tracing_middleware.cc @@ -25,8 +25,8 @@ #include "arrow/util/tracing_internal.h" #ifdef ARROW_WITH_OPENTELEMETRY -#include -#include +# include +# include #endif namespace arrow { diff --git a/cpp/src/arrow/flight/cookie_internal.cc b/cpp/src/arrow/flight/cookie_internal.cc index 75a10d148bf47..99fa8b238ddc8 100644 --- a/cpp/src/arrow/flight/cookie_internal.cc +++ b/cpp/src/arrow/flight/cookie_internal.cc @@ -28,7 +28,7 @@ // Mingw-w64 defines strcasecmp in string.h #if defined(_WIN32) && !defined(strcasecmp) -#define strcasecmp stricmp +# define strcasecmp stricmp #endif #include diff --git a/cpp/src/arrow/flight/flight_benchmark.cc b/cpp/src/arrow/flight/flight_benchmark.cc index 661c47737f024..1383788e08233 100644 --- a/cpp/src/arrow/flight/flight_benchmark.cc +++ b/cpp/src/arrow/flight/flight_benchmark.cc @@ -40,11 +40,11 @@ #include "arrow/flight/test_util.h" #ifdef ARROW_CUDA -#include -#include "arrow/gpu/cuda_api.h" +# include +# include "arrow/gpu/cuda_api.h" #endif #ifdef ARROW_WITH_UCX -#include "arrow/flight/transport/ucx/ucx.h" +# include "arrow/flight/transport/ucx/ucx.h" #endif DEFINE_bool(cuda, false, "Allocate results in CUDA memory"); diff --git a/cpp/src/arrow/flight/flight_test.cc b/cpp/src/arrow/flight/flight_test.cc index 6425233dadec4..863f21f8db5e4 100644 --- a/cpp/src/arrow/flight/flight_test.cc +++ b/cpp/src/arrow/flight/flight_test.cc @@ -44,7 +44,7 @@ #include "arrow/util/logging.h" #ifdef GRPCPP_GRPCPP_H -#error "gRPC headers should not be in public API" +# error "gRPC headers should not be in public API" #endif #include @@ -71,11 +71,11 @@ // > between the two different versions of Abseil. #include "arrow/util/tracing_internal.h" #ifdef ARROW_WITH_OPENTELEMETRY -#include -#include -#include -#include -#include +# include +# include +# include +# include +# include #endif namespace arrow { diff --git a/cpp/src/arrow/flight/otel_logging.h b/cpp/src/arrow/flight/otel_logging.h index 9a91e5d99ce7d..d1e8cbb6fcc64 100644 --- a/cpp/src/arrow/flight/otel_logging.h +++ b/cpp/src/arrow/flight/otel_logging.h @@ -20,9 +20,9 @@ #include "arrow/util/config.h" #ifdef ARROW_WITH_OPENTELEMETRY -#include "arrow/status.h" -#include "arrow/telemetry/logging.h" -#include "arrow/util/macros.h" +# include "arrow/status.h" +# include "arrow/telemetry/logging.h" +# include "arrow/util/macros.h" namespace arrow::flight { diff --git a/cpp/src/arrow/flight/otel_logging_internal.h b/cpp/src/arrow/flight/otel_logging_internal.h index 52602f0fe8aa5..426692297c362 100644 --- a/cpp/src/arrow/flight/otel_logging_internal.h +++ b/cpp/src/arrow/flight/otel_logging_internal.h @@ -21,8 +21,8 @@ #include "arrow/util/macros.h" #ifdef ARROW_WITH_OPENTELEMETRY -#include "arrow/flight/otel_logging.h" -#include "arrow/util/logger.h" +# include "arrow/flight/otel_logging.h" +# include "arrow/util/logger.h" namespace arrow::flight::internal { @@ -33,24 +33,24 @@ ARROW_EXPORT std::shared_ptr GetOtelSqlServerLogger(); } // namespace arrow::flight::internal -#define ARROW_FLIGHT_OTELLOG_CLIENT(LEVEL, ...) \ - ARROW_LOGGER_CALL(::arrow::flight::internal::GetOtelGrpcClientLogger(), LEVEL, \ - __VA_ARGS__) -#define ARROW_FLIGHT_OTELLOG_SERVER(LEVEL, ...) \ - ARROW_LOGGER_CALL(::arrow::flight::internal::GetOtelGrpcServerLogger(), LEVEL, \ - __VA_ARGS__) -#define ARROW_FLIGHT_OTELLOG_SQL_CLIENT(LEVEL, ...) \ - ARROW_LOGGER_CALL(::arrow::flight::internal::GetOtelSqlClientLogger(), LEVEL, \ - __VA_ARGS__) -#define ARROW_FLIGHT_OTELLOG_SQL_SERVER(LEVEL, ...) \ - ARROW_LOGGER_CALL(::arrow::flight::internal::GetOtelSqlServerLogger(), LEVEL, \ - __VA_ARGS__) +# define ARROW_FLIGHT_OTELLOG_CLIENT(LEVEL, ...) \ + ARROW_LOGGER_CALL(::arrow::flight::internal::GetOtelGrpcClientLogger(), LEVEL, \ + __VA_ARGS__) +# define ARROW_FLIGHT_OTELLOG_SERVER(LEVEL, ...) \ + ARROW_LOGGER_CALL(::arrow::flight::internal::GetOtelGrpcServerLogger(), LEVEL, \ + __VA_ARGS__) +# define ARROW_FLIGHT_OTELLOG_SQL_CLIENT(LEVEL, ...) \ + ARROW_LOGGER_CALL(::arrow::flight::internal::GetOtelSqlClientLogger(), LEVEL, \ + __VA_ARGS__) +# define ARROW_FLIGHT_OTELLOG_SQL_SERVER(LEVEL, ...) \ + ARROW_LOGGER_CALL(::arrow::flight::internal::GetOtelSqlServerLogger(), LEVEL, \ + __VA_ARGS__) #else -#define ARROW_FLIGHT_OTELLOG_CLIENT(LEVEL, ...) ARROW_UNUSED(0) -#define ARROW_FLIGHT_OTELLOG_SERVER(LEVEL, ...) ARROW_UNUSED(0) -#define ARROW_FLIGHT_OTELLOG_SQL_CLIENT(LEVEL, ...) ARROW_UNUSED(0) -#define ARROW_FLIGHT_OTELLOG_SQL_SERVER(LEVEL, ...) ARROW_UNUSED(0) +# define ARROW_FLIGHT_OTELLOG_CLIENT(LEVEL, ...) ARROW_UNUSED(0) +# define ARROW_FLIGHT_OTELLOG_SERVER(LEVEL, ...) ARROW_UNUSED(0) +# define ARROW_FLIGHT_OTELLOG_SQL_CLIENT(LEVEL, ...) ARROW_UNUSED(0) +# define ARROW_FLIGHT_OTELLOG_SQL_SERVER(LEVEL, ...) ARROW_UNUSED(0) #endif diff --git a/cpp/src/arrow/flight/perf_server.cc b/cpp/src/arrow/flight/perf_server.cc index 87676da11213d..e6477edd7050a 100644 --- a/cpp/src/arrow/flight/perf_server.cc +++ b/cpp/src/arrow/flight/perf_server.cc @@ -42,10 +42,10 @@ #include "arrow/flight/test_util.h" #ifdef ARROW_CUDA -#include "arrow/gpu/cuda_api.h" +# include "arrow/gpu/cuda_api.h" #endif #ifdef ARROW_WITH_UCX -#include "arrow/flight/transport/ucx/ucx.h" +# include "arrow/flight/transport/ucx/ucx.h" #endif DEFINE_bool(cuda, false, "Allocate results in CUDA memory"); diff --git a/cpp/src/arrow/flight/platform.h b/cpp/src/arrow/flight/platform.h index 8f8db2d2dc805..498c87c5b7dc9 100644 --- a/cpp/src/arrow/flight/platform.h +++ b/cpp/src/arrow/flight/platform.h @@ -24,7 +24,7 @@ // The protobuf documentation says that C4251 warnings when using the // library are spurious and suppressed when the build the library and // compiler, but must be also suppressed in downstream projects -#pragma warning(disable : 4251) +# pragma warning(disable : 4251) #endif // _MSC_VER diff --git a/cpp/src/arrow/flight/server.cc b/cpp/src/arrow/flight/server.cc index 06512bda36a49..adbdfb85f29e6 100644 --- a/cpp/src/arrow/flight/server.cc +++ b/cpp/src/arrow/flight/server.cc @@ -47,7 +47,7 @@ namespace flight { namespace { #if (ATOMIC_INT_LOCK_FREE != 2 || ATOMIC_POINTER_LOCK_FREE != 2) -#error "atomic ints and atomic pointers not always lock-free!" +# error "atomic ints and atomic pointers not always lock-free!" #endif using ::arrow::internal::SelfPipe; diff --git a/cpp/src/arrow/flight/server_tracing_middleware.cc b/cpp/src/arrow/flight/server_tracing_middleware.cc index 02520cb66fd0e..6884308c7ff48 100644 --- a/cpp/src/arrow/flight/server_tracing_middleware.cc +++ b/cpp/src/arrow/flight/server_tracing_middleware.cc @@ -27,11 +27,11 @@ #include "arrow/util/tracing_internal.h" #ifdef ARROW_WITH_OPENTELEMETRY -#include -#include -#include -#include -#include +# include +# include +# include +# include +# include #endif namespace arrow { diff --git a/cpp/src/arrow/flight/sql/test_app_cli.cc b/cpp/src/arrow/flight/sql/test_app_cli.cc index 194ecf5e57808..c5606a605e018 100644 --- a/cpp/src/arrow/flight/sql/test_app_cli.cc +++ b/cpp/src/arrow/flight/sql/test_app_cli.cc @@ -35,16 +35,16 @@ #include "arrow/table.h" #ifdef ARROW_WITH_OPENTELEMETRY -#include "arrow/flight/otel_logging.h" -#include "arrow/util/tracing_internal.h" - -#include -#include -#include -#include -#include -#include -#include +# include "arrow/flight/otel_logging.h" +# include "arrow/util/tracing_internal.h" + +# include +# include +# include +# include +# include +# include +# include #endif using arrow::Result; diff --git a/cpp/src/arrow/flight/sql/test_server_cli.cc b/cpp/src/arrow/flight/sql/test_server_cli.cc index a8124140497c6..b632851a1f97c 100644 --- a/cpp/src/arrow/flight/sql/test_server_cli.cc +++ b/cpp/src/arrow/flight/sql/test_server_cli.cc @@ -31,12 +31,12 @@ #include "arrow/util/logging.h" #ifdef ARROW_WITH_OPENTELEMETRY -#include "arrow/flight/otel_logging.h" -#include "arrow/util/tracing_internal.h" +# include "arrow/flight/otel_logging.h" +# include "arrow/util/tracing_internal.h" -#include -#include -#include +# include +# include +# include #endif DEFINE_int32(port, 31337, "Server port to listen on"); diff --git a/cpp/src/arrow/flight/sql/visibility.h b/cpp/src/arrow/flight/sql/visibility.h index 2074815e0a246..cdd8fd953d19f 100644 --- a/cpp/src/arrow/flight/sql/visibility.h +++ b/cpp/src/arrow/flight/sql/visibility.h @@ -18,31 +18,31 @@ #pragma once #if defined(_WIN32) || defined(__CYGWIN__) -#if defined(_MSC_VER) -#pragma warning(push) -#pragma warning(disable : 4251) -#else -#pragma GCC diagnostic ignored "-Wattributes" -#endif +# if defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable : 4251) +# else +# pragma GCC diagnostic ignored "-Wattributes" +# endif -#ifdef ARROW_FLIGHT_SQL_STATIC -#define ARROW_FLIGHT_SQL_EXPORT -#elif defined(ARROW_FLIGHT_SQL_EXPORTING) -#define ARROW_FLIGHT_SQL_EXPORT __declspec(dllexport) -#else -#define ARROW_FLIGHT_SQL_EXPORT __declspec(dllimport) -#endif +# ifdef ARROW_FLIGHT_SQL_STATIC +# define ARROW_FLIGHT_SQL_EXPORT +# elif defined(ARROW_FLIGHT_SQL_EXPORTING) +# define ARROW_FLIGHT_SQL_EXPORT __declspec(dllexport) +# else +# define ARROW_FLIGHT_SQL_EXPORT __declspec(dllimport) +# endif -#define ARROW_FLIGHT_SQL_NO_EXPORT +# define ARROW_FLIGHT_SQL_NO_EXPORT #else // Not Windows -#ifndef ARROW_FLIGHT_SQL_EXPORT -#define ARROW_FLIGHT_SQL_EXPORT __attribute__((visibility("default"))) -#endif -#ifndef ARROW_FLIGHT_SQL_NO_EXPORT -#define ARROW_FLIGHT_SQL_NO_EXPORT __attribute__((visibility("hidden"))) -#endif +# ifndef ARROW_FLIGHT_SQL_EXPORT +# define ARROW_FLIGHT_SQL_EXPORT __attribute__((visibility("default"))) +# endif +# ifndef ARROW_FLIGHT_SQL_NO_EXPORT +# define ARROW_FLIGHT_SQL_NO_EXPORT __attribute__((visibility("hidden"))) +# endif #endif // Non-Windows #if defined(_MSC_VER) -#pragma warning(pop) +# pragma warning(pop) #endif diff --git a/cpp/src/arrow/flight/test_definitions.cc b/cpp/src/arrow/flight/test_definitions.cc index 273d394c288d9..ea6576088f2f5 100644 --- a/cpp/src/arrow/flight/test_definitions.cc +++ b/cpp/src/arrow/flight/test_definitions.cc @@ -42,7 +42,7 @@ #include "gmock/gmock.h" #if defined(ARROW_CUDA) -#include "arrow/gpu/cuda_api.h" +# include "arrow/gpu/cuda_api.h" #endif namespace arrow { diff --git a/cpp/src/arrow/flight/transport/grpc/customize_grpc.h b/cpp/src/arrow/flight/transport/grpc/customize_grpc.h index 5005fc6b16eb4..b668022087587 100644 --- a/cpp/src/arrow/flight/transport/grpc/customize_grpc.h +++ b/cpp/src/arrow/flight/transport/grpc/customize_grpc.h @@ -26,16 +26,16 @@ // Silence protobuf warnings #ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4244) -#pragma warning(disable : 4267) +# pragma warning(push) +# pragma warning(disable : 4244) +# pragma warning(disable : 4267) #endif #include #include #ifdef _MSC_VER -#pragma warning(pop) +# pragma warning(pop) #endif namespace grpc { diff --git a/cpp/src/arrow/flight/transport/grpc/grpc_client.cc b/cpp/src/arrow/flight/transport/grpc/grpc_client.cc index 0eb7549134a04..22e8676707342 100644 --- a/cpp/src/arrow/flight/transport/grpc/grpc_client.cc +++ b/cpp/src/arrow/flight/transport/grpc/grpc_client.cc @@ -31,7 +31,7 @@ #include #include #if defined(GRPC_NAMESPACE_FOR_TLS_CREDENTIALS_OPTIONS) -#include +# include #endif #include @@ -670,11 +670,11 @@ class UnaryUnaryAsyncCall : public ::grpc::ClientUnaryReactor, public internal:: } }; -#define LISTENER_NOT_OK(LISTENER, EXPR) \ - if (auto arrow_status = (EXPR); !arrow_status.ok()) { \ - (LISTENER)->OnFinish(std::move(arrow_status)); \ - return; \ - } +# define LISTENER_NOT_OK(LISTENER, EXPR) \ + if (auto arrow_status = (EXPR); !arrow_status.ok()) { \ + (LISTENER)->OnFinish(std::move(arrow_status)); \ + return; \ + } #endif class GrpcClientImpl : public internal::ClientTransport { @@ -697,7 +697,7 @@ class GrpcClientImpl : public internal::ClientTransport { #if defined(GRPC_NAMESPACE_FOR_TLS_CREDENTIALS_OPTIONS) namespace ge = ::GRPC_NAMESPACE_FOR_TLS_CREDENTIALS_OPTIONS; -#if defined(GRPC_USE_CERTIFICATE_VERIFIER) +# if defined(GRPC_USE_CERTIFICATE_VERIFIER) // gRPC >= 1.43 class NoOpCertificateVerifier : public ge::ExternalCertificateVerifier { public: @@ -712,10 +712,10 @@ class GrpcClientImpl : public internal::ClientTransport { auto cert_verifier = ge::ExternalCertificateVerifier::Create(); -#else // defined(GRPC_USE_CERTIFICATE_VERIFIER) - // gRPC < 1.43 - // A callback to supply to TlsCredentialsOptions that accepts any server - // arguments. +# else // defined(GRPC_USE_CERTIFICATE_VERIFIER) + // gRPC < 1.43 + // A callback to supply to TlsCredentialsOptions that accepts any server + // arguments. struct NoOpTlsAuthorizationCheck : public ge::TlsServerAuthorizationCheckInterface { int Schedule(ge::TlsServerAuthorizationCheckArg* arg) override { @@ -727,33 +727,33 @@ class GrpcClientImpl : public internal::ClientTransport { auto server_authorization_check = std::make_shared(); noop_auth_check_ = std::make_shared( server_authorization_check); -#endif // defined(GRPC_USE_CERTIFICATE_VERIFIER) +# endif // defined(GRPC_USE_CERTIFICATE_VERIFIER) -#if defined(GRPC_USE_TLS_CHANNEL_CREDENTIALS_OPTIONS) +# if defined(GRPC_USE_TLS_CHANNEL_CREDENTIALS_OPTIONS) auto certificate_provider = std::make_shared<::grpc::experimental::StaticDataCertificateProvider>( kDummyRootCert); -#if defined(GRPC_USE_TLS_CHANNEL_CREDENTIALS_OPTIONS_ROOT_CERTS) +# if defined(GRPC_USE_TLS_CHANNEL_CREDENTIALS_OPTIONS_ROOT_CERTS) ::grpc::experimental::TlsChannelCredentialsOptions tls_options( certificate_provider); -#else // defined(GRPC_USE_TLS_CHANNEL_CREDENTIALS_OPTIONS_ROOT_CERTS) - // While gRPC >= 1.36 does not require a root cert (it has a default) - // in practice the path it hardcodes is broken. See grpc/grpc#21655. +# else // defined(GRPC_USE_TLS_CHANNEL_CREDENTIALS_OPTIONS_ROOT_CERTS) + // While gRPC >= 1.36 does not require a root cert (it has a default) + // in practice the path it hardcodes is broken. See grpc/grpc#21655. ::grpc::experimental::TlsChannelCredentialsOptions tls_options; tls_options.set_certificate_provider(certificate_provider); -#endif // defined(GRPC_USE_TLS_CHANNEL_CREDENTIALS_OPTIONS_ROOT_CERTS) +# endif // defined(GRPC_USE_TLS_CHANNEL_CREDENTIALS_OPTIONS_ROOT_CERTS) tls_options.watch_root_certs(); tls_options.set_root_cert_name("dummy"); -#if defined(GRPC_USE_CERTIFICATE_VERIFIER) +# if defined(GRPC_USE_CERTIFICATE_VERIFIER) tls_options.set_certificate_verifier(std::move(cert_verifier)); tls_options.set_check_call_host(false); tls_options.set_verify_server_certs(false); -#else // defined(GRPC_USE_CERTIFICATE_VERIFIER) +# else // defined(GRPC_USE_CERTIFICATE_VERIFIER) tls_options.set_server_verification_option( grpc_tls_server_verification_option::GRPC_TLS_SKIP_ALL_SERVER_VERIFICATION); tls_options.set_server_authorization_check_config(noop_auth_check_); -#endif // defined(GRPC_USE_CERTIFICATE_VERIFIER) -#elif defined(GRPC_NAMESPACE_FOR_TLS_CREDENTIALS_OPTIONS) +# endif // defined(GRPC_USE_CERTIFICATE_VERIFIER) +# elif defined(GRPC_NAMESPACE_FOR_TLS_CREDENTIALS_OPTIONS) // continues defined(GRPC_USE_TLS_CHANNEL_CREDENTIALS_OPTIONS) auto materials_config = std::make_shared(); materials_config->set_pem_root_certs(kDummyRootCert); @@ -761,7 +761,7 @@ class GrpcClientImpl : public internal::ClientTransport { GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE, GRPC_TLS_SKIP_ALL_SERVER_VERIFICATION, materials_config, std::shared_ptr(), noop_auth_check_); -#endif // defined(GRPC_USE_TLS_CHANNEL_CREDENTIALS_OPTIONS) +# endif // defined(GRPC_USE_TLS_CHANNEL_CREDENTIALS_OPTIONS) creds = ge::TlsCredentials(tls_options); #else // defined(GRPC_NAMESPACE_FOR_TLS_CREDENTIALS_OPTIONS) return Status::NotImplemented( diff --git a/cpp/src/arrow/flight/transport/grpc/serialization_internal.cc b/cpp/src/arrow/flight/transport/grpc/serialization_internal.cc index 3df13532b0b05..9b503ede05655 100644 --- a/cpp/src/arrow/flight/transport/grpc/serialization_internal.cc +++ b/cpp/src/arrow/flight/transport/grpc/serialization_internal.cc @@ -28,8 +28,8 @@ #include "arrow/flight/platform.h" #if defined(_MSC_VER) -#pragma warning(push) -#pragma warning(disable : 4267) +# pragma warning(push) +# pragma warning(disable : 4267) #endif #include @@ -41,7 +41,7 @@ #include #if defined(_MSC_VER) -#pragma warning(pop) +# pragma warning(pop) #endif #include "arrow/buffer.h" @@ -400,8 +400,8 @@ ::grpc::Status FlightDataDeserialize(ByteBuffer* buffer, // The pointer bitcast hack below causes legitimate warnings, silence them. #ifndef _WIN32 -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wstrict-aliasing" +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif // Pointer bitcast explanation: grpc::*Writer::Write() and grpc::*Reader::Read() @@ -478,7 +478,7 @@ bool ReadPayload(::grpc::ClientReaderWriter* read } #ifndef _WIN32 -#pragma GCC diagnostic pop +# pragma GCC diagnostic pop #endif } // namespace grpc diff --git a/cpp/src/arrow/flight/transport/ucx/flight_transport_ucx_test.cc b/cpp/src/arrow/flight/transport/ucx/flight_transport_ucx_test.cc index c3481d834f6ea..1090b8356294a 100644 --- a/cpp/src/arrow/flight/transport/ucx/flight_transport_ucx_test.cc +++ b/cpp/src/arrow/flight/transport/ucx/flight_transport_ucx_test.cc @@ -27,13 +27,13 @@ #include "arrow/util/config.h" #ifdef UCP_API_VERSION -#error "UCX headers should not be in public API" +# error "UCX headers should not be in public API" #endif #include "arrow/flight/transport/ucx/ucx_internal.h" #ifdef ARROW_CUDA -#include "arrow/gpu/cuda_api.h" +# include "arrow/gpu/cuda_api.h" #endif namespace arrow { diff --git a/cpp/src/arrow/flight/types.h b/cpp/src/arrow/flight/types.h index fc54bce9758b2..b6309d0af2a71 100644 --- a/cpp/src/arrow/flight/types.h +++ b/cpp/src/arrow/flight/types.h @@ -104,8 +104,8 @@ enum class FlightStatusCode : int8_t { // Silence warning // "non dll-interface class RecordBatchReader used as base for dll-interface class" #ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4275) +# pragma warning(push) +# pragma warning(disable : 4275) #endif /// \brief Flight-specific error information in a Status. @@ -139,7 +139,7 @@ class ARROW_FLIGHT_EXPORT FlightStatusDetail : public arrow::StatusDetail { }; #ifdef _MSC_VER -#pragma warning(pop) +# pragma warning(pop) #endif /// \brief Make an appropriate Arrow status for the given diff --git a/cpp/src/arrow/flight/visibility.h b/cpp/src/arrow/flight/visibility.h index bdee8b751d8a3..06f864ba8cffc 100644 --- a/cpp/src/arrow/flight/visibility.h +++ b/cpp/src/arrow/flight/visibility.h @@ -18,31 +18,31 @@ #pragma once #if defined(_WIN32) || defined(__CYGWIN__) -#if defined(_MSC_VER) -#pragma warning(push) -#pragma warning(disable : 4251) -#else -#pragma GCC diagnostic ignored "-Wattributes" -#endif +# if defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable : 4251) +# else +# pragma GCC diagnostic ignored "-Wattributes" +# endif -#ifdef ARROW_FLIGHT_STATIC -#define ARROW_FLIGHT_EXPORT -#elif defined(ARROW_FLIGHT_EXPORTING) -#define ARROW_FLIGHT_EXPORT __declspec(dllexport) -#else -#define ARROW_FLIGHT_EXPORT __declspec(dllimport) -#endif +# ifdef ARROW_FLIGHT_STATIC +# define ARROW_FLIGHT_EXPORT +# elif defined(ARROW_FLIGHT_EXPORTING) +# define ARROW_FLIGHT_EXPORT __declspec(dllexport) +# else +# define ARROW_FLIGHT_EXPORT __declspec(dllimport) +# endif -#define ARROW_FLIGHT_NO_EXPORT +# define ARROW_FLIGHT_NO_EXPORT #else // Not Windows -#ifndef ARROW_FLIGHT_EXPORT -#define ARROW_FLIGHT_EXPORT __attribute__((visibility("default"))) -#endif -#ifndef ARROW_FLIGHT_NO_EXPORT -#define ARROW_FLIGHT_NO_EXPORT __attribute__((visibility("hidden"))) -#endif +# ifndef ARROW_FLIGHT_EXPORT +# define ARROW_FLIGHT_EXPORT __attribute__((visibility("default"))) +# endif +# ifndef ARROW_FLIGHT_NO_EXPORT +# define ARROW_FLIGHT_NO_EXPORT __attribute__((visibility("hidden"))) +# endif #endif // Non-Windows #if defined(_MSC_VER) -#pragma warning(pop) +# pragma warning(pop) #endif diff --git a/cpp/src/arrow/io/buffered_test.cc b/cpp/src/arrow/io/buffered_test.cc index cbf2c2cf06938..89fe4b159f341 100644 --- a/cpp/src/arrow/io/buffered_test.cc +++ b/cpp/src/arrow/io/buffered_test.cc @@ -16,8 +16,8 @@ // under the License. #ifndef _WIN32 -#include // IWYU pragma: keep -#include +# include // IWYU pragma: keep +# include #endif #include diff --git a/cpp/src/arrow/io/file.cc b/cpp/src/arrow/io/file.cc index a22accf65660a..9fda5b7fdc16e 100644 --- a/cpp/src/arrow/io/file.cc +++ b/cpp/src/arrow/io/file.cc @@ -19,16 +19,16 @@ // sys/mman.h not present in Visual Studio or Cygwin #ifdef _WIN32 -#ifndef NOMINMAX -#define NOMINMAX -#endif -#include "arrow/io/mman.h" -#undef Realloc -#undef Free +# ifndef NOMINMAX +# define NOMINMAX +# endif +# include "arrow/io/mman.h" +# undef Realloc +# undef Free #else -#include -#include -#include // IWYU pragma: keep +# include +# include +# include // IWYU pragma: keep #endif #include diff --git a/cpp/src/arrow/io/file_benchmark.cc b/cpp/src/arrow/io/file_benchmark.cc index 02ccfb6337f4b..bcaa1a9df014b 100644 --- a/cpp/src/arrow/io/file_benchmark.cc +++ b/cpp/src/arrow/io/file_benchmark.cc @@ -33,13 +33,13 @@ #ifdef _WIN32 -#include +# include #else -#include -#include -#include +# include +# include +# include #endif diff --git a/cpp/src/arrow/io/file_test.cc b/cpp/src/arrow/io/file_test.cc index af414891b950e..44a63e9fdfa81 100644 --- a/cpp/src/arrow/io/file_test.cc +++ b/cpp/src/arrow/io/file_test.cc @@ -16,8 +16,8 @@ // under the License. #ifndef _WIN32 -#include // IWYU pragma: keep -#include +# include // IWYU pragma: keep +# include #endif #include diff --git a/cpp/src/arrow/io/hdfs_internal.cc b/cpp/src/arrow/io/hdfs_internal.cc index 5619dd2435acc..0f46a6faff924 100644 --- a/cpp/src/arrow/io/hdfs_internal.cc +++ b/cpp/src/arrow/io/hdfs_internal.cc @@ -40,7 +40,7 @@ #include "arrow/util/basic_decimal.h" #ifndef _WIN32 -#include +# include #endif #include "arrow/result.h" @@ -162,13 +162,13 @@ Result> get_potential_libjvm_paths() { // SFrame uses /usr/libexec/java_home to find JAVA_HOME; for now we are // expecting users to set an environment variable #else -#if defined(__aarch64__) +# if defined(__aarch64__) const std::string prefix_arch{"arm64"}; const std::string suffix_arch{"aarch64"}; -#else +# else const std::string prefix_arch{"amd64"}; const std::string suffix_arch{"amd64"}; -#endif +# endif ARROW_ASSIGN_OR_RAISE( search_prefixes, MakeFilenameVector({ diff --git a/cpp/src/arrow/io/memory_benchmark.cc b/cpp/src/arrow/io/memory_benchmark.cc index e16bbaf03ec47..fda5e17e073bd 100644 --- a/cpp/src/arrow/io/memory_benchmark.cc +++ b/cpp/src/arrow/io/memory_benchmark.cc @@ -39,50 +39,50 @@ constexpr size_t kMemoryPerCore = 32 * 1024 * 1024; using BufferPtr = std::shared_ptr; #ifdef ARROW_WITH_BENCHMARKS_REFERENCE -#ifndef _MSC_VER +# ifndef _MSC_VER -#ifdef ARROW_HAVE_SSE4_2 +# ifdef ARROW_HAVE_SSE4_2 -#ifdef ARROW_HAVE_AVX512 +# ifdef ARROW_HAVE_AVX512 using VectorType = __m512i; -#define VectorSet _mm512_set1_epi32 -#define VectorLoad _mm512_stream_load_si512 -#define VectorLoadAsm(SRC, DST) \ - asm volatile("vmovaps %[src], %[dst]" : [dst] "=v"(DST) : [src] "m"(SRC) :) -#define VectorStreamLoad _mm512_stream_load_si512 -#define VectorStreamLoadAsm(SRC, DST) \ - asm volatile("vmovntdqa %[src], %[dst]" : [dst] "=v"(DST) : [src] "m"(SRC) :) -#define VectorStreamWrite _mm512_stream_si512 +# define VectorSet _mm512_set1_epi32 +# define VectorLoad _mm512_stream_load_si512 +# define VectorLoadAsm(SRC, DST) \ + asm volatile("vmovaps %[src], %[dst]" : [dst] "=v"(DST) : [src] "m"(SRC) :) +# define VectorStreamLoad _mm512_stream_load_si512 +# define VectorStreamLoadAsm(SRC, DST) \ + asm volatile("vmovntdqa %[src], %[dst]" : [dst] "=v"(DST) : [src] "m"(SRC) :) +# define VectorStreamWrite _mm512_stream_si512 -#else +# else -#ifdef ARROW_HAVE_AVX2 +# ifdef ARROW_HAVE_AVX2 using VectorType = __m256i; -#define VectorSet _mm256_set1_epi32 -#define VectorLoad _mm256_stream_load_si256 -#define VectorLoadAsm(SRC, DST) \ - asm volatile("vmovaps %[src], %[dst]" : [dst] "=v"(DST) : [src] "m"(SRC) :) -#define VectorStreamLoad _mm256_stream_load_si256 -#define VectorStreamLoadAsm(SRC, DST) \ - asm volatile("vmovntdqa %[src], %[dst]" : [dst] "=v"(DST) : [src] "m"(SRC) :) -#define VectorStreamWrite _mm256_stream_si256 +# define VectorSet _mm256_set1_epi32 +# define VectorLoad _mm256_stream_load_si256 +# define VectorLoadAsm(SRC, DST) \ + asm volatile("vmovaps %[src], %[dst]" : [dst] "=v"(DST) : [src] "m"(SRC) :) +# define VectorStreamLoad _mm256_stream_load_si256 +# define VectorStreamLoadAsm(SRC, DST) \ + asm volatile("vmovntdqa %[src], %[dst]" : [dst] "=v"(DST) : [src] "m"(SRC) :) +# define VectorStreamWrite _mm256_stream_si256 -#else // ARROW_HAVE_AVX2 not set +# else // ARROW_HAVE_AVX2 not set using VectorType = __m128i; -#define VectorSet _mm_set1_epi32 -#define VectorLoad _mm_stream_load_si128 -#define VectorLoadAsm(SRC, DST) \ - asm volatile("movaps %[src], %[dst]" : [dst] "=x"(DST) : [src] "m"(SRC) :) -#define VectorStreamLoad _mm_stream_load_si128 -#define VectorStreamLoadAsm(SRC, DST) \ - asm volatile("movntdqa %[src], %[dst]" : [dst] "=x"(DST) : [src] "m"(SRC) :) -#define VectorStreamWrite _mm_stream_si128 - -#endif // ARROW_HAVE_AVX2 -#endif // ARROW_HAVE_AVX512 +# define VectorSet _mm_set1_epi32 +# define VectorLoad _mm_stream_load_si128 +# define VectorLoadAsm(SRC, DST) \ + asm volatile("movaps %[src], %[dst]" : [dst] "=x"(DST) : [src] "m"(SRC) :) +# define VectorStreamLoad _mm_stream_load_si128 +# define VectorStreamLoadAsm(SRC, DST) \ + asm volatile("movntdqa %[src], %[dst]" : [dst] "=x"(DST) : [src] "m"(SRC) :) +# define VectorStreamWrite _mm_stream_si128 + +# endif // ARROW_HAVE_AVX2 +# endif // ARROW_HAVE_AVX512 static void Read(void* src, void* dst, size_t size) { const auto simd = static_cast(src); @@ -154,15 +154,15 @@ static void StreamReadWrite(void* src, void* dst, size_t size) { } } -#endif // ARROW_HAVE_SSE4_2 +# endif // ARROW_HAVE_SSE4_2 -#ifdef ARROW_HAVE_NEON +# ifdef ARROW_HAVE_NEON using VectorType = uint8x16_t; using VectorTypeDual = uint8x16x2_t; -#define VectorSet vdupq_n_u8 -#define VectorLoadAsm vld1q_u8 +# define VectorSet vdupq_n_u8 +# define VectorLoadAsm vld1q_u8 static void armv8_stream_load_pair(VectorType* src, VectorType* dst) { asm volatile("LDNP %[reg1], %[reg2], [%[from]]\n\t" @@ -239,7 +239,7 @@ static void StreamReadWrite(void* src, void* dst, size_t size) { } } -#endif // ARROW_HAVE_NEON +# endif // ARROW_HAVE_NEON static void PlatformMemcpy(void* src, void* dst, size_t size) { memcpy(src, dst, size); } @@ -261,7 +261,7 @@ static void MemoryBandwidth(benchmark::State& state) { // NOLINT non-const refe state.SetBytesProcessed(state.iterations() * buffer_size); } -#ifdef ARROW_HAVE_SSE4_2 +# ifdef ARROW_HAVE_SSE4_2 static void SetCacheBandwidthArgs(benchmark::internal::Benchmark* bench) { auto cache_sizes = {kL1Size, kL2Size, kL3Size}; for (auto size : cache_sizes) { @@ -274,7 +274,7 @@ static void SetCacheBandwidthArgs(benchmark::internal::Benchmark* bench) { } BENCHMARK_TEMPLATE(MemoryBandwidth, Read)->Apply(SetCacheBandwidthArgs); -#endif // ARROW_HAVE_SSE4_2 +# endif // ARROW_HAVE_SSE4_2 static void SetMemoryBandwidthArgs(benchmark::internal::Benchmark* bench) { // `UseRealTime` is required due to threads, otherwise the cumulative CPU time @@ -287,8 +287,8 @@ BENCHMARK_TEMPLATE(MemoryBandwidth, StreamWrite)->Apply(SetMemoryBandwidthArgs); BENCHMARK_TEMPLATE(MemoryBandwidth, StreamReadWrite)->Apply(SetMemoryBandwidthArgs); BENCHMARK_TEMPLATE(MemoryBandwidth, PlatformMemcpy)->Apply(SetMemoryBandwidthArgs); -#endif // _MSC_VER -#endif // ARROW_WITH_BENCHMARKS_REFERENCE +# endif // _MSC_VER +#endif // ARROW_WITH_BENCHMARKS_REFERENCE static void ParallelMemoryCopy(benchmark::State& state) { // NOLINT non-const reference const int64_t n_threads = state.range(0); diff --git a/cpp/src/arrow/io/mman.h b/cpp/src/arrow/io/mman.h index 9b06ac8e7b5ca..04d450cbff513 100644 --- a/cpp/src/arrow/io/mman.h +++ b/cpp/src/arrow/io/mman.h @@ -36,7 +36,7 @@ #define MS_INVALIDATE 4 #ifndef FILE_MAP_EXECUTE -#define FILE_MAP_EXECUTE 0x0020 +# define FILE_MAP_EXECUTE 0x0020 #endif static inline int __map_mman_error(const DWORD err, const int deferr) { diff --git a/cpp/src/arrow/io/test_common.cc b/cpp/src/arrow/io/test_common.cc index 5caa20a445e6d..a06ef2f59221c 100644 --- a/cpp/src/arrow/io/test_common.cc +++ b/cpp/src/arrow/io/test_common.cc @@ -23,7 +23,7 @@ #include #ifndef _WIN32 -#include +# include #endif #include "arrow/buffer.h" diff --git a/cpp/src/arrow/ipc/json_simple_test.cc b/cpp/src/arrow/ipc/json_simple_test.cc index c6f14b1e1d50e..d3201d8571b2c 100644 --- a/cpp/src/arrow/ipc/json_simple_test.cc +++ b/cpp/src/arrow/ipc/json_simple_test.cc @@ -48,7 +48,7 @@ #if defined(_MSC_VER) // "warning C4307: '+': integral constant overflow" -#pragma warning(disable : 4307) +# pragma warning(disable : 4307) #endif namespace arrow { diff --git a/cpp/src/arrow/ipc/read_write_benchmark.cc b/cpp/src/arrow/ipc/read_write_benchmark.cc index defe9790678c0..19ed2d3034e8d 100644 --- a/cpp/src/arrow/ipc/read_write_benchmark.cc +++ b/cpp/src/arrow/ipc/read_write_benchmark.cc @@ -185,24 +185,24 @@ static void DecodeStream(benchmark::State& state) { // NOLINT non-const referen } #ifdef ARROW_WITH_ZSTD -#define GENERATE_COMPRESSED_DATA_IN_MEMORY() \ - constexpr int64_t kBatchSize = 1 << 20; /* 1 MB */ \ - constexpr int64_t kBatches = 16; \ - auto options = ipc::IpcWriteOptions::Defaults(); \ - ASSIGN_OR_ABORT(options.codec, \ - arrow::util::Codec::Create(arrow::Compression::type::ZSTD)); \ - std::shared_ptr buffer = *AllocateResizableBuffer(1024); \ - { \ - auto record_batch = MakeRecordBatch(kBatchSize, state.range(0)); \ - io::BufferOutputStream stream(buffer); \ - auto writer = *ipc::MakeFileWriter(&stream, record_batch->schema(), options); \ - for (int i = 0; i < kBatches; i++) { \ - ABORT_NOT_OK(writer->WriteRecordBatch(*record_batch)); \ - } \ - ABORT_NOT_OK(writer->Close()); \ - ABORT_NOT_OK(stream.Close()); \ - } \ - constexpr int64_t total_size = kBatchSize * kBatches; +# define GENERATE_COMPRESSED_DATA_IN_MEMORY() \ + constexpr int64_t kBatchSize = 1 << 20; /* 1 MB */ \ + constexpr int64_t kBatches = 16; \ + auto options = ipc::IpcWriteOptions::Defaults(); \ + ASSIGN_OR_ABORT(options.codec, \ + arrow::util::Codec::Create(arrow::Compression::type::ZSTD)); \ + std::shared_ptr buffer = *AllocateResizableBuffer(1024); \ + { \ + auto record_batch = MakeRecordBatch(kBatchSize, state.range(0)); \ + io::BufferOutputStream stream(buffer); \ + auto writer = *ipc::MakeFileWriter(&stream, record_batch->schema(), options); \ + for (int i = 0; i < kBatches; i++) { \ + ABORT_NOT_OK(writer->WriteRecordBatch(*record_batch)); \ + } \ + ABORT_NOT_OK(writer->Close()); \ + ABORT_NOT_OK(stream.Close()); \ + } \ + constexpr int64_t total_size = kBatchSize * kBatches; #endif #define GENERATE_DATA_IN_MEMORY() \ diff --git a/cpp/src/arrow/ipc/read_write_test.cc b/cpp/src/arrow/ipc/read_write_test.cc index ff7838cc39d72..39fd2c40fb4ec 100644 --- a/cpp/src/arrow/ipc/read_write_test.cc +++ b/cpp/src/arrow/ipc/read_write_test.cc @@ -1081,9 +1081,9 @@ TEST_F(RecursionLimits, ReadLimit) { // Test fails with a structured exception on Windows + Debug #if !defined(_WIN32) || defined(NDEBUG) TEST_F(RecursionLimits, StressLimit) { -#ifdef __EMSCRIPTEN__ +# ifdef __EMSCRIPTEN__ GTEST_SKIP() << "This crashes the Emscripten runtime."; -#endif +# endif auto CheckDepth = [this](int recursion_depth, bool* it_works) { int32_t metadata_length = -1; @@ -1112,10 +1112,10 @@ TEST_F(RecursionLimits, StressLimit) { ASSERT_TRUE(it_works); // Mitigate Valgrind's slowness -#if !defined(ARROW_VALGRIND) +# if !defined(ARROW_VALGRIND) CheckDepth(500, &it_works); ASSERT_TRUE(it_works); -#endif +# endif } #endif // !defined(_WIN32) || defined(NDEBUG) diff --git a/cpp/src/arrow/json/rapidjson_defs.h b/cpp/src/arrow/json/rapidjson_defs.h index 9ed81d000c555..2354c6157263a 100644 --- a/cpp/src/arrow/json/rapidjson_defs.h +++ b/cpp/src/arrow/json/rapidjson_defs.h @@ -34,10 +34,10 @@ // enable SIMD whitespace skipping, if available #if defined(ARROW_HAVE_SSE4_2) -#define RAPIDJSON_SSE2 1 -#define RAPIDJSON_SSE42 1 +# define RAPIDJSON_SSE2 1 +# define RAPIDJSON_SSE42 1 #endif #if defined(ARROW_HAVE_NEON) -#define RAPIDJSON_NEON 1 +# define RAPIDJSON_NEON 1 #endif diff --git a/cpp/src/arrow/memory_pool.cc b/cpp/src/arrow/memory_pool.cc index 34207781277d1..3ace2c8f23ab0 100644 --- a/cpp/src/arrow/memory_pool.cc +++ b/cpp/src/arrow/memory_pool.cc @@ -28,7 +28,7 @@ #include #if defined(sun) || defined(__sun) -#include +# include #endif #include "arrow/buffer.h" @@ -46,11 +46,11 @@ #include "arrow/util/ubsan.h" #ifdef __GLIBC__ -#include +# include #endif #ifdef ARROW_MIMALLOC -#include +# include #endif namespace arrow { diff --git a/cpp/src/arrow/memory_pool_jemalloc.cc b/cpp/src/arrow/memory_pool_jemalloc.cc index 24bc0f27f0912..239d83b81bc67 100644 --- a/cpp/src/arrow/memory_pool_jemalloc.cc +++ b/cpp/src/arrow/memory_pool_jemalloc.cc @@ -26,11 +26,11 @@ // its family. #ifdef ARROW_JEMALLOC_VENDORED -#define JEMALLOC_MANGLE +# define JEMALLOC_MANGLE // Explicitly link to our version of jemalloc -#include "jemalloc_ep/dist/include/jemalloc/jemalloc.h" +# include "jemalloc_ep/dist/include/jemalloc/jemalloc.h" #else -#include +# include #endif #ifdef ARROW_JEMALLOC_VENDORED @@ -47,31 +47,31 @@ // aggressively (and in the background) to the OS. This can be configured // further by using the arrow::jemalloc_set_decay_ms API -#undef USE_JEMALLOC_BACKGROUND_THREAD -#ifndef __APPLE__ +# undef USE_JEMALLOC_BACKGROUND_THREAD +# ifndef __APPLE__ // ARROW-6977: jemalloc's background_thread isn't always enabled on macOS -#define USE_JEMALLOC_BACKGROUND_THREAD -#endif +# define USE_JEMALLOC_BACKGROUND_THREAD +# endif // In debug mode, add memory poisoning on alloc / free -#ifdef NDEBUG -#define JEMALLOC_DEBUG_OPTIONS "" -#else -#define JEMALLOC_DEBUG_OPTIONS ",junk:true" -#endif +# ifdef NDEBUG +# define JEMALLOC_DEBUG_OPTIONS "" +# else +# define JEMALLOC_DEBUG_OPTIONS ",junk:true" +# endif const char* je_arrow_malloc_conf = ("oversize_threshold:0" -#ifdef USE_JEMALLOC_BACKGROUND_THREAD +# ifdef USE_JEMALLOC_BACKGROUND_THREAD ",dirty_decay_ms:1000" ",muzzy_decay_ms:1000" ",background_thread:true" -#else +# else // ARROW-6994: return memory immediately to the OS if the // background_thread option isn't available ",dirty_decay_ms:0" ",muzzy_decay_ms:0" -#endif +# endif JEMALLOC_DEBUG_OPTIONS); // NOLINT: whitespace/parens #endif // ARROW_JEMALLOC_VENDORED diff --git a/cpp/src/arrow/public_api_test.cc b/cpp/src/arrow/public_api_test.cc index 20de827ced13f..ccc80dc93a50a 100644 --- a/cpp/src/arrow/public_api_test.cc +++ b/cpp/src/arrow/public_api_test.cc @@ -28,32 +28,32 @@ #include "arrow/ipc/api.h" // IWYU pragma: keep #ifdef ARROW_CSV -#include "arrow/csv/api.h" // IWYU pragma: keep +# include "arrow/csv/api.h" // IWYU pragma: keep #endif #ifdef ARROW_DATASET -#include "arrow/dataset/api.h" // IWYU pragma: keep +# include "arrow/dataset/api.h" // IWYU pragma: keep #endif #ifdef ARROW_FILESYSTEM -#include "arrow/filesystem/api.h" // IWYU pragma: keep +# include "arrow/filesystem/api.h" // IWYU pragma: keep #endif #ifdef ARROW_FLIGHT -#include "arrow/flight/api.h" // IWYU pragma: keep +# include "arrow/flight/api.h" // IWYU pragma: keep #endif #ifdef ARROW_FLIGHT_SQL -#include "arrow/flight/sql/api.h" // IWYU pragma: keep +# include "arrow/flight/sql/api.h" // IWYU pragma: keep #endif #ifdef ARROW_JSON -#include "arrow/json/api.h" // IWYU pragma: keep +# include "arrow/json/api.h" // IWYU pragma: keep #endif #ifdef ARROW_SUBSTRAIT -#include "arrow/engine/api.h" // IWYU pragma: keep -#include "arrow/engine/substrait/api.h" // IWYU pragma: keep +# include "arrow/engine/api.h" // IWYU pragma: keep +# include "arrow/engine/substrait/api.h" // IWYU pragma: keep #endif #include diff --git a/cpp/src/arrow/result_internal.h b/cpp/src/arrow/result_internal.h index 7550f945d85d0..134902e1b75ad 100644 --- a/cpp/src/arrow/result_internal.h +++ b/cpp/src/arrow/result_internal.h @@ -18,5 +18,5 @@ #include "arrow/result.h" #ifndef ASSIGN_OR_RAISE -#define ASSIGN_OR_RAISE(lhs, rhs) ARROW_ASSIGN_OR_RAISE(lhs, rhs) +# define ASSIGN_OR_RAISE(lhs, rhs) ARROW_ASSIGN_OR_RAISE(lhs, rhs) #endif diff --git a/cpp/src/arrow/status.h b/cpp/src/arrow/status.h index ac384fc389a49..fb75d963f3a3c 100644 --- a/cpp/src/arrow/status.h +++ b/cpp/src/arrow/status.h @@ -28,23 +28,23 @@ #ifdef ARROW_EXTRA_ERROR_CONTEXT /// \brief Return with given status if condition is met. -#define ARROW_RETURN_IF_(condition, status, expr) \ - do { \ - if (ARROW_PREDICT_FALSE(condition)) { \ - ::arrow::Status _st = (status); \ - _st.AddContextLine(__FILE__, __LINE__, expr); \ - return _st; \ - } \ - } while (0) +# define ARROW_RETURN_IF_(condition, status, expr) \ + do { \ + if (ARROW_PREDICT_FALSE(condition)) { \ + ::arrow::Status _st = (status); \ + _st.AddContextLine(__FILE__, __LINE__, expr); \ + return _st; \ + } \ + } while (0) #else -#define ARROW_RETURN_IF_(condition, status, _) \ - do { \ - if (ARROW_PREDICT_FALSE(condition)) { \ - return (status); \ - } \ - } while (0) +# define ARROW_RETURN_IF_(condition, status, _) \ + do { \ + if (ARROW_PREDICT_FALSE(condition)) { \ + return (status); \ + } \ + } while (0) #endif // ARROW_EXTRA_ERROR_CONTEXT @@ -78,7 +78,7 @@ // This is an internal-use macro and should not be used in public headers. #ifndef RETURN_NOT_OK -#define RETURN_NOT_OK(s) ARROW_RETURN_NOT_OK(s) +# define RETURN_NOT_OK(s) ARROW_RETURN_NOT_OK(s) #endif namespace arrow { diff --git a/cpp/src/arrow/telemetry/logging.cc b/cpp/src/arrow/telemetry/logging.cc index 7e9a69afedbb5..11a70ae1319c8 100644 --- a/cpp/src/arrow/telemetry/logging.cc +++ b/cpp/src/arrow/telemetry/logging.cc @@ -21,8 +21,8 @@ #include "arrow/util/logging.h" #ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4522) +# pragma warning(push) +# pragma warning(disable : 4522) #endif #include @@ -46,7 +46,7 @@ #include #ifdef _MSC_VER -#pragma warning(pop) +# pragma warning(pop) #endif namespace arrow { diff --git a/cpp/src/arrow/testing/gtest_compat.h b/cpp/src/arrow/testing/gtest_compat.h index c934dd2793890..1fd0bfd32c5bc 100644 --- a/cpp/src/arrow/testing/gtest_compat.h +++ b/cpp/src/arrow/testing/gtest_compat.h @@ -21,13 +21,13 @@ // GTest < 1.11 #ifndef GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST -#define GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(A) +# define GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(A) #endif // GTest < 1.10 #ifndef TYPED_TEST_SUITE -#define TYPED_TEST_SUITE TYPED_TEST_CASE -#define TYPED_TEST_SUITE_P TYPED_TEST_CASE_P -#define INSTANTIATE_TEST_SUITE_P INSTANTIATE_TEST_CASE_P -#define REGISTER_TYPED_TEST_SUITE_P REGISTER_TYPED_TEST_CASE_P -#define INSTANTIATE_TYPED_TEST_SUITE_P INSTANTIATE_TYPED_TEST_CASE_P +# define TYPED_TEST_SUITE TYPED_TEST_CASE +# define TYPED_TEST_SUITE_P TYPED_TEST_CASE_P +# define INSTANTIATE_TEST_SUITE_P INSTANTIATE_TEST_CASE_P +# define REGISTER_TYPED_TEST_SUITE_P REGISTER_TYPED_TEST_CASE_P +# define INSTANTIATE_TYPED_TEST_SUITE_P INSTANTIATE_TYPED_TEST_CASE_P #endif diff --git a/cpp/src/arrow/testing/gtest_util.cc b/cpp/src/arrow/testing/gtest_util.cc index ae2e53b30a3ee..c4a7f363c71bc 100644 --- a/cpp/src/arrow/testing/gtest_util.cc +++ b/cpp/src/arrow/testing/gtest_util.cc @@ -20,13 +20,13 @@ #include "arrow/testing/extension_type.h" #ifdef _WIN32 -#include -#include +# include +# include #else -#include // IWYU pragma: keep -#include // IWYU pragma: keep -#include // IWYU pragma: keep -#include // IWYU pragma: keep +# include // IWYU pragma: keep +# include // IWYU pragma: keep +# include // IWYU pragma: keep +# include // IWYU pragma: keep #endif #include diff --git a/cpp/src/arrow/testing/gtest_util.h b/cpp/src/arrow/testing/gtest_util.h index 85b4c1f1f0138..90311464c283b 100644 --- a/cpp/src/arrow/testing/gtest_util.h +++ b/cpp/src/arrow/testing/gtest_util.h @@ -457,9 +457,9 @@ class ARROW_TESTING_EXPORT SignalHandlerGuard { }; #ifndef ARROW_LARGE_MEMORY_TESTS -#define LARGE_MEMORY_TEST(name) DISABLED_##name +# define LARGE_MEMORY_TEST(name) DISABLED_##name #else -#define LARGE_MEMORY_TEST(name) name +# define LARGE_MEMORY_TEST(name) name #endif inline void PrintTo(const Status& st, std::ostream* os) { *os << st.ToString(); } diff --git a/cpp/src/arrow/testing/process.cc b/cpp/src/arrow/testing/process.cc index 32da81f14630e..941ddd9a6b603 100644 --- a/cpp/src/arrow/testing/process.cc +++ b/cpp/src/arrow/testing/process.cc @@ -32,24 +32,24 @@ // // [1] https://github.com/boostorg/process/issues/259 // [2] https://github.com/googleapis/storage-testbench/issues/669 -#ifndef _WIN32 -#define BOOST_PROCESS_USE_V2 -#endif +# ifndef _WIN32 +# define BOOST_PROCESS_USE_V2 +# endif #endif #ifdef BOOST_PROCESS_USE_V2 -#ifdef BOOST_PROCESS_NEED_SOURCE +# ifdef BOOST_PROCESS_NEED_SOURCE // Workaround for https://github.com/boostorg/process/issues/312 -#define BOOST_PROCESS_V2_SEPARATE_COMPILATION -#ifdef __APPLE__ -#include -#endif -#include -#include -#else -#include -#endif -#include +# define BOOST_PROCESS_V2_SEPARATE_COMPILATION +# ifdef __APPLE__ +# include +# endif +# include +# include +# else +# include +# endif +# include #else // We need BOOST_USE_WINDOWS_H definition with MinGW when we use // boost/process.hpp. boost/process/detail/windows/handle_workaround.hpp @@ -58,19 +58,19 @@ // // See also: // https://github.com/boostorg/process/blob/develop/include/boost/process/detail/windows/handle_workaround.hpp -#ifdef __MINGW32__ -#define BOOST_USE_WINDOWS_H = 1 -#endif -#ifdef BOOST_PROCESS_HAVE_V1 -#include -#else -#include -#endif +# ifdef __MINGW32__ +# define BOOST_USE_WINDOWS_H = 1 +# endif +# ifdef BOOST_PROCESS_HAVE_V1 +# include +# else +# include +# endif #endif #ifdef __APPLE__ -#include -#include +# include +# include #endif #include diff --git a/cpp/src/arrow/testing/util.cc b/cpp/src/arrow/testing/util.cc index 36351fa8595be..7bef9f7d4756d 100644 --- a/cpp/src/arrow/testing/util.cc +++ b/cpp/src/arrow/testing/util.cc @@ -30,13 +30,13 @@ #include // clang-format on #else -#include // IWYU pragma: keep -#include // IWYU pragma: keep -#include // IWYU pragma: keep -#include // IWYU pragma: keep -#include // IWYU pragma: keep -#include // IWYU pragma: keep -#include // IWYU pragma: keep +# include // IWYU pragma: keep +# include // IWYU pragma: keep +# include // IWYU pragma: keep +# include // IWYU pragma: keep +# include // IWYU pragma: keep +# include // IWYU pragma: keep +# include // IWYU pragma: keep #endif #include "arrow/config.h" @@ -144,8 +144,8 @@ int GetListenPort() { return internal::WinErrorMessage(WSAGetLastError()); }; #else -#define INVALID_SOCKET -1 -#define SOCKET_ERROR -1 +# define INVALID_SOCKET -1 +# define SOCKET_ERROR -1 int sock_fd; auto sin_len = static_cast(sizeof(sin)); auto errno_message = []() -> std::string { return internal::ErrnoMessage(errno); }; diff --git a/cpp/src/arrow/testing/visibility.h b/cpp/src/arrow/testing/visibility.h index 1b2aa7cd86fc6..b7fbcd42757bd 100644 --- a/cpp/src/arrow/testing/visibility.h +++ b/cpp/src/arrow/testing/visibility.h @@ -18,31 +18,31 @@ #pragma once #if defined(_WIN32) || defined(__CYGWIN__) -#if defined(_MSC_VER) -#pragma warning(push) -#pragma warning(disable : 4251) -#else -#pragma GCC diagnostic ignored "-Wattributes" -#endif +# if defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable : 4251) +# else +# pragma GCC diagnostic ignored "-Wattributes" +# endif -#ifdef ARROW_TESTING_STATIC -#define ARROW_TESTING_EXPORT -#elif defined(ARROW_TESTING_EXPORTING) -#define ARROW_TESTING_EXPORT __declspec(dllexport) -#else -#define ARROW_TESTING_EXPORT __declspec(dllimport) -#endif +# ifdef ARROW_TESTING_STATIC +# define ARROW_TESTING_EXPORT +# elif defined(ARROW_TESTING_EXPORTING) +# define ARROW_TESTING_EXPORT __declspec(dllexport) +# else +# define ARROW_TESTING_EXPORT __declspec(dllimport) +# endif -#define ARROW_TESTING_NO_EXPORT +# define ARROW_TESTING_NO_EXPORT #else // Not Windows -#ifndef ARROW_TESTING_EXPORT -#define ARROW_TESTING_EXPORT __attribute__((visibility("default"))) -#endif -#ifndef ARROW_TESTING_NO_EXPORT -#define ARROW_TESTING_NO_EXPORT __attribute__((visibility("hidden"))) -#endif +# ifndef ARROW_TESTING_EXPORT +# define ARROW_TESTING_EXPORT __attribute__((visibility("default"))) +# endif +# ifndef ARROW_TESTING_NO_EXPORT +# define ARROW_TESTING_NO_EXPORT __attribute__((visibility("hidden"))) +# endif #endif // Non-Windows #if defined(_MSC_VER) -#pragma warning(pop) +# pragma warning(pop) #endif diff --git a/cpp/src/arrow/type_benchmark.cc b/cpp/src/arrow/type_benchmark.cc index 17dccfcb33138..0d1425a405709 100644 --- a/cpp/src/arrow/type_benchmark.cc +++ b/cpp/src/arrow/type_benchmark.cc @@ -174,12 +174,12 @@ static void SchemaEqualsWithMetadata( // Micro-benchmark various error reporting schemes #if (defined(__GNUC__) || defined(__APPLE__)) -#define ARROW_NO_INLINE __attribute__((noinline)) +# define ARROW_NO_INLINE __attribute__((noinline)) #elif defined(_MSC_VER) -#define ARROW_NO_INLINE __declspec(noinline) +# define ARROW_NO_INLINE __declspec(noinline) #else -#define ARROW_NO_INLINE -#warning Missing "noinline" attribute, no-inline benchmarks may be bogus +# define ARROW_NO_INLINE +# warning Missing "noinline" attribute, no-inline benchmarks may be bogus #endif inline int64_t Accumulate(int64_t partial, int32_t value) { diff --git a/cpp/src/arrow/util/atfork_internal.cc b/cpp/src/arrow/util/atfork_internal.cc index eb26304fba36e..e89b37d83456e 100644 --- a/cpp/src/arrow/util/atfork_internal.cc +++ b/cpp/src/arrow/util/atfork_internal.cc @@ -23,7 +23,7 @@ #include #ifndef _WIN32 -#include +# include #endif #include "arrow/util/io_util.h" diff --git a/cpp/src/arrow/util/atfork_test.cc b/cpp/src/arrow/util/atfork_test.cc index 750f4d138793b..97910f9539c0d 100644 --- a/cpp/src/arrow/util/atfork_test.cc +++ b/cpp/src/arrow/util/atfork_test.cc @@ -25,9 +25,9 @@ #include #ifndef _WIN32 -#include -#include -#include +# include +# include +# include #endif #include @@ -110,9 +110,9 @@ class TestAtFork : public ::testing::Test { #ifndef _WIN32 TEST_F(TestAtFork, EmptyHandlers) { -#ifndef ARROW_ENABLE_THREADING +# ifndef ARROW_ENABLE_THREADING GTEST_SKIP() << "Test requires threading support"; -#endif +# endif auto handlers = std::make_shared(); @@ -135,9 +135,9 @@ TEST_F(TestAtFork, EmptyHandlers) { } TEST_F(TestAtFork, SingleThread) { -#ifndef ARROW_ENABLE_THREADING +# ifndef ARROW_ENABLE_THREADING GTEST_SKIP() << "Test requires threading support"; -#endif +# endif auto handlers1 = std::make_shared(PushBefore(1), PushParentAfter(11), PushChildAfter(21)); @@ -190,16 +190,17 @@ TEST_F(TestAtFork, SingleThread) { ASSERT_THAT(child_after_, ElementsAre()); } -#if !(defined(ARROW_VALGRIND) || defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER)) +# if !(defined(ARROW_VALGRIND) || defined(ADDRESS_SANITIZER) || \ + defined(THREAD_SANITIZER)) // The two following tests would seem to leak for various reasons. // Also, Thread Sanitizer would fail with the same error message as in // https://github.com/google/sanitizers/issues/950. TEST_F(TestAtFork, MultipleThreads) { -#ifndef ARROW_ENABLE_THREADING +# ifndef ARROW_ENABLE_THREADING GTEST_SKIP() << "Test requires threading support"; -#endif +# endif const int kNumThreads = 5; const int kNumIterations = 40; @@ -255,12 +256,12 @@ TEST_F(TestAtFork, MultipleThreads) { } TEST_F(TestAtFork, NestedChild) { -#ifdef __APPLE__ +# ifdef __APPLE__ GTEST_SKIP() << "Nested fork is not supported on macOS"; -#endif -#ifndef ARROW_ENABLE_THREADING +# endif +# ifndef ARROW_ENABLE_THREADING GTEST_SKIP() << "Test requires threading support"; -#endif +# endif auto handlers1 = std::make_shared(PushBefore(1), PushParentAfter(11), PushChildAfter(21)); @@ -295,16 +296,16 @@ TEST_F(TestAtFork, NestedChild) { ASSERT_THAT(child_after_, ElementsAre()); } -#endif // !(defined(ARROW_VALGRIND) || defined(ADDRESS_SANITIZER) || - // defined(THREAD_SANITIZER)) +# endif // !(defined(ARROW_VALGRIND) || defined(ADDRESS_SANITIZER) || + // defined(THREAD_SANITIZER)) #endif // !defined(_WIN32) #ifdef _WIN32 TEST_F(TestAtFork, NoOp) { -#ifndef ARROW_ENABLE_THREADING +# ifndef ARROW_ENABLE_THREADING GTEST_SKIP() << "Test requires threading support"; -#endif +# endif auto handlers = std::make_shared(PushBefore(1), PushParentAfter(11), PushChildAfter(21)); diff --git a/cpp/src/arrow/util/bit_stream_utils_internal.h b/cpp/src/arrow/util/bit_stream_utils_internal.h index 811694e43b76c..316086fcf0c04 100644 --- a/cpp/src/arrow/util/bit_stream_utils_internal.h +++ b/cpp/src/arrow/util/bit_stream_utils_internal.h @@ -269,13 +269,13 @@ template inline void GetValue_(int num_bits, T* v, int max_bytes, const uint8_t* buffer, int* bit_offset, int* byte_offset, uint64_t* buffered_values) { #ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4800) +# pragma warning(push) +# pragma warning(disable : 4800) #endif *v = static_cast(bit_util::TrailingBits(*buffered_values, *bit_offset + num_bits) >> *bit_offset); #ifdef _MSC_VER -#pragma warning(pop) +# pragma warning(pop) #endif *bit_offset += num_bits; if (*bit_offset >= 64) { @@ -285,8 +285,8 @@ inline void GetValue_(int num_bits, T* v, int max_bytes, const uint8_t* buffer, *buffered_values = detail::ReadLittleEndianWord(buffer + *byte_offset, max_bytes - *byte_offset); #ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4800 4805) +# pragma warning(push) +# pragma warning(disable : 4800 4805) #endif // Read bits of v that crossed into new buffered_values_ if (ARROW_PREDICT_TRUE(num_bits - *bit_offset < static_cast(8 * sizeof(T)))) { @@ -297,7 +297,7 @@ inline void GetValue_(int num_bits, T* v, int max_bytes, const uint8_t* buffer, << (num_bits - *bit_offset)); } #ifdef _MSC_VER -#pragma warning(pop) +# pragma warning(pop) #endif DCHECK_LE(*bit_offset, 64); } @@ -367,12 +367,12 @@ inline int BitReader::GetBatch(int num_bits, T* v, int batch_size) { } for (int k = 0; k < num_unpacked; ++k) { #ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4800) +# pragma warning(push) +# pragma warning(disable : 4800) #endif v[i + k] = static_cast(unpack_buffer[k]); #ifdef _MSC_VER -#pragma warning(pop) +# pragma warning(pop) #endif } i += num_unpacked; diff --git a/cpp/src/arrow/util/bit_util.h b/cpp/src/arrow/util/bit_util.h index 1d3a1dc2459f9..17d1de406d514 100644 --- a/cpp/src/arrow/util/bit_util.h +++ b/cpp/src/arrow/util/bit_util.h @@ -18,18 +18,18 @@ #pragma once #if defined(_MSC_VER) -#if defined(_M_AMD64) || defined(_M_X64) -#include // IWYU pragma: keep -#include -#endif - -#pragma intrinsic(_BitScanReverse) -#pragma intrinsic(_BitScanForward) -#define ARROW_POPCOUNT64 __popcnt64 -#define ARROW_POPCOUNT32 __popcnt +# if defined(_M_AMD64) || defined(_M_X64) +# include // IWYU pragma: keep +# include +# endif + +# pragma intrinsic(_BitScanReverse) +# pragma intrinsic(_BitScanForward) +# define ARROW_POPCOUNT64 __popcnt64 +# define ARROW_POPCOUNT32 __popcnt #else -#define ARROW_POPCOUNT64 __builtin_popcountll -#define ARROW_POPCOUNT32 __builtin_popcount +# define ARROW_POPCOUNT64 __builtin_popcountll +# define ARROW_POPCOUNT32 __builtin_popcount #endif #include diff --git a/cpp/src/arrow/util/bpacking.cc b/cpp/src/arrow/util/bpacking.cc index b33eb92606be2..e0d61d8db01e1 100644 --- a/cpp/src/arrow/util/bpacking.cc +++ b/cpp/src/arrow/util/bpacking.cc @@ -24,13 +24,13 @@ #include "arrow/util/logging.h" #if defined(ARROW_HAVE_RUNTIME_AVX2) -#include "arrow/util/bpacking_avx2.h" +# include "arrow/util/bpacking_avx2.h" #endif #if defined(ARROW_HAVE_RUNTIME_AVX512) -#include "arrow/util/bpacking_avx512.h" +# include "arrow/util/bpacking_avx512.h" #endif #if defined(ARROW_HAVE_NEON) -#include "arrow/util/bpacking_neon.h" +# include "arrow/util/bpacking_neon.h" #endif namespace arrow { diff --git a/cpp/src/arrow/util/byte_stream_split_internal.h b/cpp/src/arrow/util/byte_stream_split_internal.h index 8bca0d442c681..d3214239ff9fb 100644 --- a/cpp/src/arrow/util/byte_stream_split_internal.h +++ b/cpp/src/arrow/util/byte_stream_split_internal.h @@ -29,8 +29,8 @@ #include #if defined(ARROW_HAVE_NEON) || defined(ARROW_HAVE_SSE4_2) -#include -#define ARROW_HAVE_SIMD_SPLIT +# include +# define ARROW_HAVE_SIMD_SPLIT #endif namespace arrow::util::internal { @@ -383,28 +383,28 @@ void ByteStreamSplitEncodeAvx2(const uint8_t* raw_values, int width, template void inline ByteStreamSplitDecodeSimd(const uint8_t* data, int width, int64_t num_values, int64_t stride, uint8_t* out) { -#if defined(ARROW_HAVE_AVX2) +# if defined(ARROW_HAVE_AVX2) return ByteStreamSplitDecodeAvx2(data, width, num_values, stride, out); -#elif defined(ARROW_HAVE_SSE4_2) || defined(ARROW_HAVE_NEON) +# elif defined(ARROW_HAVE_SSE4_2) || defined(ARROW_HAVE_NEON) return ByteStreamSplitDecodeSimd128(data, width, num_values, stride, out); -#else -#error "ByteStreamSplitDecodeSimd not implemented" -#endif +# else +# error "ByteStreamSplitDecodeSimd not implemented" +# endif } template void inline ByteStreamSplitEncodeSimd(const uint8_t* raw_values, int width, const int64_t num_values, uint8_t* output_buffer_raw) { -#if defined(ARROW_HAVE_AVX2) +# if defined(ARROW_HAVE_AVX2) return ByteStreamSplitEncodeAvx2(raw_values, width, num_values, output_buffer_raw); -#elif defined(ARROW_HAVE_SSE4_2) || defined(ARROW_HAVE_NEON) +# elif defined(ARROW_HAVE_SSE4_2) || defined(ARROW_HAVE_NEON) return ByteStreamSplitEncodeSimd128(raw_values, width, num_values, output_buffer_raw); -#else -#error "ByteStreamSplitEncodeSimd not implemented" -#endif +# else +# error "ByteStreamSplitEncodeSimd not implemented" +# endif } #endif @@ -546,9 +546,9 @@ inline void ByteStreamSplitDecodeScalarDynamic(const uint8_t* data, int width, inline void ByteStreamSplitEncode(const uint8_t* raw_values, int width, const int64_t num_values, uint8_t* out) { #if defined(ARROW_HAVE_SIMD_SPLIT) -#define ByteStreamSplitEncodePerhapsSimd ByteStreamSplitEncodeSimd +# define ByteStreamSplitEncodePerhapsSimd ByteStreamSplitEncodeSimd #else -#define ByteStreamSplitEncodePerhapsSimd ByteStreamSplitEncodeScalar +# define ByteStreamSplitEncodePerhapsSimd ByteStreamSplitEncodeScalar #endif switch (width) { case 1: @@ -570,9 +570,9 @@ inline void ByteStreamSplitEncode(const uint8_t* raw_values, int width, inline void ByteStreamSplitDecode(const uint8_t* data, int width, int64_t num_values, int64_t stride, uint8_t* out) { #if defined(ARROW_HAVE_SIMD_SPLIT) -#define ByteStreamSplitDecodePerhapsSimd ByteStreamSplitDecodeSimd +# define ByteStreamSplitDecodePerhapsSimd ByteStreamSplitDecodeSimd #else -#define ByteStreamSplitDecodePerhapsSimd ByteStreamSplitDecodeScalar +# define ByteStreamSplitDecodePerhapsSimd ByteStreamSplitDecodeScalar #endif switch (width) { case 1: diff --git a/cpp/src/arrow/util/byte_stream_split_test.cc b/cpp/src/arrow/util/byte_stream_split_test.cc index 3a537725b0692..9755cd8b8d0f2 100644 --- a/cpp/src/arrow/util/byte_stream_split_test.cc +++ b/cpp/src/arrow/util/byte_stream_split_test.cc @@ -145,9 +145,9 @@ class TestByteStreamSplitSpecialized : public ::testing::Test { if constexpr (kSimdImplemented) { funcs.push_back({"simd", &ByteStreamSplitDecodeSimd}); funcs.push_back({"simd128", &ByteStreamSplitDecodeSimd128}); -#if defined(ARROW_HAVE_AVX2) +# if defined(ARROW_HAVE_AVX2) funcs.push_back({"avx2", &ByteStreamSplitDecodeAvx2}); -#endif +# endif } #endif // defined(ARROW_HAVE_SIMD_SPLIT) return funcs; @@ -163,9 +163,9 @@ class TestByteStreamSplitSpecialized : public ::testing::Test { if constexpr (kSimdImplemented) { funcs.push_back({"simd", &ByteStreamSplitEncodeSimd}); funcs.push_back({"simd128", &ByteStreamSplitEncodeSimd128}); -#if defined(ARROW_HAVE_AVX2) +# if defined(ARROW_HAVE_AVX2) funcs.push_back({"avx2", &ByteStreamSplitEncodeAvx2}); -#endif +# endif } #endif // defined(ARROW_HAVE_SIMD_SPLIT) return funcs; diff --git a/cpp/src/arrow/util/cancel.cc b/cpp/src/arrow/util/cancel.cc index 2648059af81ee..b3a0c1f92c24e 100644 --- a/cpp/src/arrow/util/cancel.cc +++ b/cpp/src/arrow/util/cancel.cc @@ -33,7 +33,7 @@ namespace arrow { #if ATOMIC_INT_LOCK_FREE != 2 -#error Lock-free atomic int required for signal safety +# error Lock-free atomic int required for signal safety #endif using internal::AtForkHandler; diff --git a/cpp/src/arrow/util/cancel_test.cc b/cpp/src/arrow/util/cancel_test.cc index 713418f15a0cc..6cea75755de10 100644 --- a/cpp/src/arrow/util/cancel_test.cc +++ b/cpp/src/arrow/util/cancel_test.cc @@ -29,9 +29,9 @@ #include #ifndef _WIN32 -#include // for setitimer() -#include -#include +# include // for setitimer() +# include +# include #endif #include "arrow/testing/gtest_util.h" @@ -269,9 +269,9 @@ TEST_F(SignalCancelTest, RegisterUnregister) { #if !(defined(_WIN32) || defined(ARROW_VALGRIND) || defined(ADDRESS_SANITIZER) || \ defined(THREAD_SANITIZER)) TEST_F(SignalCancelTest, ForkSafetyUnregisteredHandlers) { -#ifndef ARROW_ENABLE_THREADING +# ifndef ARROW_ENABLE_THREADING GTEST_SKIP() << "Test requires threading support"; -#endif +# endif RunInChild([&]() { // Child @@ -296,9 +296,9 @@ TEST_F(SignalCancelTest, ForkSafetyUnregisteredHandlers) { } TEST_F(SignalCancelTest, ForkSafetyRegisteredHandlers) { -#ifndef ARROW_ENABLE_THREADING +# ifndef ARROW_ENABLE_THREADING GTEST_SKIP() << "Test requires threading support"; -#endif +# endif RegisterHandler(); diff --git a/cpp/src/arrow/util/compression_benchmark.cc b/cpp/src/arrow/util/compression_benchmark.cc index 0b9727cff9041..361935805be79 100644 --- a/cpp/src/arrow/util/compression_benchmark.cc +++ b/cpp/src/arrow/util/compression_benchmark.cc @@ -228,28 +228,28 @@ static void ReferenceDecompression( state.SetBytesProcessed(state.iterations() * data.size()); } -#ifdef ARROW_WITH_ZLIB +# ifdef ARROW_WITH_ZLIB BENCHMARK_TEMPLATE(ReferenceStreamingCompression, Compression::GZIP); BENCHMARK_TEMPLATE(ReferenceCompression, Compression::GZIP); BENCHMARK_TEMPLATE(ReferenceStreamingDecompression, Compression::GZIP); BENCHMARK_TEMPLATE(ReferenceDecompression, Compression::GZIP); -#endif +# endif -#ifdef ARROW_WITH_BROTLI +# ifdef ARROW_WITH_BROTLI BENCHMARK_TEMPLATE(ReferenceStreamingCompression, Compression::BROTLI); BENCHMARK_TEMPLATE(ReferenceCompression, Compression::BROTLI); BENCHMARK_TEMPLATE(ReferenceStreamingDecompression, Compression::BROTLI); BENCHMARK_TEMPLATE(ReferenceDecompression, Compression::BROTLI); -#endif +# endif -#ifdef ARROW_WITH_ZSTD +# ifdef ARROW_WITH_ZSTD BENCHMARK_TEMPLATE(ReferenceStreamingCompression, Compression::ZSTD); BENCHMARK_TEMPLATE(ReferenceCompression, Compression::ZSTD); BENCHMARK_TEMPLATE(ReferenceStreamingDecompression, Compression::ZSTD); BENCHMARK_TEMPLATE(ReferenceDecompression, Compression::ZSTD); -#endif +# endif -#ifdef ARROW_WITH_LZ4 +# ifdef ARROW_WITH_LZ4 BENCHMARK_TEMPLATE(ReferenceStreamingCompression, Compression::LZ4_FRAME); BENCHMARK_TEMPLATE(ReferenceCompression, Compression::LZ4_FRAME); BENCHMARK_TEMPLATE(ReferenceStreamingDecompression, Compression::LZ4_FRAME); @@ -257,12 +257,12 @@ BENCHMARK_TEMPLATE(ReferenceDecompression, Compression::LZ4_FRAME); BENCHMARK_TEMPLATE(ReferenceCompression, Compression::LZ4); BENCHMARK_TEMPLATE(ReferenceDecompression, Compression::LZ4); -#endif +# endif -#ifdef ARROW_WITH_SNAPPY +# ifdef ARROW_WITH_SNAPPY BENCHMARK_TEMPLATE(ReferenceCompression, Compression::SNAPPY); BENCHMARK_TEMPLATE(ReferenceDecompression, Compression::SNAPPY); -#endif +# endif #endif diff --git a/cpp/src/arrow/util/compression_lz4.cc b/cpp/src/arrow/util/compression_lz4.cc index be957afab3c46..ae1d0961de600 100644 --- a/cpp/src/arrow/util/compression_lz4.cc +++ b/cpp/src/arrow/util/compression_lz4.cc @@ -34,7 +34,7 @@ #include "arrow/util/ubsan.h" #ifndef LZ4F_HEADER_SIZE_MAX -#define LZ4F_HEADER_SIZE_MAX 19 +# define LZ4F_HEADER_SIZE_MAX 19 #endif namespace arrow { diff --git a/cpp/src/arrow/util/cpu_info.cc b/cpp/src/arrow/util/cpu_info.cc index 7c2e9fa921246..620e520e72b39 100644 --- a/cpp/src/arrow/util/cpu_info.cc +++ b/cpp/src/arrow/util/cpu_info.cc @@ -20,17 +20,17 @@ #include "arrow/util/cpu_info.h" #ifdef __APPLE__ -#include +# include #endif #ifndef _MSC_VER -#include +# include #endif #ifdef _WIN32 -#include +# include -#include "arrow/util/windows_compatibility.h" +# include "arrow/util/windows_compatibility.h" #endif #include @@ -55,12 +55,12 @@ #undef CPUINFO_ARCH_PPC #if defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64) -#define CPUINFO_ARCH_X86 +# define CPUINFO_ARCH_X86 #elif defined(_M_ARM64) || defined(__aarch64__) || defined(__arm64__) -#define CPUINFO_ARCH_ARM +# define CPUINFO_ARCH_ARM #elif defined(__PPC64__) || defined(__PPC64LE__) || defined(__ppc64__) || \ defined(__powerpc64__) -#define CPUINFO_ARCH_PPC +# define CPUINFO_ARCH_PPC #endif namespace arrow { @@ -122,10 +122,10 @@ void OsRetrieveCacheSize(std::array* cache_sizes) { free(buffer); } -#if defined(CPUINFO_ARCH_X86) +# if defined(CPUINFO_ARCH_X86) // On x86, get CPU features by cpuid, https://en.wikipedia.org/wiki/CPUID -#if defined(__MINGW64_VERSION_MAJOR) && __MINGW64_VERSION_MAJOR < 5 +# if defined(__MINGW64_VERSION_MAJOR) && __MINGW64_VERSION_MAJOR < 5 void __cpuidex(int CPUInfo[4], int function_id, int subfunction_id) { __asm__ __volatile__("cpuid" : "=a"(CPUInfo[0]), "=b"(CPUInfo[1]), "=c"(CPUInfo[2]), @@ -138,7 +138,7 @@ int64_t _xgetbv(int xcr) { __asm__ __volatile__("xgetbv" : "=a"(out) : "c"(xcr) : "%edx"); return out; } -#endif // MINGW +# endif // MINGW void OsRetrieveCpuInfo(int64_t* hardware_flags, CpuInfo::Vendor* vendor, std::string* model_name) { @@ -215,14 +215,14 @@ void OsRetrieveCpuInfo(int64_t* hardware_flags, CpuInfo::Vendor* vendor, } } } -#elif defined(CPUINFO_ARCH_ARM) +# elif defined(CPUINFO_ARCH_ARM) // Windows on Arm void OsRetrieveCpuInfo(int64_t* hardware_flags, CpuInfo::Vendor* vendor, std::string* model_name) { *hardware_flags |= CpuInfo::ASIMD; // TODO: vendor, model_name } -#endif +# endif #elif defined(__APPLE__) //------------------------------ MACOS ------------------------------// @@ -265,7 +265,7 @@ void OsRetrieveCpuInfo(int64_t* hardware_flags, CpuInfo::Vendor* vendor, int64_t flag; }; std::vector features = { -#if defined(CPUINFO_ARCH_X86) +# if defined(CPUINFO_ARCH_X86) {"hw.optional.sse4_2", CpuInfo::SSSE3 | CpuInfo::SSE4_1 | CpuInfo::SSE4_2 | CpuInfo::POPCNT}, {"hw.optional.avx1_0", CpuInfo::AVX}, @@ -277,10 +277,10 @@ void OsRetrieveCpuInfo(int64_t* hardware_flags, CpuInfo::Vendor* vendor, {"hw.optional.avx512dq", CpuInfo::AVX512DQ}, {"hw.optional.avx512bw", CpuInfo::AVX512BW}, {"hw.optional.avx512vl", CpuInfo::AVX512VL}, -#elif defined(CPUINFO_ARCH_ARM) +# elif defined(CPUINFO_ARCH_ARM) // ARM64 (note that this is exposed under Rosetta as well) {"hw.optional.neon", CpuInfo::ASIMD}, -#endif +# endif }; for (const auto& feature : features) { auto v = IntegerSysCtlByName(feature.name); @@ -297,7 +297,7 @@ void OsRetrieveCpuInfo(int64_t* hardware_flags, CpuInfo::Vendor* vendor, // Get cache size, return 0 on error int64_t LinuxGetCacheSize(int level) { // get cache size by sysconf() -#ifdef _SC_LEVEL1_DCACHE_SIZE +# ifdef _SC_LEVEL1_DCACHE_SIZE const int kCacheSizeConf[] = { _SC_LEVEL1_DCACHE_SIZE, _SC_LEVEL2_CACHE_SIZE, @@ -310,7 +310,7 @@ int64_t LinuxGetCacheSize(int level) { if (errno == 0 && cache_size > 0) { return cache_size; } -#endif +# endif // get cache size from sysfs if sysconf() fails or not supported const char* kCacheSizeSysfs[] = { @@ -345,12 +345,12 @@ int64_t LinuxGetCacheSize(int level) { // care about are present. // Returns a bitmap of flags. int64_t LinuxParseCpuFlags(const std::string& values) { -#if defined(CPUINFO_ARCH_X86) || defined(CPUINFO_ARCH_ARM) +# if defined(CPUINFO_ARCH_X86) || defined(CPUINFO_ARCH_ARM) const struct { std::string name; int64_t flag; } flag_mappings[] = { -#if defined(CPUINFO_ARCH_X86) +# if defined(CPUINFO_ARCH_X86) {"ssse3", CpuInfo::SSSE3}, {"sse4_1", CpuInfo::SSE4_1}, {"sse4_2", CpuInfo::SSE4_2}, @@ -364,9 +364,9 @@ int64_t LinuxParseCpuFlags(const std::string& values) { {"avx512bw", CpuInfo::AVX512BW}, {"bmi1", CpuInfo::BMI1}, {"bmi2", CpuInfo::BMI2}, -#elif defined(CPUINFO_ARCH_ARM) +# elif defined(CPUINFO_ARCH_ARM) {"asimd", CpuInfo::ASIMD}, -#endif +# endif }; const int64_t num_flags = sizeof(flag_mappings) / sizeof(flag_mappings[0]); @@ -377,9 +377,9 @@ int64_t LinuxParseCpuFlags(const std::string& values) { } } return flags; -#else +# else return 0; -#endif +# endif } void OsRetrieveCacheSize(std::array* cache_sizes) { @@ -466,11 +466,11 @@ bool ArchParseUserSimdLevel(const std::string& simd_level, int64_t* hardware_fla } void ArchVerifyCpuRequirements(const CpuInfo* ci) { -#if defined(ARROW_HAVE_SSE4_2) +# if defined(ARROW_HAVE_SSE4_2) if (!ci->IsDetected(CpuInfo::SSE4_2)) { DCHECK(false) << "CPU does not support the Supplemental SSE4_2 instruction set"; } -#endif +# endif } #elif defined(CPUINFO_ARCH_ARM) diff --git a/cpp/src/arrow/util/decimal_internal.h b/cpp/src/arrow/util/decimal_internal.h index 89f755af88316..b3a8b1127f918 100644 --- a/cpp/src/arrow/util/decimal_internal.h +++ b/cpp/src/arrow/util/decimal_internal.h @@ -189,11 +189,11 @@ constexpr BasicDecimal128 kDecimal128HalfPowersOfTen[] = { BasicDecimal128(2710505431213761085LL, 343699775700336640ULL)}; #if ARROW_LITTLE_ENDIAN -#define BasicDecimal256FromLE(v1, v2, v3, v4) \ - BasicDecimal256(std::array{v1, v2, v3, v4}) +# define BasicDecimal256FromLE(v1, v2, v3, v4) \ + BasicDecimal256(std::array{v1, v2, v3, v4}) #else -#define BasicDecimal256FromLE(v1, v2, v3, v4) \ - BasicDecimal256(std::array{v4, v3, v2, v1}) +# define BasicDecimal256FromLE(v1, v2, v3, v4) \ + BasicDecimal256(std::array{v4, v3, v2, v1}) #endif constexpr BasicDecimal256 kDecimal256PowersOfTen[76 + 1] = { diff --git a/cpp/src/arrow/util/endian.h b/cpp/src/arrow/util/endian.h index 3d394ba8b7801..9c603144a7fd8 100644 --- a/cpp/src/arrow/util/endian.h +++ b/cpp/src/arrow/util/endian.h @@ -18,38 +18,38 @@ #pragma once #ifdef _WIN32 -#define ARROW_LITTLE_ENDIAN 1 +# define ARROW_LITTLE_ENDIAN 1 #else -#if defined(__APPLE__) || defined(__FreeBSD__) -#include // IWYU pragma: keep -#elif defined(sun) || defined(__sun) -#include // IWYU pragma: keep -#else -#include // IWYU pragma: keep -#endif +# if defined(__APPLE__) || defined(__FreeBSD__) +# include // IWYU pragma: keep +# elif defined(sun) || defined(__sun) +# include // IWYU pragma: keep +# else +# include // IWYU pragma: keep +# endif # -#ifndef __BYTE_ORDER__ -#error "__BYTE_ORDER__ not defined" -#endif +# ifndef __BYTE_ORDER__ +# error "__BYTE_ORDER__ not defined" +# endif # -#ifndef __ORDER_LITTLE_ENDIAN__ -#error "__ORDER_LITTLE_ENDIAN__ not defined" -#endif +# ifndef __ORDER_LITTLE_ENDIAN__ +# error "__ORDER_LITTLE_ENDIAN__ not defined" +# endif # -#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define ARROW_LITTLE_ENDIAN 1 -#else -#define ARROW_LITTLE_ENDIAN 0 -#endif +# if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ +# define ARROW_LITTLE_ENDIAN 1 +# else +# define ARROW_LITTLE_ENDIAN 0 +# endif #endif #if defined(_MSC_VER) -#include // IWYU pragma: keep -#define ARROW_BYTE_SWAP64 _byteswap_uint64 -#define ARROW_BYTE_SWAP32 _byteswap_ulong +# include // IWYU pragma: keep +# define ARROW_BYTE_SWAP64 _byteswap_uint64 +# define ARROW_BYTE_SWAP32 _byteswap_ulong #else -#define ARROW_BYTE_SWAP64 __builtin_bswap64 -#define ARROW_BYTE_SWAP32 __builtin_bswap32 +# define ARROW_BYTE_SWAP64 __builtin_bswap64 +# define ARROW_BYTE_SWAP32 __builtin_bswap32 #endif #include diff --git a/cpp/src/arrow/util/hash_util.h b/cpp/src/arrow/util/hash_util.h index dd1c38a78216e..7b3de2208935f 100644 --- a/cpp/src/arrow/util/hash_util.h +++ b/cpp/src/arrow/util/hash_util.h @@ -26,9 +26,9 @@ namespace internal { namespace detail { #if defined(_MSC_VER) -#define ARROW_HASH_ROTL32(x, r) _rotl(x, r) +# define ARROW_HASH_ROTL32(x, r) _rotl(x, r) #else -#define ARROW_HASH_ROTL32(x, r) (x << r) | (x >> (32 - r)) +# define ARROW_HASH_ROTL32(x, r) (x << r) | (x >> (32 - r)) #endif template diff --git a/cpp/src/arrow/util/hashing.h b/cpp/src/arrow/util/hashing.h index 2de9f4153248f..4ead1a7283d81 100644 --- a/cpp/src/arrow/util/hashing.h +++ b/cpp/src/arrow/util/hashing.h @@ -182,7 +182,7 @@ hash_t ComputeStringHash(const void* data, int64_t length) { } #if XXH3_SECRET_SIZE_MIN != 136 -#error XXH3_SECRET_SIZE_MIN changed, please fix kXxh3Secrets +# error XXH3_SECRET_SIZE_MIN changed, please fix kXxh3Secrets #endif // XXH3_64bits_withSeed generates a secret based on the seed, which is too slow. diff --git a/cpp/src/arrow/util/int128_internal.h b/cpp/src/arrow/util/int128_internal.h index 1d494671a9f8f..201e4a1349190 100644 --- a/cpp/src/arrow/util/int128_internal.h +++ b/cpp/src/arrow/util/int128_internal.h @@ -20,7 +20,7 @@ #include "arrow/util/macros.h" #ifndef ARROW_USE_NATIVE_INT128 -#include +# include #endif namespace arrow { diff --git a/cpp/src/arrow/util/io_util.cc b/cpp/src/arrow/util/io_util.cc index 2eefe96f0d5c4..8c4d925dac541 100644 --- a/cpp/src/arrow/util/io_util.cc +++ b/cpp/src/arrow/util/io_util.cc @@ -17,7 +17,7 @@ // Ensure 64-bit off_t for platforms where it matters #ifdef _FILE_OFFSET_BITS -#undef _FILE_OFFSET_BITS +# undef _FILE_OFFSET_BITS #endif #define _FILE_OFFSET_BITS 64 @@ -27,8 +27,8 @@ // is the best way to enable modern POSIX APIs, such as posix_madvise(), on Solaris. // (see also // https://github.com/illumos/illumos-gate/blob/master/usr/src/uts/common/sys/mman.h) -#undef __EXTENSIONS__ -#define __EXTENSIONS__ +# undef __EXTENSIONS__ +# define __EXTENSIONS__ #endif #include "arrow/util/windows_compatibility.h" // IWYU pragma: keep @@ -60,34 +60,34 @@ // file compatibility stuff #ifdef _WIN32 -#include -#include -#include +# include +# include +# include #else // POSIX-like platforms -#include +# include #endif #ifdef _WIN32 -#include "arrow/io/mman.h" -#undef Realloc -#undef Free +# include "arrow/io/mman.h" +# undef Realloc +# undef Free #else // POSIX-like platforms -#include -#include +# include +# include #endif // define max read/write count #ifdef _WIN32 -#define ARROW_MAX_IO_CHUNKSIZE INT32_MAX +# define ARROW_MAX_IO_CHUNKSIZE INT32_MAX #else -#ifdef __APPLE__ +# ifdef __APPLE__ // due to macOS bug, we need to set read/write max -#define ARROW_MAX_IO_CHUNKSIZE INT32_MAX -#else +# define ARROW_MAX_IO_CHUNKSIZE INT32_MAX +# else // see notes on Linux read/write manpage -#define ARROW_MAX_IO_CHUNKSIZE 0x7ffff000 -#endif +# define ARROW_MAX_IO_CHUNKSIZE 0x7ffff000 +# endif #endif @@ -102,25 +102,25 @@ // For filename conversion #if defined(_WIN32) -#include "arrow/util/utf8.h" +# include "arrow/util/utf8.h" #endif #ifdef _WIN32 -#include +# include #elif __APPLE__ -#include -#include +# include +# include #elif __linux__ -#include -#include +# include +# include #endif #ifdef _WIN32 -#include +# include #else -#include +# include #endif namespace arrow::internal { @@ -1223,11 +1223,11 @@ Status SetPipeFileDescriptorNonBlocking(int fd) { namespace { #ifdef WIN32 -#define PIPE_WRITE _write -#define PIPE_READ _read +# define PIPE_WRITE _write +# define PIPE_READ _read #else -#define PIPE_WRITE write -#define PIPE_READ read +# define PIPE_WRITE write +# define PIPE_READ read #endif class SelfPipeImpl : public SelfPipe, public std::enable_shared_from_this { @@ -1500,7 +1500,7 @@ Status MemoryAdviseWillNeed(const std::vector& regions) { region.size + static_cast(addr - aligned_addr)}; }; -#ifdef _WIN32 +# ifdef _WIN32 // PrefetchVirtualMemory() is available on Windows 8 or later struct PrefetchEntry { // Like WIN32_MEMORY_RANGE_ENTRY void* VirtualAddress; @@ -1528,7 +1528,7 @@ Status MemoryAdviseWillNeed(const std::vector& regions) { } } return Status::OK(); -#elif defined(POSIX_MADV_WILLNEED) +# elif defined(POSIX_MADV_WILLNEED) for (const auto& region : regions) { if (region.size != 0) { const auto aligned = align_region(region); @@ -1542,9 +1542,9 @@ Status MemoryAdviseWillNeed(const std::vector& regions) { } } return Status::OK(); -#else +# else return Status::OK(); -#endif +# endif #else return Status::OK(); #endif @@ -1876,11 +1876,11 @@ std::vector GetPlatformTemporaryDirs() { #else selectors = {{"TMPDIR", ""}, {"TMP", ""}, {"TEMP", ""}, {"TEMPDIR", ""}}; -#ifdef __ANDROID__ +# ifdef __ANDROID__ fallback_tmp = "/data/local/tmp"; -#else +# else fallback_tmp = "/tmp"; -#endif +# endif #endif std::vector temp_dirs; @@ -2157,7 +2157,7 @@ int64_t GetCurrentRSS() { #elif defined(__APPLE__) // OSX ------------------------------------------------------ -#ifdef MACH_TASK_BASIC_INFO +# ifdef MACH_TASK_BASIC_INFO struct mach_task_basic_info info; mach_msg_type_number_t infoCount = MACH_TASK_BASIC_INFO_COUNT; if (task_info(mach_task_self(), MACH_TASK_BASIC_INFO, (task_info_t)&info, &infoCount) != @@ -2165,7 +2165,7 @@ int64_t GetCurrentRSS() { ARROW_LOG(WARNING) << "Can't resolve RSS value"; return 0; } -#else +# else struct task_basic_info info; mach_msg_type_number_t infoCount = TASK_BASIC_INFO_COUNT; if (task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &infoCount) != @@ -2173,7 +2173,7 @@ int64_t GetCurrentRSS() { ARROW_LOG(WARNING) << "Can't resolve RSS value"; return 0; } -#endif +# endif return static_cast(info.resident_size); #elif defined(__linux__) diff --git a/cpp/src/arrow/util/io_util.h b/cpp/src/arrow/util/io_util.h index 5f5bbd169e2eb..892641d4bc52f 100644 --- a/cpp/src/arrow/util/io_util.h +++ b/cpp/src/arrow/util/io_util.h @@ -18,7 +18,7 @@ #pragma once #ifndef _WIN32 -#define ARROW_HAVE_SIGACTION 1 +# define ARROW_HAVE_SIGACTION 1 #endif #include @@ -29,7 +29,7 @@ #include #if ARROW_HAVE_SIGACTION -#include // Needed for struct sigaction +# include // Needed for struct sigaction #endif #include "arrow/result.h" diff --git a/cpp/src/arrow/util/io_util_test.cc b/cpp/src/arrow/util/io_util_test.cc index 73213bf9ce48a..1ff8fcf7adb5c 100644 --- a/cpp/src/arrow/util/io_util_test.cc +++ b/cpp/src/arrow/util/io_util_test.cc @@ -29,9 +29,9 @@ #include #ifndef _WIN32 -#include -#include -#include +# include +# include +# include #endif #include @@ -48,11 +48,11 @@ #include "arrow/util/windows_fixup.h" #ifdef WIN32 -#define PIPE_WRITE _write -#define PIPE_READ _read +# define PIPE_WRITE _write +# define PIPE_READ _read #else -#define PIPE_WRITE write -#define PIPE_READ read +# define PIPE_WRITE write +# define PIPE_READ read #endif namespace arrow { @@ -474,9 +474,9 @@ TEST_F(TestSelfPipe, SendFromSignalAndWait) { #if !(defined(_WIN32) || defined(ARROW_VALGRIND) || defined(ADDRESS_SANITIZER) || \ defined(THREAD_SANITIZER)) TEST_F(TestSelfPipe, ForkSafety) { -#ifndef ARROW_ENABLE_THREADING +# ifndef ARROW_ENABLE_THREADING GTEST_SKIP() << "Test requires threading support"; -#endif +# endif self_pipe_->Send(123456789123456789ULL); @@ -974,7 +974,7 @@ TEST(DeleteFile, Basics) { TEST(FileUtils, LongPaths) { // ARROW-8477: check using long file paths under Windows (> 260 characters). bool created, deleted; -#ifdef _WIN32 +# ifdef _WIN32 const char* kRegKeyName = R"(SYSTEM\CurrentControlSet\Control\FileSystem)"; const char* kRegValueName = "LongPathsEnabled"; DWORD value = 0; @@ -990,7 +990,7 @@ TEST(FileUtils, LongPaths) { << " to 1 on the test host."; return; } -#endif +# endif const std::string BASE = "xxx-io-util-test-dir-long"; PlatformFilename base_path, long_path, long_filename; diff --git a/cpp/src/arrow/util/logger.h b/cpp/src/arrow/util/logger.h index 5200503bb4fdb..7832f4a4c2232 100644 --- a/cpp/src/arrow/util/logger.h +++ b/cpp/src/arrow/util/logger.h @@ -128,7 +128,7 @@ class ARROW_EXPORT LogMessage { // For the following macros, log statements with a lower severity than // `ARROW_MINIMUM_LOG_LEVEL` will be stripped from the build #ifndef ARROW_MINIMUM_LOG_LEVEL -#define ARROW_MINIMUM_LOG_LEVEL -1000 +# define ARROW_MINIMUM_LOG_LEVEL -1000 #endif #define ARROW_LOGGER_INTERNAL(LOGGER, LEVEL) \ @@ -137,50 +137,50 @@ class ARROW_EXPORT LogMessage { static_assert(static_cast(::arrow::util::ArrowLogLevel::ARROW_TRACE) == -2); #if ARROW_MINIMUM_LOG_LEVEL <= -2 -#define ARROW_LOGGER_TRACE(LOGGER, ...) \ - (ARROW_LOGGER_INTERNAL(LOGGER, TRACE).Append(__VA_ARGS__)) +# define ARROW_LOGGER_TRACE(LOGGER, ...) \ + (ARROW_LOGGER_INTERNAL(LOGGER, TRACE).Append(__VA_ARGS__)) #else -#define ARROW_LOGGER_TRACE(...) ARROW_UNUSED(0) +# define ARROW_LOGGER_TRACE(...) ARROW_UNUSED(0) #endif static_assert(static_cast(::arrow::util::ArrowLogLevel::ARROW_DEBUG) == -1); #if ARROW_MINIMUM_LOG_LEVEL <= -1 -#define ARROW_LOGGER_DEBUG(LOGGER, ...) \ - (ARROW_LOGGER_INTERNAL(LOGGER, DEBUG).Append(__VA_ARGS__)) +# define ARROW_LOGGER_DEBUG(LOGGER, ...) \ + (ARROW_LOGGER_INTERNAL(LOGGER, DEBUG).Append(__VA_ARGS__)) #else -#define ARROW_LOGGER_DEBUG(...) ARROW_UNUSED(0) +# define ARROW_LOGGER_DEBUG(...) ARROW_UNUSED(0) #endif static_assert(static_cast(::arrow::util::ArrowLogLevel::ARROW_INFO) == 0); #if ARROW_MINIMUM_LOG_LEVEL <= 0 -#define ARROW_LOGGER_INFO(LOGGER, ...) \ - (ARROW_LOGGER_INTERNAL(LOGGER, INFO).Append(__VA_ARGS__)) +# define ARROW_LOGGER_INFO(LOGGER, ...) \ + (ARROW_LOGGER_INTERNAL(LOGGER, INFO).Append(__VA_ARGS__)) #else -#define ARROW_LOGGER_INFO(...) ARROW_UNUSED(0) +# define ARROW_LOGGER_INFO(...) ARROW_UNUSED(0) #endif static_assert(static_cast(::arrow::util::ArrowLogLevel::ARROW_WARNING) == 1); #if ARROW_MINIMUM_LOG_LEVEL <= 1 -#define ARROW_LOGGER_WARNING(LOGGER, ...) \ - (ARROW_LOGGER_INTERNAL(LOGGER, WARNING).Append(__VA_ARGS__)) +# define ARROW_LOGGER_WARNING(LOGGER, ...) \ + (ARROW_LOGGER_INTERNAL(LOGGER, WARNING).Append(__VA_ARGS__)) #else -#define ARROW_LOGGER_WARNING(...) ARROW_UNUSED(0) +# define ARROW_LOGGER_WARNING(...) ARROW_UNUSED(0) #endif static_assert(static_cast(::arrow::util::ArrowLogLevel::ARROW_ERROR) == 2); #if ARROW_MINIMUM_LOG_LEVEL <= 2 -#define ARROW_LOGGER_ERROR(LOGGER, ...) \ - (ARROW_LOGGER_INTERNAL(LOGGER, ERROR).Append(__VA_ARGS__)) +# define ARROW_LOGGER_ERROR(LOGGER, ...) \ + (ARROW_LOGGER_INTERNAL(LOGGER, ERROR).Append(__VA_ARGS__)) #else -#define ARROW_LOGGER_ERROR(...) ARROW_UNUSED(0) +# define ARROW_LOGGER_ERROR(...) ARROW_UNUSED(0) #endif static_assert(static_cast(::arrow::util::ArrowLogLevel::ARROW_FATAL) == 3); #if ARROW_MINIMUM_LOG_LEVEL <= 3 -#define ARROW_LOGGER_FATAL(LOGGER, ...) \ - (ARROW_LOGGER_INTERNAL(LOGGER, FATAL).Append(__VA_ARGS__)) +# define ARROW_LOGGER_FATAL(LOGGER, ...) \ + (ARROW_LOGGER_INTERNAL(LOGGER, FATAL).Append(__VA_ARGS__)) #else -#define ARROW_LOGGER_FATAL(...) ARROW_UNUSED(0) +# define ARROW_LOGGER_FATAL(...) ARROW_UNUSED(0) #endif #define ARROW_LOGGER_CALL(LOGGER, LEVEL, ...) ARROW_LOGGER_##LEVEL(LOGGER, __VA_ARGS__) diff --git a/cpp/src/arrow/util/logging.cc b/cpp/src/arrow/util/logging.cc index ca4edcc5a5deb..993c5306ca4aa 100644 --- a/cpp/src/arrow/util/logging.cc +++ b/cpp/src/arrow/util/logging.cc @@ -20,36 +20,36 @@ #include "arrow/util/config.h" #ifdef ARROW_WITH_BACKTRACE -#include +# include #endif #include #include #ifdef ARROW_USE_GLOG -#include -#include +# include +# include -#include +# include // Restore our versions of DCHECK and friends, as GLog defines its own -#undef DCHECK -#undef DCHECK_OK -#undef DCHECK_EQ -#undef DCHECK_NE -#undef DCHECK_LE -#undef DCHECK_LT -#undef DCHECK_GE -#undef DCHECK_GT - -#define DCHECK ARROW_DCHECK -#define DCHECK_OK ARROW_DCHECK_OK -#define DCHECK_EQ ARROW_DCHECK_EQ -#define DCHECK_NE ARROW_DCHECK_NE -#define DCHECK_LE ARROW_DCHECK_LE -#define DCHECK_LT ARROW_DCHECK_LT -#define DCHECK_GE ARROW_DCHECK_GE -#define DCHECK_GT ARROW_DCHECK_GT +# undef DCHECK +# undef DCHECK_OK +# undef DCHECK_EQ +# undef DCHECK_NE +# undef DCHECK_LE +# undef DCHECK_LT +# undef DCHECK_GE +# undef DCHECK_GT + +# define DCHECK ARROW_DCHECK +# define DCHECK_OK ARROW_DCHECK_OK +# define DCHECK_EQ ARROW_DCHECK_EQ +# define DCHECK_NE ARROW_DCHECK_NE +# define DCHECK_LE ARROW_DCHECK_LE +# define DCHECK_LT ARROW_DCHECK_LT +# define DCHECK_GE ARROW_DCHECK_GE +# define DCHECK_GT ARROW_DCHECK_GT #endif @@ -188,11 +188,11 @@ void ArrowLog::UninstallSignalAction() { // This signal list comes from glog's signalhandler.cc. // https://github.com/google/glog/blob/master/src/signalhandler.cc#L58-L70 std::vector installed_signals({SIGSEGV, SIGILL, SIGFPE, SIGABRT, SIGTERM}); -#ifdef WIN32 +# ifdef WIN32 for (int signal_num : installed_signals) { ARROW_CHECK(signal(signal_num, SIG_DFL) != SIG_ERR); } -#else +# else struct sigaction sig_action; memset(&sig_action, 0, sizeof(sig_action)); sigemptyset(&sig_action.sa_mask); @@ -200,7 +200,7 @@ void ArrowLog::UninstallSignalAction() { for (int signal_num : installed_signals) { ARROW_CHECK(sigaction(signal_num, &sig_action, NULL) == 0); } -#endif +# endif #endif } diff --git a/cpp/src/arrow/util/logging.h b/cpp/src/arrow/util/logging.h index be73c020c07f8..04c6bc21cac73 100644 --- a/cpp/src/arrow/util/logging.h +++ b/cpp/src/arrow/util/logging.h @@ -22,25 +22,25 @@ // The LLVM IR code doesn't have an NDEBUG mode. And, it shouldn't include references to // streams or stdc++. So, making the DCHECK calls void in that case. -#define ARROW_IGNORE_EXPR(expr) ((void)(expr)) +# define ARROW_IGNORE_EXPR(expr) ((void)(expr)) -#define DCHECK(condition) ARROW_IGNORE_EXPR(condition) -#define DCHECK_OK(status) ARROW_IGNORE_EXPR(status) -#define DCHECK_EQ(val1, val2) ARROW_IGNORE_EXPR(val1) -#define DCHECK_NE(val1, val2) ARROW_IGNORE_EXPR(val1) -#define DCHECK_LE(val1, val2) ARROW_IGNORE_EXPR(val1) -#define DCHECK_LT(val1, val2) ARROW_IGNORE_EXPR(val1) -#define DCHECK_GE(val1, val2) ARROW_IGNORE_EXPR(val1) -#define DCHECK_GT(val1, val2) ARROW_IGNORE_EXPR(val1) +# define DCHECK(condition) ARROW_IGNORE_EXPR(condition) +# define DCHECK_OK(status) ARROW_IGNORE_EXPR(status) +# define DCHECK_EQ(val1, val2) ARROW_IGNORE_EXPR(val1) +# define DCHECK_NE(val1, val2) ARROW_IGNORE_EXPR(val1) +# define DCHECK_LE(val1, val2) ARROW_IGNORE_EXPR(val1) +# define DCHECK_LT(val1, val2) ARROW_IGNORE_EXPR(val1) +# define DCHECK_GE(val1, val2) ARROW_IGNORE_EXPR(val1) +# define DCHECK_GT(val1, val2) ARROW_IGNORE_EXPR(val1) #else // !GANDIVA_IR -#include -#include -#include +# include +# include +# include -#include "arrow/util/macros.h" -#include "arrow/util/visibility.h" +# include "arrow/util/macros.h" +# include "arrow/util/visibility.h" namespace arrow { namespace util { @@ -54,115 +54,115 @@ enum class ArrowLogLevel : int { ARROW_FATAL = 3 }; -#define ARROW_LOG_INTERNAL(level) ::arrow::util::ArrowLog(__FILE__, __LINE__, level) -#define ARROW_LOG(level) ARROW_LOG_INTERNAL(::arrow::util::ArrowLogLevel::ARROW_##level) +# define ARROW_LOG_INTERNAL(level) ::arrow::util::ArrowLog(__FILE__, __LINE__, level) +# define ARROW_LOG(level) ARROW_LOG_INTERNAL(::arrow::util::ArrowLogLevel::ARROW_##level) -#define ARROW_IGNORE_EXPR(expr) ((void)(expr)) +# define ARROW_IGNORE_EXPR(expr) ((void)(expr)) -#define ARROW_CHECK_OR_LOG(condition, level) \ - ARROW_PREDICT_TRUE(condition) \ - ? ARROW_IGNORE_EXPR(0) \ - : ::arrow::util::Voidify() & ARROW_LOG(level) << " Check failed: " #condition " " +# define ARROW_CHECK_OR_LOG(condition, level) \ + ARROW_PREDICT_TRUE(condition) \ + ? ARROW_IGNORE_EXPR(0) \ + : ::arrow::util::Voidify() & ARROW_LOG(level) << " Check failed: " #condition " " -#define ARROW_CHECK(condition) ARROW_CHECK_OR_LOG(condition, FATAL) +# define ARROW_CHECK(condition) ARROW_CHECK_OR_LOG(condition, FATAL) // If 'to_call' returns a bad status, CHECK immediately with a logged message // of 'msg' followed by the status. -#define ARROW_CHECK_OK_PREPEND(to_call, msg, level) \ - do { \ - ::arrow::Status _s = (to_call); \ - ARROW_CHECK_OR_LOG(_s.ok(), level) \ - << "Operation failed: " << ARROW_STRINGIFY(to_call) << "\n" \ - << (msg) << ": " << _s.ToString(); \ - } while (false) +# define ARROW_CHECK_OK_PREPEND(to_call, msg, level) \ + do { \ + ::arrow::Status _s = (to_call); \ + ARROW_CHECK_OR_LOG(_s.ok(), level) \ + << "Operation failed: " << ARROW_STRINGIFY(to_call) << "\n" \ + << (msg) << ": " << _s.ToString(); \ + } while (false) // If the status is bad, CHECK immediately, appending the status to the // logged message. -#define ARROW_CHECK_OK(s) ARROW_CHECK_OK_PREPEND(s, "Bad status", FATAL) +# define ARROW_CHECK_OK(s) ARROW_CHECK_OK_PREPEND(s, "Bad status", FATAL) -#define ARROW_CHECK_EQ(val1, val2) ARROW_CHECK((val1) == (val2)) -#define ARROW_CHECK_NE(val1, val2) ARROW_CHECK((val1) != (val2)) -#define ARROW_CHECK_LE(val1, val2) ARROW_CHECK((val1) <= (val2)) -#define ARROW_CHECK_LT(val1, val2) ARROW_CHECK((val1) < (val2)) -#define ARROW_CHECK_GE(val1, val2) ARROW_CHECK((val1) >= (val2)) -#define ARROW_CHECK_GT(val1, val2) ARROW_CHECK((val1) > (val2)) +# define ARROW_CHECK_EQ(val1, val2) ARROW_CHECK((val1) == (val2)) +# define ARROW_CHECK_NE(val1, val2) ARROW_CHECK((val1) != (val2)) +# define ARROW_CHECK_LE(val1, val2) ARROW_CHECK((val1) <= (val2)) +# define ARROW_CHECK_LT(val1, val2) ARROW_CHECK((val1) < (val2)) +# define ARROW_CHECK_GE(val1, val2) ARROW_CHECK((val1) >= (val2)) +# define ARROW_CHECK_GT(val1, val2) ARROW_CHECK((val1) > (val2)) -#ifdef NDEBUG -#define ARROW_DFATAL ::arrow::util::ArrowLogLevel::ARROW_WARNING +# ifdef NDEBUG +# define ARROW_DFATAL ::arrow::util::ArrowLogLevel::ARROW_WARNING // CAUTION: DCHECK_OK() always evaluates its argument, but other DCHECK*() macros // only do so in debug mode. -#define ARROW_DCHECK(condition) \ - while (false) ARROW_IGNORE_EXPR(condition); \ - while (false) ::arrow::util::detail::NullLog() -#define ARROW_DCHECK_OK(s) \ - ARROW_IGNORE_EXPR(s); \ - while (false) ::arrow::util::detail::NullLog() -#define ARROW_DCHECK_EQ(val1, val2) \ - while (false) ARROW_IGNORE_EXPR(val1); \ - while (false) ARROW_IGNORE_EXPR(val2); \ - while (false) ::arrow::util::detail::NullLog() -#define ARROW_DCHECK_NE(val1, val2) \ - while (false) ARROW_IGNORE_EXPR(val1); \ - while (false) ARROW_IGNORE_EXPR(val2); \ - while (false) ::arrow::util::detail::NullLog() -#define ARROW_DCHECK_LE(val1, val2) \ - while (false) ARROW_IGNORE_EXPR(val1); \ - while (false) ARROW_IGNORE_EXPR(val2); \ - while (false) ::arrow::util::detail::NullLog() -#define ARROW_DCHECK_LT(val1, val2) \ - while (false) ARROW_IGNORE_EXPR(val1); \ - while (false) ARROW_IGNORE_EXPR(val2); \ - while (false) ::arrow::util::detail::NullLog() -#define ARROW_DCHECK_GE(val1, val2) \ - while (false) ARROW_IGNORE_EXPR(val1); \ - while (false) ARROW_IGNORE_EXPR(val2); \ - while (false) ::arrow::util::detail::NullLog() -#define ARROW_DCHECK_GT(val1, val2) \ - while (false) ARROW_IGNORE_EXPR(val1); \ - while (false) ARROW_IGNORE_EXPR(val2); \ - while (false) ::arrow::util::detail::NullLog() - -#else -#define ARROW_DFATAL ::arrow::util::ArrowLogLevel::ARROW_FATAL - -#define ARROW_DCHECK ARROW_CHECK -#define ARROW_DCHECK_OK ARROW_CHECK_OK -#define ARROW_DCHECK_EQ ARROW_CHECK_EQ -#define ARROW_DCHECK_NE ARROW_CHECK_NE -#define ARROW_DCHECK_LE ARROW_CHECK_LE -#define ARROW_DCHECK_LT ARROW_CHECK_LT -#define ARROW_DCHECK_GE ARROW_CHECK_GE -#define ARROW_DCHECK_GT ARROW_CHECK_GT - -#endif // NDEBUG +# define ARROW_DCHECK(condition) \ + while (false) ARROW_IGNORE_EXPR(condition); \ + while (false) ::arrow::util::detail::NullLog() +# define ARROW_DCHECK_OK(s) \ + ARROW_IGNORE_EXPR(s); \ + while (false) ::arrow::util::detail::NullLog() +# define ARROW_DCHECK_EQ(val1, val2) \ + while (false) ARROW_IGNORE_EXPR(val1); \ + while (false) ARROW_IGNORE_EXPR(val2); \ + while (false) ::arrow::util::detail::NullLog() +# define ARROW_DCHECK_NE(val1, val2) \ + while (false) ARROW_IGNORE_EXPR(val1); \ + while (false) ARROW_IGNORE_EXPR(val2); \ + while (false) ::arrow::util::detail::NullLog() +# define ARROW_DCHECK_LE(val1, val2) \ + while (false) ARROW_IGNORE_EXPR(val1); \ + while (false) ARROW_IGNORE_EXPR(val2); \ + while (false) ::arrow::util::detail::NullLog() +# define ARROW_DCHECK_LT(val1, val2) \ + while (false) ARROW_IGNORE_EXPR(val1); \ + while (false) ARROW_IGNORE_EXPR(val2); \ + while (false) ::arrow::util::detail::NullLog() +# define ARROW_DCHECK_GE(val1, val2) \ + while (false) ARROW_IGNORE_EXPR(val1); \ + while (false) ARROW_IGNORE_EXPR(val2); \ + while (false) ::arrow::util::detail::NullLog() +# define ARROW_DCHECK_GT(val1, val2) \ + while (false) ARROW_IGNORE_EXPR(val1); \ + while (false) ARROW_IGNORE_EXPR(val2); \ + while (false) ::arrow::util::detail::NullLog() + +# else +# define ARROW_DFATAL ::arrow::util::ArrowLogLevel::ARROW_FATAL + +# define ARROW_DCHECK ARROW_CHECK +# define ARROW_DCHECK_OK ARROW_CHECK_OK +# define ARROW_DCHECK_EQ ARROW_CHECK_EQ +# define ARROW_DCHECK_NE ARROW_CHECK_NE +# define ARROW_DCHECK_LE ARROW_CHECK_LE +# define ARROW_DCHECK_LT ARROW_CHECK_LT +# define ARROW_DCHECK_GE ARROW_CHECK_GE +# define ARROW_DCHECK_GT ARROW_CHECK_GT + +# endif // NDEBUG // These are internal-use macros and should not be used in public headers. -#ifndef DCHECK -#define DCHECK ARROW_DCHECK -#endif -#ifndef DCHECK_OK -#define DCHECK_OK ARROW_DCHECK_OK -#endif -#ifndef DCHECK_EQ -#define DCHECK_EQ ARROW_DCHECK_EQ -#endif -#ifndef DCHECK_NE -#define DCHECK_NE ARROW_DCHECK_NE -#endif -#ifndef DCHECK_LE -#define DCHECK_LE ARROW_DCHECK_LE -#endif -#ifndef DCHECK_LT -#define DCHECK_LT ARROW_DCHECK_LT -#endif -#ifndef DCHECK_GE -#define DCHECK_GE ARROW_DCHECK_GE -#endif -#ifndef DCHECK_GT -#define DCHECK_GT ARROW_DCHECK_GT -#endif +# ifndef DCHECK +# define DCHECK ARROW_DCHECK +# endif +# ifndef DCHECK_OK +# define DCHECK_OK ARROW_DCHECK_OK +# endif +# ifndef DCHECK_EQ +# define DCHECK_EQ ARROW_DCHECK_EQ +# endif +# ifndef DCHECK_NE +# define DCHECK_NE ARROW_DCHECK_NE +# endif +# ifndef DCHECK_LE +# define DCHECK_LE ARROW_DCHECK_LE +# endif +# ifndef DCHECK_LT +# define DCHECK_LT ARROW_DCHECK_LT +# endif +# ifndef DCHECK_GE +# define DCHECK_GE ARROW_DCHECK_GE +# endif +# ifndef DCHECK_GT +# define DCHECK_GT ARROW_DCHECK_GT +# endif // This code is adapted from // https://github.com/ray-project/ray/blob/master/src/ray/util/logging.h. diff --git a/cpp/src/arrow/util/macros.h b/cpp/src/arrow/util/macros.h index 484df3400d92d..5658874b42b6c 100644 --- a/cpp/src/arrow/util/macros.h +++ b/cpp/src/arrow/util/macros.h @@ -25,15 +25,15 @@ // From Google gutil #ifndef ARROW_DISALLOW_COPY_AND_ASSIGN -#define ARROW_DISALLOW_COPY_AND_ASSIGN(TypeName) \ - TypeName(const TypeName&) = delete; \ - void operator=(const TypeName&) = delete +# define ARROW_DISALLOW_COPY_AND_ASSIGN(TypeName) \ + TypeName(const TypeName&) = delete; \ + void operator=(const TypeName&) = delete #endif #ifndef ARROW_DEFAULT_MOVE_AND_ASSIGN -#define ARROW_DEFAULT_MOVE_AND_ASSIGN(TypeName) \ - TypeName(TypeName&&) = default; \ - TypeName& operator=(TypeName&&) = default +# define ARROW_DEFAULT_MOVE_AND_ASSIGN(TypeName) \ + TypeName(TypeName&&) = default; \ + TypeName& operator=(TypeName&&) = default #endif // With ARROW_PREDICT_FALSE, GCC and clang can be told that a certain branch is @@ -68,55 +68,55 @@ // Program Annotations". https://github.com/jdoerfert/PETOSPA/blob/master/ISC19.pdf #define ARROW_UNUSED(x) (void)(x) #ifdef ARROW_WARN_DOCUMENTATION -#define ARROW_ARG_UNUSED(x) x +# define ARROW_ARG_UNUSED(x) x #else -#define ARROW_ARG_UNUSED(x) +# define ARROW_ARG_UNUSED(x) #endif #if defined(__GNUC__) // GCC and compatible compilers (clang, Intel ICC) -#define ARROW_NORETURN __attribute__((noreturn)) -#define ARROW_NOINLINE __attribute__((noinline)) -#define ARROW_FORCE_INLINE __attribute__((always_inline)) -#define ARROW_PREDICT_FALSE(x) (__builtin_expect(!!(x), 0)) -#define ARROW_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1)) -#define ARROW_PREFETCH(addr) __builtin_prefetch(addr) -#define ARROW_RESTRICT __restrict -#if defined(__clang__) // clang-specific -#define ARROW_COMPILER_ASSUME(expr) __builtin_assume(expr) -#else // GCC-specific -#if __GNUC__ >= 13 -#define ARROW_COMPILER_ASSUME(expr) __attribute__((assume(expr))) -#else +# define ARROW_NORETURN __attribute__((noreturn)) +# define ARROW_NOINLINE __attribute__((noinline)) +# define ARROW_FORCE_INLINE __attribute__((always_inline)) +# define ARROW_PREDICT_FALSE(x) (__builtin_expect(!!(x), 0)) +# define ARROW_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1)) +# define ARROW_PREFETCH(addr) __builtin_prefetch(addr) +# define ARROW_RESTRICT __restrict +# if defined(__clang__) // clang-specific +# define ARROW_COMPILER_ASSUME(expr) __builtin_assume(expr) +# else // GCC-specific +# if __GNUC__ >= 13 +# define ARROW_COMPILER_ASSUME(expr) __attribute__((assume(expr))) +# else // GCC does not have a built-in assume intrinsic before GCC 13, so we use an // if statement and __builtin_unreachable() to achieve the same effect [2]. // Unlike clang's __builtin_assume and C++23's [[assume(expr)]], using this // on GCC won't warn about side-effects in the expression, so make sure expr // is side-effect free when working with GCC versions before 13 (Jan-2024), // otherwise clang/MSVC builds will fail in CI. -#define ARROW_COMPILER_ASSUME(expr) \ - if (expr) { \ - } else { \ - __builtin_unreachable(); \ - } -#endif // __GNUC__ >= 13 -#endif +# define ARROW_COMPILER_ASSUME(expr) \ + if (expr) { \ + } else { \ + __builtin_unreachable(); \ + } +# endif // __GNUC__ >= 13 +# endif #elif defined(_MSC_VER) // MSVC -#define ARROW_NORETURN __declspec(noreturn) -#define ARROW_NOINLINE __declspec(noinline) -#define ARROW_FORCE_INLINE __forceinline -#define ARROW_PREDICT_FALSE(x) (x) -#define ARROW_PREDICT_TRUE(x) (x) -#define ARROW_PREFETCH(addr) -#define ARROW_RESTRICT __restrict -#define ARROW_COMPILER_ASSUME(expr) __assume(expr) +# define ARROW_NORETURN __declspec(noreturn) +# define ARROW_NOINLINE __declspec(noinline) +# define ARROW_FORCE_INLINE __forceinline +# define ARROW_PREDICT_FALSE(x) (x) +# define ARROW_PREDICT_TRUE(x) (x) +# define ARROW_PREFETCH(addr) +# define ARROW_RESTRICT __restrict +# define ARROW_COMPILER_ASSUME(expr) __assume(expr) #else -#define ARROW_NORETURN -#define ARROW_NOINLINE -#define ARROW_FORCE_INLINE -#define ARROW_PREDICT_FALSE(x) (x) -#define ARROW_PREDICT_TRUE(x) (x) -#define ARROW_PREFETCH(addr) -#define ARROW_RESTRICT -#define ARROW_COMPILER_ASSUME(expr) +# define ARROW_NORETURN +# define ARROW_NOINLINE +# define ARROW_FORCE_INLINE +# define ARROW_PREDICT_FALSE(x) (x) +# define ARROW_PREDICT_TRUE(x) (x) +# define ARROW_PREFETCH(addr) +# define ARROW_RESTRICT +# define ARROW_COMPILER_ASSUME(expr) #endif // ---------------------------------------------------------------------- @@ -124,11 +124,11 @@ #ifndef NULLPTR -#ifdef __cplusplus_cli -#define NULLPTR __nullptr -#else -#define NULLPTR nullptr -#endif +# ifdef __cplusplus_cli +# define NULLPTR __nullptr +# else +# define NULLPTR nullptr +# endif #endif // ifndef NULLPTR @@ -154,22 +154,22 @@ // Macros to disable deprecation warnings #ifdef __clang__ -#define ARROW_SUPPRESS_DEPRECATION_WARNING \ - _Pragma("clang diagnostic push"); \ - _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") -#define ARROW_UNSUPPRESS_DEPRECATION_WARNING _Pragma("clang diagnostic pop") +# define ARROW_SUPPRESS_DEPRECATION_WARNING \ + _Pragma("clang diagnostic push"); \ + _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") +# define ARROW_UNSUPPRESS_DEPRECATION_WARNING _Pragma("clang diagnostic pop") #elif defined(__GNUC__) -#define ARROW_SUPPRESS_DEPRECATION_WARNING \ - _Pragma("GCC diagnostic push"); \ - _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") -#define ARROW_UNSUPPRESS_DEPRECATION_WARNING _Pragma("GCC diagnostic pop") +# define ARROW_SUPPRESS_DEPRECATION_WARNING \ + _Pragma("GCC diagnostic push"); \ + _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +# define ARROW_UNSUPPRESS_DEPRECATION_WARNING _Pragma("GCC diagnostic pop") #elif defined(_MSC_VER) -#define ARROW_SUPPRESS_DEPRECATION_WARNING \ - __pragma(warning(push)) __pragma(warning(disable : 4996)) -#define ARROW_UNSUPPRESS_DEPRECATION_WARNING __pragma(warning(pop)) +# define ARROW_SUPPRESS_DEPRECATION_WARNING \ + __pragma(warning(push)) __pragma(warning(disable : 4996)) +# define ARROW_UNSUPPRESS_DEPRECATION_WARNING __pragma(warning(pop)) #else -#define ARROW_SUPPRESS_DEPRECATION_WARNING -#define ARROW_UNSUPPRESS_DEPRECATION_WARNING +# define ARROW_SUPPRESS_DEPRECATION_WARNING +# define ARROW_UNSUPPRESS_DEPRECATION_WARNING #endif // ---------------------------------------------------------------------- @@ -178,41 +178,42 @@ // these macros are portable across different compilers and platforms //[https://github.com/google/flatbuffers/blob/master/include/flatbuffers/flatbuffers.h#L1355] #if !defined(MANUALLY_ALIGNED_STRUCT) -#if defined(_MSC_VER) -#define MANUALLY_ALIGNED_STRUCT(alignment) \ - __pragma(pack(1)); \ - struct __declspec(align(alignment)) -#define STRUCT_END(name, size) \ - __pragma(pack()); \ - static_assert(sizeof(name) == size, "compiler breaks packing rules") -#elif defined(__GNUC__) || defined(__clang__) -#define MANUALLY_ALIGNED_STRUCT(alignment) \ - _Pragma("pack(1)") struct __attribute__((aligned(alignment))) -#define STRUCT_END(name, size) \ - _Pragma("pack()") static_assert(sizeof(name) == size, "compiler breaks packing rules") -#else -#error Unknown compiler, please define structure alignment macros -#endif +# if defined(_MSC_VER) +# define MANUALLY_ALIGNED_STRUCT(alignment) \ + __pragma(pack(1)); \ + struct __declspec(align(alignment)) +# define STRUCT_END(name, size) \ + __pragma(pack()); \ + static_assert(sizeof(name) == size, "compiler breaks packing rules") +# elif defined(__GNUC__) || defined(__clang__) +# define MANUALLY_ALIGNED_STRUCT(alignment) \ + _Pragma("pack(1)") struct __attribute__((aligned(alignment))) +# define STRUCT_END(name, size) \ + _Pragma("pack()") static_assert(sizeof(name) == size, \ + "compiler breaks packing rules") +# else +# error Unknown compiler, please define structure alignment macros +# endif #endif // !defined(MANUALLY_ALIGNED_STRUCT) // ---------------------------------------------------------------------- // Convenience macro disabling a particular UBSan check in a function #if defined(__clang__) -#define ARROW_DISABLE_UBSAN(feature) __attribute__((no_sanitize(feature))) +# define ARROW_DISABLE_UBSAN(feature) __attribute__((no_sanitize(feature))) #else -#define ARROW_DISABLE_UBSAN(feature) +# define ARROW_DISABLE_UBSAN(feature) #endif // ---------------------------------------------------------------------- // Machine information #if INTPTR_MAX == INT64_MAX -#define ARROW_BITNESS 64 +# define ARROW_BITNESS 64 #elif INTPTR_MAX == INT32_MAX -#define ARROW_BITNESS 32 +# define ARROW_BITNESS 32 #else -#error Unexpected INTPTR_MAX +# error Unexpected INTPTR_MAX #endif // ---------------------------------------------------------------------- diff --git a/cpp/src/arrow/util/math_constants.h b/cpp/src/arrow/util/math_constants.h index 7ee87c5d6ac81..3524f88e0ba9a 100644 --- a/cpp/src/arrow/util/math_constants.h +++ b/cpp/src/arrow/util/math_constants.h @@ -22,11 +22,11 @@ // Not provided by default in MSVC, // and _USE_MATH_DEFINES is not reliable with unity builds #ifndef M_PI -#define M_PI 3.14159265358979323846 +# define M_PI 3.14159265358979323846 #endif #ifndef M_PI_2 -#define M_PI_2 1.57079632679489661923 +# define M_PI_2 1.57079632679489661923 #endif #ifndef M_PI_4 -#define M_PI_4 0.785398163397448309616 +# define M_PI_4 0.785398163397448309616 #endif diff --git a/cpp/src/arrow/util/mutex.cc b/cpp/src/arrow/util/mutex.cc index bbf2a9a93e692..e170a8648a1fd 100644 --- a/cpp/src/arrow/util/mutex.cc +++ b/cpp/src/arrow/util/mutex.cc @@ -20,8 +20,8 @@ #include #ifndef _WIN32 -#include -#include +# include +# include #endif #include "arrow/util/config.h" diff --git a/cpp/src/arrow/util/simd.h b/cpp/src/arrow/util/simd.h index ee9105d5f4beb..b37f6e4926978 100644 --- a/cpp/src/arrow/util/simd.h +++ b/cpp/src/arrow/util/simd.h @@ -20,25 +20,25 @@ #ifdef _MSC_VER // MSVC x86_64/arm64 -#if defined(_M_AMD64) || defined(_M_X64) -#include -#endif +# if defined(_M_AMD64) || defined(_M_X64) +# include +# endif #else // gcc/clang (possibly others) -#if defined(ARROW_HAVE_BMI2) -#include -#endif +# if defined(ARROW_HAVE_BMI2) +# include +# endif -#if defined(ARROW_HAVE_AVX2) || defined(ARROW_HAVE_AVX512) -#include -#elif defined(ARROW_HAVE_SSE4_2) -#include -#endif +# if defined(ARROW_HAVE_AVX2) || defined(ARROW_HAVE_AVX512) +# include +# elif defined(ARROW_HAVE_SSE4_2) +# include +# endif -#ifdef ARROW_HAVE_NEON -#include -#endif +# ifdef ARROW_HAVE_NEON +# include +# endif #endif diff --git a/cpp/src/arrow/util/small_vector_benchmark.cc b/cpp/src/arrow/util/small_vector_benchmark.cc index 96f94c369e61e..04ad547221b2c 100644 --- a/cpp/src/arrow/util/small_vector_benchmark.cc +++ b/cpp/src/arrow/util/small_vector_benchmark.cc @@ -321,10 +321,10 @@ void LongVectorInsertAtEnd(benchmark::State& state) { #ifdef ARROW_WITH_BENCHMARKS_REFERENCE -#define STD_VECTOR(T) std::vector +# define STD_VECTOR(T) std::vector SHORT_VECTOR_BENCHMARKS(STD_VECTOR); LONG_VECTOR_BENCHMARKS(STD_VECTOR); -#undef STD_VECTOR +# undef STD_VECTOR #endif diff --git a/cpp/src/arrow/util/string.h b/cpp/src/arrow/util/string.h index d7e377773f62f..f2081d0937b77 100644 --- a/cpp/src/arrow/util/string.h +++ b/cpp/src/arrow/util/string.h @@ -26,7 +26,7 @@ #include #if __has_include() -#include +# include #endif #include "arrow/result.h" diff --git a/cpp/src/arrow/util/thread_pool.cc b/cpp/src/arrow/util/thread_pool.cc index d82934c9bec01..d59d1f20de7c3 100644 --- a/cpp/src/arrow/util/thread_pool.cc +++ b/cpp/src/arrow/util/thread_pool.cc @@ -128,7 +128,7 @@ int SerialExecutor::GetNumTasks() { #ifdef ARROW_ENABLE_THREADING Status SerialExecutor::SpawnReal(TaskHints hints, FnOnce task, StopToken stop_token, StopCallback&& stop_callback) { -#ifdef ARROW_WITH_OPENTELEMETRY +# ifdef ARROW_WITH_OPENTELEMETRY // Wrap the task to propagate a parent tracing span to it // XXX should there be a generic utility in tracing_internal.h for this? task = [func = std::move(task), @@ -137,7 +137,7 @@ Status SerialExecutor::SpawnReal(TaskHints hints, FnOnce task, auto scope = ::arrow::internal::tracing::GetTracer()->WithActiveSpan(active_span); std::move(func)(); }; -#endif +# endif // While the SerialExecutor runs tasks synchronously on its main thread, // SpawnReal may be called from external threads (e.g. when transferring back // from blocking I/O threads), so we need to keep the state alive *and* to @@ -172,7 +172,7 @@ void SerialExecutor::Finish() { #else // ARROW_ENABLE_THREADING Status SerialExecutor::SpawnReal(TaskHints hints, FnOnce task, StopToken stop_token, StopCallback&& stop_callback) { -#ifdef ARROW_WITH_OPENTELEMETRY +# ifdef ARROW_WITH_OPENTELEMETRY // Wrap the task to propagate a parent tracing span to it // XXX should there be a generic utility in tracing_internal.h for this? task = [func = std::move(task), @@ -181,7 +181,7 @@ Status SerialExecutor::SpawnReal(TaskHints hints, FnOnce task, auto scope = ::arrow::internal::tracing::GetTracer()->WithActiveSpan(active_span); std::move(func)(); }; -#endif // ARROW_WITH_OPENTELEMETRY +# endif // ARROW_WITH_OPENTELEMETRY if (state_->finished) { return Status::Invalid( @@ -503,7 +503,7 @@ ThreadPool::ThreadPool() shutdown_on_destroy_(true) { // Eternal thread pools would produce false leak reports in the vector of // atfork handlers. -#if !(defined(_WIN32) || defined(ADDRESS_SANITIZER) || defined(ARROW_VALGRIND)) +# if !(defined(_WIN32) || defined(ADDRESS_SANITIZER) || defined(ARROW_VALGRIND)) state_->atfork_handler_ = std::make_shared( /*before=*/ [weak_state = std::weak_ptr(sp_state_)]() { @@ -528,7 +528,7 @@ ThreadPool::ThreadPool() } }); RegisterAtFork(state_->atfork_handler_); -#endif +# endif } ThreadPool::~ThreadPool() { @@ -623,7 +623,7 @@ void ThreadPool::LaunchWorkersUnlocked(int threads) { Status ThreadPool::SpawnReal(TaskHints hints, FnOnce task, StopToken stop_token, StopCallback&& stop_callback) { { -#ifdef ARROW_WITH_OPENTELEMETRY +# ifdef ARROW_WITH_OPENTELEMETRY // Wrap the task to propagate a parent tracing span to it // This task-wrapping needs to be done before we grab the mutex because the // first call to OT (whatever that happens to be) will attempt to grab this mutex @@ -638,7 +638,7 @@ Status ThreadPool::SpawnReal(TaskHints hints, FnOnce task, StopToken sto } wrapper{std::forward>(task), ::arrow::internal::tracing::GetTracer()->GetCurrentSpan()}; task = std::move(wrapper); -#endif +# endif std::lock_guard lock(state_->mutex_); if (state_->please_shutdown_) { return Status::Invalid("operation forbidden during or after shutdown"); @@ -674,9 +674,9 @@ Result> ThreadPool::MakeEternal(int threads) { // On Windows, the ThreadPool destructor may be called after non-main threads // have been killed by the OS, and hang in a condition variable. // On Unix, we want to avoid leak reports by Valgrind. -#ifdef _WIN32 +# ifdef _WIN32 pool->shutdown_on_destroy_ = false; -#endif +# endif return pool; } diff --git a/cpp/src/arrow/util/thread_pool.h b/cpp/src/arrow/util/thread_pool.h index 44b1e227b0e5f..cd32781aed756 100644 --- a/cpp/src/arrow/util/thread_pool.h +++ b/cpp/src/arrow/util/thread_pool.h @@ -36,7 +36,7 @@ #if defined(_MSC_VER) // Disable harmless warning for decorated name length limit -#pragma warning(disable : 4503) +# pragma warning(disable : 4503) #endif namespace arrow { diff --git a/cpp/src/arrow/util/thread_pool_test.cc b/cpp/src/arrow/util/thread_pool_test.cc index 8f43bb8dec367..7cf8826e8a173 100644 --- a/cpp/src/arrow/util/thread_pool_test.cc +++ b/cpp/src/arrow/util/thread_pool_test.cc @@ -16,8 +16,8 @@ // under the License. #ifndef _WIN32 -#include -#include +# include +# include #endif #include @@ -830,9 +830,9 @@ class TestThreadPoolForkSafety : public TestThreadPool {}; TEST_F(TestThreadPoolForkSafety, Basics) { { -#ifndef ARROW_ENABLE_THREADING +# ifndef ARROW_ENABLE_THREADING GTEST_SKIP() << "Test requires threading support"; -#endif +# endif // Fork after task submission auto pool = this->MakeThreadPool(3); @@ -877,9 +877,9 @@ TEST_F(TestThreadPoolForkSafety, Basics) { } TEST_F(TestThreadPoolForkSafety, MultipleChildThreads) { -#ifndef ARROW_ENABLE_THREADING +# ifndef ARROW_ENABLE_THREADING GTEST_SKIP() << "Test requires threading support"; -#endif +# endif // ARROW-15593: race condition in after-fork ThreadPool reinitialization // when SpawnReal() was called from multiple threads in a forked child. auto run_in_child = [](ThreadPool* pool) { @@ -927,12 +927,12 @@ TEST_F(TestThreadPoolForkSafety, MultipleChildThreads) { TEST_F(TestThreadPoolForkSafety, NestedChild) { { -#ifdef __APPLE__ +# ifdef __APPLE__ GTEST_SKIP() << "Nested fork is not supported on macos"; -#endif -#ifndef ARROW_ENABLE_THREADING +# endif +# ifndef ARROW_ENABLE_THREADING GTEST_SKIP() << "Test requires threading support"; -#endif +# endif auto pool = this->MakeThreadPool(3); ASSERT_OK_AND_ASSIGN(auto fut, pool->Submit(add, 4, 5)); ASSERT_OK_AND_EQ(9, fut.result()); diff --git a/cpp/src/arrow/util/tracing_internal.cc b/cpp/src/arrow/util/tracing_internal.cc index f4f65ad1e6132..e47acf42bccd1 100644 --- a/cpp/src/arrow/util/tracing_internal.cc +++ b/cpp/src/arrow/util/tracing_internal.cc @@ -26,8 +26,8 @@ #include #ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4522) +# pragma warning(push) +# pragma warning(disable : 4522) #endif #include @@ -45,7 +45,7 @@ #include #include #ifdef _MSC_VER -#pragma warning(pop) +# pragma warning(pop) #endif #include "arrow/util/io_util.h" diff --git a/cpp/src/arrow/util/tracing_internal.h b/cpp/src/arrow/util/tracing_internal.h index a031edf08dc77..6ed731599a9d4 100644 --- a/cpp/src/arrow/util/tracing_internal.h +++ b/cpp/src/arrow/util/tracing_internal.h @@ -23,15 +23,15 @@ #include "arrow/util/config.h" #ifdef ARROW_WITH_OPENTELEMETRY -#ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4522) -#endif -#include -#include -#ifdef _MSC_VER -#pragma warning(pop) -#endif +# ifdef _MSC_VER +# pragma warning(push) +# pragma warning(disable : 4522) +# endif +# include +# include +# ifdef _MSC_VER +# pragma warning(pop) +# endif #endif #include "arrow/memory_pool.h" @@ -135,77 +135,78 @@ opentelemetry::nostd::shared_ptr& RewrapSpan( opentelemetry::trace::StartSpanOptions SpanOptionsWithParent( const util::tracing::Span& parent_span); -#define START_SPAN(target_span, ...) \ - auto opentelemetry_scope##__LINE__ = \ - ::arrow::internal::tracing::GetTracer()->WithActiveSpan( \ - ::arrow::internal::tracing::RewrapSpan( \ - target_span.details.get(), \ - ::arrow::internal::tracing::GetTracer()->StartSpan(__VA_ARGS__))) - -#define START_SCOPED_SPAN(target_span, ...) \ - ::arrow::internal::tracing::Scope( \ - ::arrow::internal::tracing::GetTracer()->WithActiveSpan( \ - ::arrow::internal::tracing::RewrapSpan( \ - target_span.details.get(), \ - ::arrow::internal::tracing::GetTracer()->StartSpan(__VA_ARGS__)))) - -#define START_SCOPED_SPAN_SV(target_span, name, ...) \ - ::arrow::internal::tracing::Scope( \ - ::arrow::internal::tracing::GetTracer()->WithActiveSpan( \ - ::arrow::internal::tracing::RewrapSpan( \ - target_span.details.get(), \ - ::arrow::internal::tracing::GetTracer()->StartSpan( \ - ::opentelemetry::nostd::string_view(name.data(), name.size()), \ - ##__VA_ARGS__)))) - -#define START_SCOPED_SPAN_WITH_PARENT_SV(target_span, parent_span, name, ...) \ - ::arrow::internal::tracing::Scope( \ - ::arrow::internal::tracing::GetTracer()->WithActiveSpan( \ - ::arrow::internal::tracing::RewrapSpan( \ - target_span.details.get(), \ - \ - ::arrow::internal::tracing::GetTracer()->StartSpan( \ - ::opentelemetry::nostd::string_view(name.data(), name.size()), \ - __VA_ARGS__, \ - ::arrow::internal::tracing::SpanOptionsWithParent(parent_span))))) - -#define START_COMPUTE_SPAN(target_span, ...) \ - START_SPAN(target_span, __VA_ARGS__); \ - ::arrow::internal::tracing::UnwrapSpan(target_span.details.get()) \ - ->SetAttribute("arrow.memory_pool_bytes", \ - ::arrow::default_memory_pool()->bytes_allocated()) - -#define EVENT_ON_CURRENT_SPAN(...) \ - ::arrow::internal::tracing::GetTracer()->GetCurrentSpan()->AddEvent(__VA_ARGS__) - -#define EVENT(target_span, ...) \ - ::arrow::internal::tracing::UnwrapSpan(target_span.details.get())->AddEvent(__VA_ARGS__) - -#define ACTIVATE_SPAN(target_span) \ - ::arrow::internal::tracing::Scope( \ - ::arrow::internal::tracing::GetTracer()->WithActiveSpan( \ - ::arrow::internal::tracing::UnwrapSpan(target_span.details.get()))) - -#define MARK_SPAN(target_span, status) \ - ::arrow::internal::tracing::MarkSpan( \ - status, ::arrow::internal::tracing::UnwrapSpan(target_span.details.get()).get()) - -#define END_SPAN(target_span) \ - ::arrow::internal::tracing::UnwrapSpan(target_span.details.get())->End() - -#define END_SPAN_ON_FUTURE_COMPLETION(target_span, target_future) \ - target_future.SetSpan(&target_span) - -#define PROPAGATE_SPAN_TO_GENERATOR(generator) \ - generator = ::arrow::internal::tracing::PropagateSpanThroughAsyncGenerator( \ - std::move(generator)) - -#define WRAP_ASYNC_GENERATOR(generator) \ - generator = ::arrow::internal::tracing::WrapAsyncGenerator(std::move(generator)) - -#define WRAP_ASYNC_GENERATOR_WITH_CHILD_SPAN(generator, name) \ - generator = \ - ::arrow::internal::tracing::WrapAsyncGenerator(std::move(generator), name, true) +# define START_SPAN(target_span, ...) \ + auto opentelemetry_scope##__LINE__ = \ + ::arrow::internal::tracing::GetTracer()->WithActiveSpan( \ + ::arrow::internal::tracing::RewrapSpan( \ + target_span.details.get(), \ + ::arrow::internal::tracing::GetTracer()->StartSpan(__VA_ARGS__))) + +# define START_SCOPED_SPAN(target_span, ...) \ + ::arrow::internal::tracing::Scope( \ + ::arrow::internal::tracing::GetTracer()->WithActiveSpan( \ + ::arrow::internal::tracing::RewrapSpan( \ + target_span.details.get(), \ + ::arrow::internal::tracing::GetTracer()->StartSpan(__VA_ARGS__)))) + +# define START_SCOPED_SPAN_SV(target_span, name, ...) \ + ::arrow::internal::tracing::Scope( \ + ::arrow::internal::tracing::GetTracer()->WithActiveSpan( \ + ::arrow::internal::tracing::RewrapSpan( \ + target_span.details.get(), \ + ::arrow::internal::tracing::GetTracer()->StartSpan( \ + ::opentelemetry::nostd::string_view(name.data(), name.size()), \ + ##__VA_ARGS__)))) + +# define START_SCOPED_SPAN_WITH_PARENT_SV(target_span, parent_span, name, ...) \ + ::arrow::internal::tracing::Scope( \ + ::arrow::internal::tracing::GetTracer()->WithActiveSpan( \ + ::arrow::internal::tracing::RewrapSpan( \ + target_span.details.get(), \ + \ + ::arrow::internal::tracing::GetTracer()->StartSpan( \ + ::opentelemetry::nostd::string_view(name.data(), name.size()), \ + __VA_ARGS__, \ + ::arrow::internal::tracing::SpanOptionsWithParent(parent_span))))) + +# define START_COMPUTE_SPAN(target_span, ...) \ + START_SPAN(target_span, __VA_ARGS__); \ + ::arrow::internal::tracing::UnwrapSpan(target_span.details.get()) \ + ->SetAttribute("arrow.memory_pool_bytes", \ + ::arrow::default_memory_pool()->bytes_allocated()) + +# define EVENT_ON_CURRENT_SPAN(...) \ + ::arrow::internal::tracing::GetTracer()->GetCurrentSpan()->AddEvent(__VA_ARGS__) + +# define EVENT(target_span, ...) \ + ::arrow::internal::tracing::UnwrapSpan(target_span.details.get()) \ + ->AddEvent(__VA_ARGS__) + +# define ACTIVATE_SPAN(target_span) \ + ::arrow::internal::tracing::Scope( \ + ::arrow::internal::tracing::GetTracer()->WithActiveSpan( \ + ::arrow::internal::tracing::UnwrapSpan(target_span.details.get()))) + +# define MARK_SPAN(target_span, status) \ + ::arrow::internal::tracing::MarkSpan( \ + status, ::arrow::internal::tracing::UnwrapSpan(target_span.details.get()).get()) + +# define END_SPAN(target_span) \ + ::arrow::internal::tracing::UnwrapSpan(target_span.details.get())->End() + +# define END_SPAN_ON_FUTURE_COMPLETION(target_span, target_future) \ + target_future.SetSpan(&target_span) + +# define PROPAGATE_SPAN_TO_GENERATOR(generator) \ + generator = ::arrow::internal::tracing::PropagateSpanThroughAsyncGenerator( \ + std::move(generator)) + +# define WRAP_ASYNC_GENERATOR(generator) \ + generator = ::arrow::internal::tracing::WrapAsyncGenerator(std::move(generator)) + +# define WRAP_ASYNC_GENERATOR_WITH_CHILD_SPAN(generator, name) \ + generator = \ + ::arrow::internal::tracing::WrapAsyncGenerator(std::move(generator), name, true) /* * Calls to the helper macros above are removed by the preprocessor when @@ -223,19 +224,19 @@ struct Scope { [[maybe_unused]] ~Scope() {} }; -#define START_SPAN(target_span, ...) -#define START_SCOPED_SPAN(target_span, ...) ::arrow::internal::tracing::Scope() -#define START_SCOPED_SPAN_SV(target_span, name, ...) ::arrow::internal::tracing::Scope() -#define START_COMPUTE_SPAN(target_span, ...) -#define ACTIVATE_SPAN(target_span) ::arrow::internal::tracing::Scope() -#define MARK_SPAN(target_span, status) -#define EVENT(target_span, ...) -#define EVENT_ON_CURRENT_SPAN(...) -#define END_SPAN(target_span) -#define END_SPAN_ON_FUTURE_COMPLETION(target_span, target_future) -#define PROPAGATE_SPAN_TO_GENERATOR(generator) -#define WRAP_ASYNC_GENERATOR(generator) -#define WRAP_ASYNC_GENERATOR_WITH_CHILD_SPAN(generator, name) +# define START_SPAN(target_span, ...) +# define START_SCOPED_SPAN(target_span, ...) ::arrow::internal::tracing::Scope() +# define START_SCOPED_SPAN_SV(target_span, name, ...) ::arrow::internal::tracing::Scope() +# define START_COMPUTE_SPAN(target_span, ...) +# define ACTIVATE_SPAN(target_span) ::arrow::internal::tracing::Scope() +# define MARK_SPAN(target_span, status) +# define EVENT(target_span, ...) +# define EVENT_ON_CURRENT_SPAN(...) +# define END_SPAN(target_span) +# define END_SPAN_ON_FUTURE_COMPLETION(target_span, target_future) +# define PROPAGATE_SPAN_TO_GENERATOR(generator) +# define WRAP_ASYNC_GENERATOR(generator) +# define WRAP_ASYNC_GENERATOR_WITH_CHILD_SPAN(generator, name) #endif diff --git a/cpp/src/arrow/util/utf8.cc b/cpp/src/arrow/util/utf8.cc index 042a6144d6c19..9f91e0f080868 100644 --- a/cpp/src/arrow/util/utf8.cc +++ b/cpp/src/arrow/util/utf8.cc @@ -30,7 +30,7 @@ // Can be defined by utfcpp #ifdef NOEXCEPT -#undef NOEXCEPT +# undef NOEXCEPT #endif namespace arrow { diff --git a/cpp/src/arrow/util/utf8_internal.h b/cpp/src/arrow/util/utf8_internal.h index ec8fc2b46fe82..335e875f7ae20 100644 --- a/cpp/src/arrow/util/utf8_internal.h +++ b/cpp/src/arrow/util/utf8_internal.h @@ -25,7 +25,7 @@ #include #if defined(ARROW_HAVE_NEON) || defined(ARROW_HAVE_SSE4_2) -#include +# include #endif #include "arrow/type_fwd.h" diff --git a/cpp/src/arrow/util/visibility.h b/cpp/src/arrow/util/visibility.h index 1498d2085a03d..9a53cdbdeff1b 100644 --- a/cpp/src/arrow/util/visibility.h +++ b/cpp/src/arrow/util/visibility.h @@ -20,67 +20,67 @@ #if defined(_WIN32) || defined(__CYGWIN__) // Windows -#if defined(_MSC_VER) -#pragma warning(disable : 4251) -#else -#pragma GCC diagnostic ignored "-Wattributes" -#endif +# if defined(_MSC_VER) +# pragma warning(disable : 4251) +# else +# pragma GCC diagnostic ignored "-Wattributes" +# endif -#if defined(__cplusplus) && defined(__GNUC__) && !defined(__clang__) +# if defined(__cplusplus) && defined(__GNUC__) && !defined(__clang__) // Use C++ attribute syntax where possible to avoid GCC parser bug // (https://stackoverflow.com/questions/57993818/gcc-how-to-combine-attribute-dllexport-and-nodiscard-in-a-struct-de) -#define ARROW_DLLEXPORT [[gnu::dllexport]] -#define ARROW_DLLIMPORT [[gnu::dllimport]] -#else -#define ARROW_DLLEXPORT __declspec(dllexport) -#define ARROW_DLLIMPORT __declspec(dllimport) -#endif +# define ARROW_DLLEXPORT [[gnu::dllexport]] +# define ARROW_DLLIMPORT [[gnu::dllimport]] +# else +# define ARROW_DLLEXPORT __declspec(dllexport) +# define ARROW_DLLIMPORT __declspec(dllimport) +# endif // _declspec(dllexport) even when the #included by a non-arrow source -#define ARROW_FORCE_EXPORT ARROW_DLLEXPORT +# define ARROW_FORCE_EXPORT ARROW_DLLEXPORT -#ifdef ARROW_STATIC -#define ARROW_EXPORT -#define ARROW_FRIEND_EXPORT -#define ARROW_TEMPLATE_EXPORT -#elif defined(ARROW_EXPORTING) -#define ARROW_EXPORT ARROW_DLLEXPORT +# ifdef ARROW_STATIC +# define ARROW_EXPORT +# define ARROW_FRIEND_EXPORT +# define ARROW_TEMPLATE_EXPORT +# elif defined(ARROW_EXPORTING) +# define ARROW_EXPORT ARROW_DLLEXPORT // For some reason [[gnu::dllexport]] doesn't work well with friend declarations -#define ARROW_FRIEND_EXPORT __declspec(dllexport) -#define ARROW_TEMPLATE_EXPORT ARROW_DLLEXPORT -#else -#define ARROW_EXPORT ARROW_DLLIMPORT -#define ARROW_FRIEND_EXPORT __declspec(dllimport) -#define ARROW_TEMPLATE_EXPORT ARROW_DLLIMPORT -#endif +# define ARROW_FRIEND_EXPORT __declspec(dllexport) +# define ARROW_TEMPLATE_EXPORT ARROW_DLLEXPORT +# else +# define ARROW_EXPORT ARROW_DLLIMPORT +# define ARROW_FRIEND_EXPORT __declspec(dllimport) +# define ARROW_TEMPLATE_EXPORT ARROW_DLLIMPORT +# endif -#define ARROW_NO_EXPORT +# define ARROW_NO_EXPORT #else // Non-Windows -#if defined(__cplusplus) && (defined(__GNUC__) || defined(__clang__)) -#ifndef ARROW_EXPORT -#define ARROW_EXPORT [[gnu::visibility("default")]] -#endif -#ifndef ARROW_NO_EXPORT -#define ARROW_NO_EXPORT [[gnu::visibility("hidden")]] -#endif -#else +# if defined(__cplusplus) && (defined(__GNUC__) || defined(__clang__)) +# ifndef ARROW_EXPORT +# define ARROW_EXPORT [[gnu::visibility("default")]] +# endif +# ifndef ARROW_NO_EXPORT +# define ARROW_NO_EXPORT [[gnu::visibility("hidden")]] +# endif +# else // Not C++, or not gcc/clang -#ifndef ARROW_EXPORT -#define ARROW_EXPORT -#endif -#ifndef ARROW_NO_EXPORT -#define ARROW_NO_EXPORT -#endif -#endif +# ifndef ARROW_EXPORT +# define ARROW_EXPORT +# endif +# ifndef ARROW_NO_EXPORT +# define ARROW_NO_EXPORT +# endif +# endif -#define ARROW_FRIEND_EXPORT -#define ARROW_TEMPLATE_EXPORT +# define ARROW_FRIEND_EXPORT +# define ARROW_TEMPLATE_EXPORT // [[gnu::visibility("default")]] even when #included by a non-arrow source -#define ARROW_FORCE_EXPORT [[gnu::visibility("default")]] +# define ARROW_FORCE_EXPORT [[gnu::visibility("default")]] #endif // Non-Windows diff --git a/cpp/src/arrow/util/windows_compatibility.h b/cpp/src/arrow/util/windows_compatibility.h index c97b2f3b76a7c..810a91201f335 100644 --- a/cpp/src/arrow/util/windows_compatibility.h +++ b/cpp/src/arrow/util/windows_compatibility.h @@ -18,22 +18,22 @@ #ifdef _WIN32 // Windows defines min and max macros that mess up std::min/max -#ifndef NOMINMAX -#define NOMINMAX -#endif +# ifndef NOMINMAX +# define NOMINMAX +# endif -#define WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN // Set Windows 7 as a conservative minimum for Apache Arrow -#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x601 -#undef _WIN32_WINNT -#endif -#ifndef _WIN32_WINNT -#define _WIN32_WINNT 0x601 -#endif +# if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x601 +# undef _WIN32_WINNT +# endif +# ifndef _WIN32_WINNT +# define _WIN32_WINNT 0x601 +# endif -#include +# include -#include "arrow/util/windows_fixup.h" +# include "arrow/util/windows_fixup.h" #endif // _WIN32 diff --git a/cpp/src/arrow/util/windows_fixup.h b/cpp/src/arrow/util/windows_fixup.h index 2949ac4ab7688..42e74f4a7857f 100644 --- a/cpp/src/arrow/util/windows_fixup.h +++ b/cpp/src/arrow/util/windows_fixup.h @@ -19,32 +19,32 @@ #ifdef _WIN32 -#ifdef max -#undef max -#endif -#ifdef min -#undef min -#endif +# ifdef max +# undef max +# endif +# ifdef min +# undef min +# endif // The Windows API defines macros from *File resolving to either // *FileA or *FileW. Need to undo them. -#ifdef CopyFile -#undef CopyFile -#endif -#ifdef CreateFile -#undef CreateFile -#endif -#ifdef DeleteFile -#undef DeleteFile -#endif +# ifdef CopyFile +# undef CopyFile +# endif +# ifdef CreateFile +# undef CreateFile +# endif +# ifdef DeleteFile +# undef DeleteFile +# endif // Other annoying Windows macro definitions... -#ifdef IN -#undef IN -#endif -#ifdef OUT -#undef OUT -#endif +# ifdef IN +# undef IN +# endif +# ifdef OUT +# undef OUT +# endif // Note that we can't undefine OPTIONAL, because it can be used in other // Windows headers... diff --git a/cpp/src/gandiva/cast_time.cc b/cpp/src/gandiva/cast_time.cc index eeb2ea3fdd88f..f170375298b55 100644 --- a/cpp/src/gandiva/cast_time.cc +++ b/cpp/src/gandiva/cast_time.cc @@ -22,10 +22,10 @@ #include "gandiva/precompiled/time_fields.h" #ifndef GANDIVA_UNIT_TEST -#include "gandiva/exported_funcs.h" -#include "gandiva/gdv_function_stubs.h" +# include "gandiva/exported_funcs.h" +# include "gandiva/gdv_function_stubs.h" -#include "gandiva/engine.h" +# include "gandiva/engine.h" namespace gandiva { diff --git a/cpp/src/gandiva/context_helper.cc b/cpp/src/gandiva/context_helper.cc index 8edd52b1fb070..2a3efc8348b38 100644 --- a/cpp/src/gandiva/context_helper.cc +++ b/cpp/src/gandiva/context_helper.cc @@ -21,9 +21,9 @@ // This file is also used in the pre-compiled unit tests, which do include // llvm/engine/.. #ifndef GANDIVA_UNIT_TEST -#include "gandiva/exported_funcs.h" +# include "gandiva/exported_funcs.h" -#include "gandiva/engine.h" +# include "gandiva/engine.h" namespace gandiva { diff --git a/cpp/src/gandiva/decimal_xlarge.cc b/cpp/src/gandiva/decimal_xlarge.cc index 21212422f3d69..e9fe0dc6b91ed 100644 --- a/cpp/src/gandiva/decimal_xlarge.cc +++ b/cpp/src/gandiva/decimal_xlarge.cc @@ -33,8 +33,8 @@ #include "gandiva/decimal_type_util.h" #ifndef GANDIVA_UNIT_TEST -#include "gandiva/engine.h" -#include "gandiva/exported_funcs.h" +# include "gandiva/engine.h" +# include "gandiva/exported_funcs.h" namespace gandiva { diff --git a/cpp/src/gandiva/engine.cc b/cpp/src/gandiva/engine.cc index bfce72cefc630..065ea5a59837e 100644 --- a/cpp/src/gandiva/engine.cc +++ b/cpp/src/gandiva/engine.cc @@ -18,7 +18,7 @@ // TODO(wesm): LLVM 7 produces pesky C4244 that disable pragmas around the LLVM // includes seem to not fix as with LLVM 6 #if defined(_MSC_VER) -#pragma warning(disable : 4244) +# pragma warning(disable : 4244) #endif #include "gandiva/engine.h" @@ -35,12 +35,12 @@ #include #if defined(_MSC_VER) -#pragma warning(push) -#pragma warning(disable : 4141) -#pragma warning(disable : 4146) -#pragma warning(disable : 4244) -#pragma warning(disable : 4267) -#pragma warning(disable : 4624) +# pragma warning(push) +# pragma warning(disable : 4141) +# pragma warning(disable : 4146) +# pragma warning(disable : 4244) +# pragma warning(disable : 4267) +# pragma warning(disable : 4624) #endif #include @@ -56,32 +56,32 @@ #include #include #if LLVM_VERSION_MAJOR >= 17 -#include +# include #else -#include +# include #endif #include #include #if LLVM_VERSION_MAJOR >= 18 -#include +# include #else -#include +# include #endif #include #include #if LLVM_VERSION_MAJOR >= 14 -#include -#include -#include -#include -#include -#include -#include -#include -#include +# include +# include +# include +# include +# include +# include +# include +# include +# include #else -#include -#include +# include +# include #endif #include #include @@ -91,18 +91,18 @@ #include #include #if LLVM_VERSION_MAJOR <= 17 -#include +# include #endif // JITLink is available in LLVM 9+ // but the `InProcessMemoryManager::Create` API was added since LLVM 14 #if LLVM_VERSION_MAJOR >= 14 && !defined(_WIN32) -#define JIT_LINK_SUPPORTED -#include +# define JIT_LINK_SUPPORTED +# include #endif #if defined(_MSC_VER) -#pragma warning(pop) +# pragma warning(pop) #endif #include "gandiva/configuration.h" diff --git a/cpp/src/gandiva/gandiva_object_cache.h b/cpp/src/gandiva/gandiva_object_cache.h index 62042c7b627ec..cebc8d5cac211 100644 --- a/cpp/src/gandiva/gandiva_object_cache.h +++ b/cpp/src/gandiva/gandiva_object_cache.h @@ -18,12 +18,12 @@ #pragma once #if defined(_MSC_VER) -#pragma warning(push) -#pragma warning(disable : 4244) -#pragma warning(disable : 4141) -#pragma warning(disable : 4146) -#pragma warning(disable : 4267) -#pragma warning(disable : 4624) +# pragma warning(push) +# pragma warning(disable : 4244) +# pragma warning(disable : 4141) +# pragma warning(disable : 4146) +# pragma warning(disable : 4267) +# pragma warning(disable : 4624) #endif #include diff --git a/cpp/src/gandiva/gdv_function_stubs.h b/cpp/src/gandiva/gdv_function_stubs.h index 8e87bc51215e1..4113f261ad766 100644 --- a/cpp/src/gandiva/gdv_function_stubs.h +++ b/cpp/src/gandiva/gdv_function_stubs.h @@ -46,13 +46,13 @@ using gdv_month_interval = int32_t; #ifdef GANDIVA_UNIT_TEST // unit tests may be compiled without O2, so inlining may not happen. -#define GDV_FORCE_INLINE +# define GDV_FORCE_INLINE #else -#ifdef _MSC_VER -#define GDV_FORCE_INLINE __forceinline -#else -#define GDV_FORCE_INLINE inline __attribute__((always_inline)) -#endif +# ifdef _MSC_VER +# define GDV_FORCE_INLINE __forceinline +# else +# define GDV_FORCE_INLINE inline __attribute__((always_inline)) +# endif #endif GANDIVA_EXPORT diff --git a/cpp/src/gandiva/llvm_includes.h b/cpp/src/gandiva/llvm_includes.h index 3d455591895c7..659c9d29de177 100644 --- a/cpp/src/gandiva/llvm_includes.h +++ b/cpp/src/gandiva/llvm_includes.h @@ -18,13 +18,13 @@ #pragma once #if defined(_MSC_VER) -#pragma warning(push) -#pragma warning(disable : 4141) -#pragma warning(disable : 4146) -#pragma warning(disable : 4244) -#pragma warning(disable : 4267) -#pragma warning(disable : 4291) -#pragma warning(disable : 4624) +# pragma warning(push) +# pragma warning(disable : 4141) +# pragma warning(disable : 4146) +# pragma warning(disable : 4244) +# pragma warning(disable : 4267) +# pragma warning(disable : 4291) +# pragma warning(disable : 4624) #endif #include @@ -33,11 +33,11 @@ #include #if LLVM_VERSION_MAJOR >= 10 -#define LLVM_ALIGN(alignment) (llvm::Align((alignment))) +# define LLVM_ALIGN(alignment) (llvm::Align((alignment))) #else -#define LLVM_ALIGN(alignment) (alignment) +# define LLVM_ALIGN(alignment) (alignment) #endif #if defined(_MSC_VER) -#pragma warning(pop) +# pragma warning(pop) #endif diff --git a/cpp/src/gandiva/precompiled/extended_math_ops.cc b/cpp/src/gandiva/precompiled/extended_math_ops.cc index e5bd9b48e0e0b..c03db1d5f2b13 100644 --- a/cpp/src/gandiva/precompiled/extended_math_ops.cc +++ b/cpp/src/gandiva/precompiled/extended_math_ops.cc @@ -16,7 +16,7 @@ // under the License. #ifndef M_PI -#define M_PI 3.14159265358979323846 +# define M_PI 3.14159265358979323846 #endif #include "arrow/util/logging.h" diff --git a/cpp/src/gandiva/precompiled/extended_math_ops_test.cc b/cpp/src/gandiva/precompiled/extended_math_ops_test.cc index 3e9d8a5d2cd44..7170fad01d250 100644 --- a/cpp/src/gandiva/precompiled/extended_math_ops_test.cc +++ b/cpp/src/gandiva/precompiled/extended_math_ops_test.cc @@ -16,7 +16,7 @@ // under the License. #ifndef M_PI -#define M_PI 3.14159265358979323846 +# define M_PI 3.14159265358979323846 #endif #include diff --git a/cpp/src/gandiva/precompiled/types.h b/cpp/src/gandiva/precompiled/types.h index 83bbdee208562..c93b694fc777e 100644 --- a/cpp/src/gandiva/precompiled/types.h +++ b/cpp/src/gandiva/precompiled/types.h @@ -43,9 +43,9 @@ using gdv_day_time_interval = int64_t; #ifdef GANDIVA_UNIT_TEST // unit tests may be compiled without O2, so inlining may not happen. -#define FORCE_INLINE +# define FORCE_INLINE #else -#define FORCE_INLINE __attribute__((always_inline)) +# define FORCE_INLINE __attribute__((always_inline)) #endif extern "C" { diff --git a/cpp/src/gandiva/selection_vector.cc b/cpp/src/gandiva/selection_vector.cc index 39e9f5bc90228..8d5f9f4210af5 100644 --- a/cpp/src/gandiva/selection_vector.cc +++ b/cpp/src/gandiva/selection_vector.cc @@ -54,14 +54,14 @@ Status SelectionVector::PopulateFromBitMap(const uint8_t* bitmap, int64_t bitmap while (current_word != 0) { #if defined(_MSC_VER) -#pragma warning(push) -#pragma warning(disable : 4146) +# pragma warning(push) +# pragma warning(disable : 4146) #endif // MSVC warns about negating an unsigned type. We suppress it for now uint64_t highest_only = current_word & -current_word; #if defined(_MSC_VER) -#pragma warning(pop) +# pragma warning(pop) #endif int pos_in_word = arrow::bit_util::CountTrailingZeros(highest_only); diff --git a/cpp/src/gandiva/tests/projector_test.cc b/cpp/src/gandiva/tests/projector_test.cc index 59eeb3d92f19a..a22d04ac28f47 100644 --- a/cpp/src/gandiva/tests/projector_test.cc +++ b/cpp/src/gandiva/tests/projector_test.cc @@ -16,7 +16,7 @@ // under the License. #ifndef M_PI -#define M_PI 3.14159265358979323846 +# define M_PI 3.14159265358979323846 #endif #include "gandiva/projector.h" diff --git a/cpp/src/gandiva/tests/test_util.cc b/cpp/src/gandiva/tests/test_util.cc index 2ee49ffae0ed6..584e27e7533b6 100644 --- a/cpp/src/gandiva/tests/test_util.cc +++ b/cpp/src/gandiva/tests/test_util.cc @@ -35,7 +35,7 @@ std::shared_ptr TestConfigWithIrDumping() { } #ifndef GANDIVA_EXTENSION_TEST_DIR -#define GANDIVA_EXTENSION_TEST_DIR "." +# define GANDIVA_EXTENSION_TEST_DIR "." #endif std::string GetTestFunctionLLVMIRPath() { diff --git a/cpp/src/gandiva/visibility.h b/cpp/src/gandiva/visibility.h index 450b3056b2ec0..4961952c2974e 100644 --- a/cpp/src/gandiva/visibility.h +++ b/cpp/src/gandiva/visibility.h @@ -18,31 +18,31 @@ #pragma once #if defined(_WIN32) || defined(__CYGWIN__) -#if defined(_MSC_VER) -#pragma warning(push) -#pragma warning(disable : 4251) -#else -#pragma GCC diagnostic ignored "-Wattributes" -#endif +# if defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable : 4251) +# else +# pragma GCC diagnostic ignored "-Wattributes" +# endif -#ifdef GANDIVA_STATIC -#define GANDIVA_EXPORT -#elif defined(GANDIVA_EXPORTING) -#define GANDIVA_EXPORT __declspec(dllexport) -#else -#define GANDIVA_EXPORT __declspec(dllimport) -#endif +# ifdef GANDIVA_STATIC +# define GANDIVA_EXPORT +# elif defined(GANDIVA_EXPORTING) +# define GANDIVA_EXPORT __declspec(dllexport) +# else +# define GANDIVA_EXPORT __declspec(dllimport) +# endif -#define GANDIVA_NO_EXPORT +# define GANDIVA_NO_EXPORT #else // Not Windows -#ifndef GANDIVA_EXPORT -#define GANDIVA_EXPORT __attribute__((visibility("default"))) -#endif -#ifndef GANDIVA_NO_EXPORT -#define GANDIVA_NO_EXPORT __attribute__((visibility("hidden"))) -#endif +# ifndef GANDIVA_EXPORT +# define GANDIVA_EXPORT __attribute__((visibility("default"))) +# endif +# ifndef GANDIVA_NO_EXPORT +# define GANDIVA_NO_EXPORT __attribute__((visibility("hidden"))) +# endif #endif // Non-Windows #if defined(_MSC_VER) -#pragma warning(pop) +# pragma warning(pop) #endif diff --git a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc index 64030e0f90d54..724e6c44f2ed0 100644 --- a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc +++ b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc @@ -16,9 +16,9 @@ // under the License. #ifdef _MSC_VER -#pragma warning(push) +# pragma warning(push) // Disable forcing value to bool warnings -#pragma warning(disable : 4800) +# pragma warning(disable : 4800) #endif #include "gmock/gmock.h" @@ -55,7 +55,7 @@ #include "arrow/util/range.h" #ifdef ARROW_CSV -#include "arrow/csv/api.h" +# include "arrow/csv/api.h" #endif #include "parquet/api/reader.h" diff --git a/cpp/src/parquet/exception.h b/cpp/src/parquet/exception.h index 826f5bdc8bf73..cd221ec7a24ae 100644 --- a/cpp/src/parquet/exception.h +++ b/cpp/src/parquet/exception.h @@ -28,7 +28,7 @@ // PARQUET-1085 #if !defined(ARROW_UNUSED) -#define ARROW_UNUSED(x) UNUSED(x) +# define ARROW_UNUSED(x) UNUSED(x) #endif // Parquet exception to Arrow Status diff --git a/cpp/src/parquet/level_comparison_inc.h b/cpp/src/parquet/level_comparison_inc.h index cfee506654331..04f628d533111 100644 --- a/cpp/src/parquet/level_comparison_inc.h +++ b/cpp/src/parquet/level_comparison_inc.h @@ -22,7 +22,7 @@ // Used to make sure ODR rule isn't violated. #ifndef PARQUET_IMPL_NAMESPACE -#error "PARQUET_IMPL_NAMESPACE must be defined" +# error "PARQUET_IMPL_NAMESPACE must be defined" #endif namespace parquet::internal::PARQUET_IMPL_NAMESPACE { /// Builds a bitmap by applying predicate to the level vector provided. diff --git a/cpp/src/parquet/level_conversion_inc.h b/cpp/src/parquet/level_conversion_inc.h index 3accb154e6f5a..5fce93e779b2d 100644 --- a/cpp/src/parquet/level_conversion_inc.h +++ b/cpp/src/parquet/level_conversion_inc.h @@ -31,7 +31,7 @@ #include "parquet/level_comparison.h" #ifndef PARQUET_IMPL_NAMESPACE -#error "PARQUET_IMPL_NAMESPACE must be defined" +# error "PARQUET_IMPL_NAMESPACE must be defined" #endif namespace parquet::internal::PARQUET_IMPL_NAMESPACE { @@ -261,7 +261,7 @@ inline uint64_t ExtractBitsSoftware(uint64_t bitmap, uint64_t select_bitmap) { #ifdef ARROW_HAVE_BMI2 // Use _pext_u64 on 64-bit builds, _pext_u32 on 32-bit builds, -#if UINTPTR_MAX == 0xFFFFFFFF +# if UINTPTR_MAX == 0xFFFFFFFF using extract_bitmap_t = uint32_t; inline extract_bitmap_t ExtractBits(extract_bitmap_t bitmap, @@ -269,7 +269,7 @@ inline extract_bitmap_t ExtractBits(extract_bitmap_t bitmap, return _pext_u32(bitmap, select_bitmap); } -#else +# else using extract_bitmap_t = uint64_t; inline extract_bitmap_t ExtractBits(extract_bitmap_t bitmap, @@ -277,7 +277,7 @@ inline extract_bitmap_t ExtractBits(extract_bitmap_t bitmap, return _pext_u64(bitmap, select_bitmap); } -#endif +# endif #else // !defined(ARROW_HAVE_BMI2) diff --git a/cpp/src/parquet/platform.h b/cpp/src/parquet/platform.h index b085e57cd9918..e8d67e225f8ff 100644 --- a/cpp/src/parquet/platform.h +++ b/cpp/src/parquet/platform.h @@ -28,48 +28,48 @@ #if defined(_WIN32) || defined(__CYGWIN__) -#if defined(_MSC_VER) -#pragma warning(push) +# if defined(_MSC_VER) +# pragma warning(push) // Disable warning for STL types usage in DLL interface // https://web.archive.org/web/20130317015847/http://connect.microsoft.com/VisualStudio/feedback/details/696593/vc-10-vs-2010-basic-string-exports -#pragma warning(disable : 4275 4251) +# pragma warning(disable : 4275 4251) // Disable diamond inheritance warnings -#pragma warning(disable : 4250) +# pragma warning(disable : 4250) // Disable macro redefinition warnings -#pragma warning(disable : 4005) +# pragma warning(disable : 4005) // Disable extern before exported template warnings -#pragma warning(disable : 4910) -#else -#pragma GCC diagnostic ignored "-Wattributes" -#endif +# pragma warning(disable : 4910) +# else +# pragma GCC diagnostic ignored "-Wattributes" +# endif -#ifdef PARQUET_STATIC -#define PARQUET_EXPORT -#elif defined(PARQUET_EXPORTING) -#define PARQUET_EXPORT __declspec(dllexport) -#else -#define PARQUET_EXPORT __declspec(dllimport) -#endif +# ifdef PARQUET_STATIC +# define PARQUET_EXPORT +# elif defined(PARQUET_EXPORTING) +# define PARQUET_EXPORT __declspec(dllexport) +# else +# define PARQUET_EXPORT __declspec(dllimport) +# endif -#define PARQUET_NO_EXPORT +# define PARQUET_NO_EXPORT #else // Not Windows -#ifndef PARQUET_EXPORT -#define PARQUET_EXPORT __attribute__((visibility("default"))) -#endif -#ifndef PARQUET_NO_EXPORT -#define PARQUET_NO_EXPORT __attribute__((visibility("hidden"))) -#endif +# ifndef PARQUET_EXPORT +# define PARQUET_EXPORT __attribute__((visibility("default"))) +# endif +# ifndef PARQUET_NO_EXPORT +# define PARQUET_NO_EXPORT __attribute__((visibility("hidden"))) +# endif #endif // Non-Windows // This is a complicated topic, some reading on it: // http://www.codesynthesis.com/~boris/blog/2010/01/18/dll-export-cxx-templates/ #if defined(_MSC_VER) || defined(__clang__) -#define PARQUET_TEMPLATE_CLASS_EXPORT -#define PARQUET_TEMPLATE_EXPORT PARQUET_EXPORT +# define PARQUET_TEMPLATE_CLASS_EXPORT +# define PARQUET_TEMPLATE_EXPORT PARQUET_EXPORT #else -#define PARQUET_TEMPLATE_CLASS_EXPORT PARQUET_EXPORT -#define PARQUET_TEMPLATE_EXPORT +# define PARQUET_TEMPLATE_CLASS_EXPORT PARQUET_EXPORT +# define PARQUET_TEMPLATE_EXPORT #endif #define PARQUET_DISALLOW_COPY_AND_ASSIGN ARROW_DISALLOW_COPY_AND_ASSIGN @@ -80,7 +80,7 @@ // If ARROW_VALGRIND set when compiling unit tests, also define // PARQUET_VALGRIND #ifdef ARROW_VALGRIND -#define PARQUET_VALGRIND +# define PARQUET_VALGRIND #endif namespace parquet { diff --git a/cpp/src/parquet/types_test.cc b/cpp/src/parquet/types_test.cc index e0ca7d6356646..fdcaed5c81ed7 100644 --- a/cpp/src/parquet/types_test.cc +++ b/cpp/src/parquet/types_test.cc @@ -65,11 +65,11 @@ TEST(TestConvertedTypeToString, ConvertedTypes) { } #ifdef __GNUC__ -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wdeprecated-declarations" #elif defined(_MSC_VER) -#pragma warning(push) -#pragma warning(disable : 4996) +# pragma warning(push) +# pragma warning(disable : 4996) #endif TEST(TypePrinter, StatisticsTypes) { @@ -164,9 +164,9 @@ TEST(TestInt96Timestamp, Decoding) { } #if !(defined(_WIN32) || defined(__CYGWIN__)) -#pragma GCC diagnostic pop +# pragma GCC diagnostic pop #elif _MSC_VER -#pragma warning(pop) +# pragma warning(pop) #endif } // namespace parquet diff --git a/cpp/src/parquet/windows_fixup.h b/cpp/src/parquet/windows_fixup.h index ce44480c5732e..feac4e64d1976 100644 --- a/cpp/src/parquet/windows_fixup.h +++ b/cpp/src/parquet/windows_fixup.h @@ -22,8 +22,8 @@ #ifdef _WIN32 // parquet.thrift's OPTIONAL RepetitionType conflicts with a Windows #define -#ifdef OPTIONAL -#undef OPTIONAL -#endif +# ifdef OPTIONAL +# undef OPTIONAL +# endif #endif // _WIN32 diff --git a/matlab/src/cpp/arrow/matlab/api/visibility.h b/matlab/src/cpp/arrow/matlab/api/visibility.h index 1570de06c4e17..9c5cc28565113 100644 --- a/matlab/src/cpp/arrow/matlab/api/visibility.h +++ b/matlab/src/cpp/arrow/matlab/api/visibility.h @@ -18,11 +18,11 @@ #pragma once #if defined(_WIN32) || defined(__CYGWIN__) -#ifdef ARROW_MATLAB_EXPORTING -#define ARROW_MATLAB_EXPORT __declspec(dllexport) -#else -#define ARROW_MATLAB_EXPORT __declspec(dllimport) -#endif +# ifdef ARROW_MATLAB_EXPORTING +# define ARROW_MATLAB_EXPORT __declspec(dllexport) +# else +# define ARROW_MATLAB_EXPORT __declspec(dllimport) +# endif #else // Not Windows -#define ARROW_MATLAB_EXPORT __attribute__((visibility("default"))) +# define ARROW_MATLAB_EXPORT __attribute__((visibility("default"))) #endif diff --git a/python/pyarrow/src/arrow/python/datetime.h b/python/pyarrow/src/arrow/python/datetime.h index 7346d6bc67791..9b21eeb434217 100644 --- a/python/pyarrow/src/arrow/python/datetime.h +++ b/python/pyarrow/src/arrow/python/datetime.h @@ -35,9 +35,9 @@ // Instead, we redefine PyDateTimeAPI to point to a global variable, // which is initialized once by calling InitDatetime(). #ifdef PYPY_VERSION -#include "datetime.h" +# include "datetime.h" #else -#define PyDateTimeAPI ::arrow::py::internal::datetime_api +# define PyDateTimeAPI ::arrow::py::internal::datetime_api #endif namespace arrow { diff --git a/python/pyarrow/src/arrow/python/flight.h b/python/pyarrow/src/arrow/python/flight.h index 82d93711e55fb..5243258495778 100644 --- a/python/pyarrow/src/arrow/python/flight.h +++ b/python/pyarrow/src/arrow/python/flight.h @@ -26,24 +26,24 @@ #include "arrow/python/common.h" #if defined(_WIN32) || defined(__CYGWIN__) // Windows -#if defined(_MSC_VER) -#pragma warning(disable : 4251) -#else -#pragma GCC diagnostic ignored "-Wattributes" -#endif - -#ifdef ARROW_PYTHON_STATIC -#define ARROW_PYFLIGHT_EXPORT -#elif defined(ARROW_PYFLIGHT_EXPORTING) -#define ARROW_PYFLIGHT_EXPORT __declspec(dllexport) -#else -#define ARROW_PYFLIGHT_EXPORT __declspec(dllimport) -#endif +# if defined(_MSC_VER) +# pragma warning(disable : 4251) +# else +# pragma GCC diagnostic ignored "-Wattributes" +# endif + +# ifdef ARROW_PYTHON_STATIC +# define ARROW_PYFLIGHT_EXPORT +# elif defined(ARROW_PYFLIGHT_EXPORTING) +# define ARROW_PYFLIGHT_EXPORT __declspec(dllexport) +# else +# define ARROW_PYFLIGHT_EXPORT __declspec(dllimport) +# endif #else // Not Windows -#ifndef ARROW_PYFLIGHT_EXPORT -#define ARROW_PYFLIGHT_EXPORT __attribute__((visibility("default"))) -#endif +# ifndef ARROW_PYFLIGHT_EXPORT +# define ARROW_PYFLIGHT_EXPORT __attribute__((visibility("default"))) +# endif #endif // Non-Windows namespace arrow { diff --git a/python/pyarrow/src/arrow/python/numpy_interop.h b/python/pyarrow/src/arrow/python/numpy_interop.h index 7ea7d6e16f528..a83ae4a62b944 100644 --- a/python/pyarrow/src/arrow/python/numpy_interop.h +++ b/python/pyarrow/src/arrow/python/numpy_interop.h @@ -23,19 +23,19 @@ // Don't use the deprecated Numpy functions #ifdef NPY_1_7_API_VERSION -#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION +# define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION #else -#define NPY_ARRAY_NOTSWAPPED NPY_NOTSWAPPED -#define NPY_ARRAY_ALIGNED NPY_ALIGNED -#define NPY_ARRAY_WRITEABLE NPY_WRITEABLE -#define NPY_ARRAY_UPDATEIFCOPY NPY_UPDATEIFCOPY +# define NPY_ARRAY_NOTSWAPPED NPY_NOTSWAPPED +# define NPY_ARRAY_ALIGNED NPY_ALIGNED +# define NPY_ARRAY_WRITEABLE NPY_WRITEABLE +# define NPY_ARRAY_UPDATEIFCOPY NPY_UPDATEIFCOPY #endif // This is required to be able to access the NumPy C API properly in C++ files // other than init.cc. #define PY_ARRAY_UNIQUE_SYMBOL arrow_ARRAY_API #ifndef NUMPY_IMPORT_ARRAY -#define NO_IMPORT_ARRAY +# define NO_IMPORT_ARRAY #endif #include // IWYU pragma: export @@ -56,22 +56,22 @@ // NPY_INT needs to be handled separately. #if NPY_BITSOF_LONG == 32 && NPY_BITSOF_LONGLONG == 64 -#define NPY_INT64_IS_LONG_LONG 1 +# define NPY_INT64_IS_LONG_LONG 1 #else -#define NPY_INT64_IS_LONG_LONG 0 +# define NPY_INT64_IS_LONG_LONG 0 #endif #if NPY_BITSOF_INT == 32 && NPY_BITSOF_LONG == 64 -#define NPY_INT32_IS_INT 1 +# define NPY_INT32_IS_INT 1 #else -#define NPY_INT32_IS_INT 0 +# define NPY_INT32_IS_INT 0 #endif // Backported NumPy 2 API (can be removed if numpy 2 is required) #if NPY_ABI_VERSION < 0x02000000 -#define PyDataType_ELSIZE(descr) ((descr)->elsize) -#define PyDataType_C_METADATA(descr) ((descr)->c_metadata) -#define PyDataType_FIELDS(descr) ((descr)->fields) +# define PyDataType_ELSIZE(descr) ((descr)->elsize) +# define PyDataType_C_METADATA(descr) ((descr)->c_metadata) +# define PyDataType_FIELDS(descr) ((descr)->fields) #endif namespace arrow { diff --git a/python/pyarrow/src/arrow/python/parquet_encryption.h b/python/pyarrow/src/arrow/python/parquet_encryption.h index a1aaa30e260f5..7a107c89f0bdc 100644 --- a/python/pyarrow/src/arrow/python/parquet_encryption.h +++ b/python/pyarrow/src/arrow/python/parquet_encryption.h @@ -27,24 +27,24 @@ #include "parquet/encryption/kms_client_factory.h" #if defined(_WIN32) || defined(__CYGWIN__) // Windows -#if defined(_MSC_VER) -#pragma warning(disable : 4251) -#else -#pragma GCC diagnostic ignored "-Wattributes" -#endif - -#ifdef ARROW_PYTHON_STATIC -#define ARROW_PYTHON_PARQUET_ENCRYPTION_EXPORT -#elif defined(ARROW_PYTHON_PARQUET_ENCRYPTION_EXPORTING) -#define ARROW_PYTHON_PARQUET_ENCRYPTION_EXPORT __declspec(dllexport) -#else -#define ARROW_PYTHON_PARQUET_ENCRYPTION_EXPORT __declspec(dllimport) -#endif +# if defined(_MSC_VER) +# pragma warning(disable : 4251) +# else +# pragma GCC diagnostic ignored "-Wattributes" +# endif + +# ifdef ARROW_PYTHON_STATIC +# define ARROW_PYTHON_PARQUET_ENCRYPTION_EXPORT +# elif defined(ARROW_PYTHON_PARQUET_ENCRYPTION_EXPORTING) +# define ARROW_PYTHON_PARQUET_ENCRYPTION_EXPORT __declspec(dllexport) +# else +# define ARROW_PYTHON_PARQUET_ENCRYPTION_EXPORT __declspec(dllimport) +# endif #else // Not Windows -#ifndef ARROW_PYTHON_PARQUET_ENCRYPTION_EXPORT -#define ARROW_PYTHON_PARQUET_ENCRYPTION_EXPORT __attribute__((visibility("default"))) -#endif +# ifndef ARROW_PYTHON_PARQUET_ENCRYPTION_EXPORT +# define ARROW_PYTHON_PARQUET_ENCRYPTION_EXPORT __attribute__((visibility("default"))) +# endif #endif // Non-Windows namespace arrow { diff --git a/python/pyarrow/src/arrow/python/platform.h b/python/pyarrow/src/arrow/python/platform.h index e71c7ac85399e..48758cd1c8468 100644 --- a/python/pyarrow/src/arrow/python/platform.h +++ b/python/pyarrow/src/arrow/python/platform.h @@ -29,13 +29,13 @@ // Work around C2528 error #ifdef _MSC_VER -#if _MSC_VER >= 1900 -#undef timezone -#endif +# if _MSC_VER >= 1900 +# undef timezone +# endif // https://bugs.python.org/issue36020 // TODO(wjones127): Can remove once we drop support for CPython 3.9 -#ifdef snprintf -#undef snprintf -#endif +# ifdef snprintf +# undef snprintf +# endif #endif diff --git a/python/pyarrow/src/arrow/python/visibility.h b/python/pyarrow/src/arrow/python/visibility.h index dd43b32fd43ff..4bf9680a06bf0 100644 --- a/python/pyarrow/src/arrow/python/visibility.h +++ b/python/pyarrow/src/arrow/python/visibility.h @@ -18,22 +18,22 @@ #pragma once #if defined(_WIN32) || defined(__CYGWIN__) // Windows -#if defined(_MSC_VER) -#pragma warning(disable : 4251) -#else -#pragma GCC diagnostic ignored "-Wattributes" -#endif +# if defined(_MSC_VER) +# pragma warning(disable : 4251) +# else +# pragma GCC diagnostic ignored "-Wattributes" +# endif -#ifdef ARROW_PYTHON_STATIC -#define ARROW_PYTHON_EXPORT -#elif defined(ARROW_PYTHON_EXPORTING) -#define ARROW_PYTHON_EXPORT __declspec(dllexport) -#else -#define ARROW_PYTHON_EXPORT __declspec(dllimport) -#endif +# ifdef ARROW_PYTHON_STATIC +# define ARROW_PYTHON_EXPORT +# elif defined(ARROW_PYTHON_EXPORTING) +# define ARROW_PYTHON_EXPORT __declspec(dllexport) +# else +# define ARROW_PYTHON_EXPORT __declspec(dllimport) +# endif #else // Not Windows -#ifndef ARROW_PYTHON_EXPORT -#define ARROW_PYTHON_EXPORT __attribute__((visibility("default"))) -#endif +# ifndef ARROW_PYTHON_EXPORT +# define ARROW_PYTHON_EXPORT __attribute__((visibility("default"))) +# endif #endif // Non-Windows