diff --git a/src/check/dt_xspan.cpp b/src/check/dt_xspan.cpp index 63ce4dcc..922d43d0 100644 --- a/src/check/dt_xspan.cpp +++ b/src/check/dt_xspan.cpp @@ -35,22 +35,22 @@ TEST_CASE("basic xspan usage") { char buf[4] = {0, 1, 2, 3}; - SUBCASE("SPAN_x") { - SPAN_0(char) a0 = nullptr; + SUBCASE("XSPAN_x") { + XSPAN_0(char) a0 = nullptr; - SPAN_0(char) b0 = buf; - SPAN_P(char) bp = buf; + XSPAN_0(char) b0 = buf; + XSPAN_P(char) bp = buf; - SPAN_0(char) c0 = SPAN_0_MAKE(char, buf); - SPAN_P(char) cp = SPAN_P_MAKE(char, buf); - SPAN_S(char) cs = SPAN_S_MAKE(char, buf, sizeof(buf)); + XSPAN_0(char) c0 = XSPAN_0_MAKE(char, buf); + XSPAN_P(char) cp = XSPAN_P_MAKE(char, buf); + XSPAN_S(char) cs = XSPAN_S_MAKE(char, buf, sizeof(buf)); - SPAN_0(const char) const x0 = SPAN_0_MAKE(const char, buf); - SPAN_P(const char) const xp = SPAN_P_MAKE(const char, buf); - SPAN_S(const char) const xs = SPAN_S_MAKE(const char, buf, sizeof(buf)); - SPAN_P(const char) const yp = xs; - SPAN_0(const char) const z0p = yp; - SPAN_0(const char) const z0s = xs; + XSPAN_0(const char) const x0 = XSPAN_0_MAKE(const char, buf); + XSPAN_P(const char) const xp = XSPAN_P_MAKE(const char, buf); + XSPAN_S(const char) const xs = XSPAN_S_MAKE(const char, buf, sizeof(buf)); + XSPAN_P(const char) const yp = xs; + XSPAN_0(const char) const z0p = yp; + XSPAN_0(const char) const z0s = xs; CHECK((a0 == nullptr)); CHECK(c0 == b0); @@ -69,26 +69,26 @@ TEST_CASE("basic xspan usage") { CHECK_THROWS(raw_index_bytes(cs, 1, 4)); } - SUBCASE("SPAN_x_VAR") { - SPAN_0_VAR(char, a0, nullptr); + SUBCASE("XSPAN_x_VAR") { + XSPAN_0_VAR(char, a0, nullptr); - SPAN_0_VAR(char, b0, buf); - SPAN_P_VAR(char, bp, buf); + XSPAN_0_VAR(char, b0, buf); + XSPAN_P_VAR(char, bp, buf); - SPAN_0_VAR(char, c0, buf, sizeof(buf)); - SPAN_P_VAR(char, cp, buf, sizeof(buf)); - SPAN_S_VAR(char, cs, buf, sizeof(buf)); + XSPAN_0_VAR(char, c0, buf, sizeof(buf)); + XSPAN_P_VAR(char, cp, buf, sizeof(buf)); + XSPAN_S_VAR(char, cs, buf, sizeof(buf)); - SPAN_0_VAR(char, d0, buf + 1, sizeof(buf), buf); - SPAN_P_VAR(char, dp, buf + 1, sizeof(buf), buf); - SPAN_S_VAR(char, ds, buf + 1, sizeof(buf), buf); + XSPAN_0_VAR(char, d0, buf + 1, sizeof(buf), buf); + XSPAN_P_VAR(char, dp, buf + 1, sizeof(buf), buf); + XSPAN_S_VAR(char, ds, buf + 1, sizeof(buf), buf); - SPAN_0_VAR(const char, const x0, buf, sizeof(buf)); - SPAN_P_VAR(const char, const xp, buf, sizeof(buf)); - SPAN_S_VAR(const char, const xs, buf, sizeof(buf)); - SPAN_P_VAR(const char, const yp, xs); - SPAN_0_VAR(const char, const z0p, yp); - SPAN_0_VAR(const char, const z0s, xs); + XSPAN_0_VAR(const char, const x0, buf, sizeof(buf)); + XSPAN_P_VAR(const char, const xp, buf, sizeof(buf)); + XSPAN_S_VAR(const char, const xs, buf, sizeof(buf)); + XSPAN_P_VAR(const char, const yp, xs); + XSPAN_0_VAR(const char, const z0p, yp); + XSPAN_0_VAR(const char, const z0s, xs); CHECK((a0 == nullptr)); CHECK(c0 == b0); @@ -111,19 +111,19 @@ TEST_CASE("basic xspan usage") { SUBCASE("xspan in class") { struct MyType { - SPAN_0(char) s0; - SPAN_P(char) sp; - SPAN_S(char) ss; + XSPAN_0(char) s0; + XSPAN_P(char) sp; + XSPAN_S(char) ss; #if __cplusplus >= 201103L - SPAN_0(char) x0 = nullptr; + XSPAN_0(char) x0 = nullptr; #endif -#if WITH_SPAN >= 2 +#if WITH_XSPAN >= 2 // much nicer syntax when using fully checked xspan: MyType(char *b, size_t n, bool) : s0(b, n), sp(b, n), ss(b, n) {} #endif MyType(char *b, size_t n) - : s0(SPAN_0_MAKE(char, b, n)), sp(SPAN_P_MAKE(char, b, n)), - ss(SPAN_S_MAKE(char, b, n)) { + : s0(XSPAN_0_MAKE(char, b, n)), sp(XSPAN_P_MAKE(char, b, n)), + ss(XSPAN_S_MAKE(char, b, n)) { UNUSED(n); } }; @@ -137,7 +137,7 @@ TEST_CASE("basic xspan usage") { // **************************************************************************/ -#if (WITH_SPAN >= 2) && DEBUG +#if (WITH_XSPAN >= 2) && DEBUG TEST_CASE("PtrOrSpanOrNull") { char real_buf[2 + 6 + 2] = {126, 127, 0, 1, 2, 3, 4, 5, 124, 125}; @@ -334,7 +334,7 @@ TEST_CASE("PtrOrSpan") { assert(sp_with_base.raw_base() == base_buf); CHECK_THROWS(sp_no_base = my_null); // nullptr assignment CHECK_THROWS(sp_with_base = my_null); // nullptr assignment -#if SPAN_CONFIG_ENABLE_SPAN_CONVERSION +#if XSPAN_CONFIG_ENABLE_SPAN_CONVERSION typedef PtrOrSpanOrNull Span0; Span0 s0_no_base(nullptr); Span0 s0_with_base(nullptr, 4, base_buf); @@ -435,7 +435,7 @@ TEST_CASE("Span") { SpanS ss_with_base(base_buf, 4, base_buf); assert(ss_with_base.raw_base() == base_buf); CHECK_THROWS(ss_with_base = my_null); // nullptr assignment -#if SPAN_CONFIG_ENABLE_SPAN_CONVERSION +#if XSPAN_CONFIG_ENABLE_SPAN_CONVERSION { typedef PtrOrSpanOrNull Span0; // v0 nullptr, b0 base, b1 base + 1 @@ -629,7 +629,7 @@ TEST_CASE("PtrOrSpan") { TEST_CASE("PtrOrSpan char") { char real_buf[2 + 8 + 2] = {126, 127, 0, 1, 2, 3, 4, 5, 6, 7, 124, 125}; char *buf = real_buf + 2; - SPAN_P(char) a(buf, SpanSizeInBytes(8)); + SPAN_P(char) a(buf, XSpanSizeInBytes(8)); SPAN_P(char) b = a.subspan(0, 7); SPAN_P(char) c = (b + 1).subspan(0, 6); a += 1; @@ -682,7 +682,7 @@ TEST_CASE("PtrOrSpan char") { TEST_CASE("PtrOrSpan int") { int buf[8] = {0, 1, 2, 3, 4, 5, 6, 7}; - SPAN_P(int) a(buf, SpanCount(8)); + SPAN_P(int) a(buf, XSpanCount(8)); CHECK(a.raw_size_in_bytes() == 8 * sizeof(int)); SPAN_P(int) b = a.subspan(0, 7); CHECK(b.raw_size_in_bytes() == 7 * sizeof(int)); @@ -723,17 +723,17 @@ __acc_static_noinline int foo(T p) { } template -SPAN_0(T) +XSPAN_0(T) make_span_0(T *ptr, size_t count) { return PtrOrSpanOrNull(ptr, count); } template -SPAN_P(T) +XSPAN_P(T) make_span_p(T *ptr, size_t count) { return PtrOrSpan(ptr, count); } template -SPAN_S(T) +XSPAN_S(T) make_span_s(T *ptr, size_t count) { return Span(ptr, count); } @@ -747,6 +747,6 @@ TEST_CASE("Span codegen") { CHECK(foo(make_span_s(buf, 8)) == 0 + 2 + 5); } -#endif // WITH_SPAN >= 2 +#endif // WITH_XSPAN >= 2 /* vim:set ts=4 sw=4 et: */ diff --git a/src/pefile.cpp b/src/pefile.cpp index f55dae05..ad3890cb 100644 --- a/src/pefile.cpp +++ b/src/pefile.cpp @@ -39,7 +39,7 @@ // **************************************************************************/ -#if (WITH_SPAN >= 2) && 1 +#if (WITH_XSPAN >= 2) && 1 //#define IPTR(type, var) Span var(ibuf, ibuf.getSize(), ibuf) //#define OPTR(type, var) Span var(obuf, obuf.getSize(), obuf) #define IPTR_I_D(type, var, disp) Span var(ibuf + (disp), ibuf.getSize() - (disp), ibuf + (disp)) diff --git a/src/util/bptr.h b/src/util/bptr.h index 546d8f99..1d17626b 100644 --- a/src/util/bptr.h +++ b/src/util/bptr.h @@ -29,7 +29,7 @@ #ifndef UPX_BPTR_H__ #define UPX_BPTR_H__ 1 -#if WITH_SPAN >= 2 +#if WITH_XSPAN >= 2 #error "this file is deprecated, please use xspan.h instead" #endif diff --git a/src/util/membuffer.h b/src/util/membuffer.h index 2465ec68..68fbcaf4 100644 --- a/src/util/membuffer.h +++ b/src/util/membuffer.h @@ -45,7 +45,7 @@ protected: public: // NOTE: implicit conversion to underlying pointer - // NOTE: for fully bound-checked pointer use SPAN_S from xspan.h + // NOTE: for fully bound-checked pointer use XSPAN_S from xspan.h operator pointer() const { return b; } template size_in_bytes) - span_fail_range_range(); - span_check_stats_check_range_counter += 1; - // fprintf(stderr, "span_check_range done\n"); + xspan_fail_range_range(); + xspan_stats.check_range_counter += 1; + // fprintf(stderr, "xspan_check_range done\n"); } -SPAN_NAMESPACE_END +XSPAN_NAMESPACE_END -#endif // WITH_SPAN +#endif // WITH_XSPAN /* vim:set ts=4 sw=4 et: */ diff --git a/src/util/xspan.h b/src/util/xspan.h index 30b0ce34..5b04c20e 100644 --- a/src/util/xspan.h +++ b/src/util/xspan.h @@ -30,41 +30,41 @@ // config and implementation **************************************************************************/ -#ifndef WITH_SPAN -#define WITH_SPAN 2 +#ifndef WITH_XSPAN +#define WITH_XSPAN 2 #endif -#if WITH_SPAN +#if WITH_XSPAN // automatic conversion to underlying pointer; do NOT enable this config as this // defeats the main purpose of a checked pointer => use raw_bytes() as needed; // and see xspan_fwd.h how to make this more convenient -#ifndef SPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION -#define SPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION 0 +#ifndef XSPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION +#define XSPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION 0 #endif // allow automatic conversion PtrOrSpanOrNull => PtrOrSpan => Span (with runtime checks) // choose between compile-time safety vs. possible run-time errors -#ifndef SPAN_CONFIG_ENABLE_SPAN_CONVERSION -#define SPAN_CONFIG_ENABLE_SPAN_CONVERSION 1 +#ifndef XSPAN_CONFIG_ENABLE_SPAN_CONVERSION +#define XSPAN_CONFIG_ENABLE_SPAN_CONVERSION 1 #endif #include "xspan_impl.h" -#ifdef SPAN_NAMESPACE_NAME +#ifdef XSPAN_NAMESPACE_NAME // help constructor to distinguish between number of elements and bytes -using SPAN_NAMESPACE_NAME::SpanCount; -using SPAN_NAMESPACE_NAME::SpanSizeInBytes; +using XSPAN_NAMESPACE_NAME::XSpanCount; +using XSPAN_NAMESPACE_NAME::XSpanSizeInBytes; // actual classes -using SPAN_NAMESPACE_NAME::Ptr; -using SPAN_NAMESPACE_NAME::PtrOrSpan; -using SPAN_NAMESPACE_NAME::PtrOrSpanOrNull; -using SPAN_NAMESPACE_NAME::Span; +using XSPAN_NAMESPACE_NAME::Ptr; +using XSPAN_NAMESPACE_NAME::PtrOrSpan; +using XSPAN_NAMESPACE_NAME::PtrOrSpanOrNull; +using XSPAN_NAMESPACE_NAME::Span; // util -using SPAN_NAMESPACE_NAME::raw_bytes; // overloaded for all classes -using SPAN_NAMESPACE_NAME::raw_index_bytes; // overloaded for all classes +using XSPAN_NAMESPACE_NAME::raw_bytes; // overloaded for all classes +using XSPAN_NAMESPACE_NAME::raw_index_bytes; // overloaded for all classes #endif -#endif // WITH_SPAN +#endif // WITH_XSPAN /************************************************************************* // usage @@ -76,41 +76,41 @@ using SPAN_NAMESPACE_NAME::raw_index_bytes; // overloaded for all classes // Ptr invariants: none; this is just a no-op pointer wrapper **************************************************************************/ -#if WITH_SPAN >= 2 +#if WITH_XSPAN >= 2 // fully checked -#define SPAN_0(type) PtrOrSpanOrNull -#define SPAN_P(type) PtrOrSpan -#define SPAN_S(type) Span +#define XSPAN_0(type) PtrOrSpanOrNull +#define XSPAN_P(type) PtrOrSpan +#define XSPAN_S(type) Span // create a value -#define SPAN_0_MAKE(type, first, ...) (SPAN_0(type)(first, ##__VA_ARGS__)) -#define SPAN_P_MAKE(type, first, ...) (SPAN_P(type)(first, ##__VA_ARGS__)) -#define SPAN_S_MAKE(type, first, ...) (SPAN_S(type)(first, ##__VA_ARGS__)) +#define XSPAN_0_MAKE(type, first, ...) (XSPAN_0(type)(first, ##__VA_ARGS__)) +#define XSPAN_P_MAKE(type, first, ...) (XSPAN_P(type)(first, ##__VA_ARGS__)) +#define XSPAN_S_MAKE(type, first, ...) (XSPAN_S(type)(first, ##__VA_ARGS__)) // define a variable -#define SPAN_0_VAR(type, var, first, ...) SPAN_0(type) var(first, ##__VA_ARGS__) -#define SPAN_P_VAR(type, var, first, ...) SPAN_P(type) var(first, ##__VA_ARGS__) -#define SPAN_S_VAR(type, var, first, ...) SPAN_S(type) var(first, ##__VA_ARGS__) +#define XSPAN_0_VAR(type, var, first, ...) XSPAN_0(type) var(first, ##__VA_ARGS__) +#define XSPAN_P_VAR(type, var, first, ...) XSPAN_P(type) var(first, ##__VA_ARGS__) +#define XSPAN_S_VAR(type, var, first, ...) XSPAN_S(type) var(first, ##__VA_ARGS__) -#elif WITH_SPAN >= 1 +#elif WITH_XSPAN >= 1 // unchecked - just a no-op pointer wrapper, no extra functionality -#define SPAN_0(type) Ptr -#define SPAN_P(type) Ptr -#define SPAN_S(type) Ptr +#define XSPAN_0(type) Ptr +#define XSPAN_P(type) Ptr +#define XSPAN_S(type) Ptr // create a value -#define SPAN_0_MAKE(type, first, ...) (SPAN_0(type)(first)) -#define SPAN_P_MAKE(type, first, ...) (SPAN_P(type)(first)) -#define SPAN_S_MAKE(type, first, ...) (SPAN_S(type)(first)) +#define XSPAN_0_MAKE(type, first, ...) (XSPAN_0(type)(first)) +#define XSPAN_P_MAKE(type, first, ...) (XSPAN_P(type)(first)) +#define XSPAN_S_MAKE(type, first, ...) (XSPAN_S(type)(first)) // define a variable -#define SPAN_0_VAR(type, var, first, ...) SPAN_0(type) var(first) -#define SPAN_P_VAR(type, var, first, ...) SPAN_P(type) var(first) -#define SPAN_S_VAR(type, var, first, ...) SPAN_S(type) var(first) +#define XSPAN_0_VAR(type, var, first, ...) XSPAN_0(type) var(first) +#define XSPAN_P_VAR(type, var, first, ...) XSPAN_P(type) var(first) +#define XSPAN_S_VAR(type, var, first, ...) XSPAN_S(type) var(first) #else @@ -118,32 +118,43 @@ using SPAN_NAMESPACE_NAME::raw_index_bytes; // overloaded for all classes // helper for implicit pointer conversions and MemBuffer overloads template -inline R *span_make_helper__(R * /*dummy*/, T *first) { +inline R *xspan_make_helper__(R * /*dummy*/, T *first) { return first; // IMPORTANT: no cast here to detect bad usage } template -inline R *span_make_helper__(R * /*dummy*/, std::nullptr_t /*first*/) { +inline R *xspan_make_helper__(R * /*dummy*/, std::nullptr_t /*first*/) { return nullptr; } template -inline R *span_make_helper__(R * /*dummy*/, MemBuffer &first) { +inline R *xspan_make_helper__(R * /*dummy*/, MemBuffer &first) { return (R *) membuffer_get_void_ptr(first); } -#define SPAN_0(type) type * -#define SPAN_P(type) type * -#define SPAN_S(type) type * +#define XSPAN_0(type) type * +#define XSPAN_P(type) type * +#define XSPAN_S(type) type * // create a value -#define SPAN_0_MAKE(type, first, ...) (span_make_helper__((type *) nullptr, first)) -#define SPAN_P_MAKE(type, first, ...) (span_make_helper__((type *) nullptr, first)) -#define SPAN_S_MAKE(type, first, ...) (span_make_helper__((type *) nullptr, first)) +#define XSPAN_0_MAKE(type, first, ...) (xspan_make_helper__((type *) nullptr, first)) +#define XSPAN_P_MAKE(type, first, ...) (xspan_make_helper__((type *) nullptr, first)) +#define XSPAN_S_MAKE(type, first, ...) (xspan_make_helper__((type *) nullptr, first)) // define a variable -#define SPAN_0_VAR(type, var, first, ...) type *var = SPAN_0_MAKE(type, first) -#define SPAN_P_VAR(type, var, first, ...) type *var = SPAN_P_MAKE(type, first) -#define SPAN_S_VAR(type, var, first, ...) type *var = SPAN_S_MAKE(type, first) +#define XSPAN_0_VAR(type, var, first, ...) type *var = XSPAN_0_MAKE(type, first) +#define XSPAN_P_VAR(type, var, first, ...) type *var = XSPAN_P_MAKE(type, first) +#define XSPAN_S_VAR(type, var, first, ...) type *var = XSPAN_S_MAKE(type, first) -#endif // WITH_SPAN +#endif // WITH_XSPAN + +// old names +#define SPAN_0 XSPAN_0 +#define SPAN_P XSPAN_P +#define SPAN_S XSPAN_S +#define SPAN_0_MAKE XSPAN_0_MAKE +#define SPAN_P_MAKE XSPAN_P_MAKE +#define SPAN_S_MAKE XSPAN_S_MAKE +#define SPAN_0_VAR XSPAN_0_VAR +#define SPAN_P_VAR XSPAN_P_VAR +#define SPAN_S_VAR XSPAN_S_VAR /* vim:set ts=4 sw=4 et: */ diff --git a/src/util/xspan_fwd.h b/src/util/xspan_fwd.h index 69f08a9a..4b4f3055 100644 --- a/src/util/xspan_fwd.h +++ b/src/util/xspan_fwd.h @@ -27,9 +27,9 @@ // manually forward a number of well-known functions using a // checked "raw_bytes()" call -#define SPAN_FWD_TU(RType) \ +#define XSPAN_FWD_TU(RType) \ template \ - inline SPAN_REQUIRES_CONVERTIBLE_ANY_DIRECTION(T, U, RType) + inline XSPAN_REQUIRES_CONVERTIBLE_ANY_DIRECTION(T, U, RType) /************************************************************************* // overloads for standard functions @@ -52,16 +52,16 @@ template inline int memcmp(const void *a, const C &b, size_t n) { return memcmp(a, b.raw_bytes(n), n); } -SPAN_FWD_TU(int) memcmp(const C &a, const C &b, size_t n) { +XSPAN_FWD_TU(int) memcmp(const C &a, const C &b, size_t n) { return memcmp(a.raw_bytes(n), b.raw_bytes(n), n); } #ifdef D -SPAN_FWD_TU(int) memcmp(const C &a, const D &b, size_t n) { +XSPAN_FWD_TU(int) memcmp(const C &a, const D &b, size_t n) { return memcmp(a.raw_bytes(n), b.raw_bytes(n), n); } #endif #ifdef E -SPAN_FWD_TU(int) memcmp(const C &a, const E &b, size_t n) { +XSPAN_FWD_TU(int) memcmp(const C &a, const E &b, size_t n) { return memcmp(a.raw_bytes(n), b.raw_bytes(n), n); } #endif @@ -74,16 +74,16 @@ template inline void *memcpy(void *a, const C &b, size_t n) { return memcpy(a, b.raw_bytes(n), n); } -SPAN_FWD_TU(void *) memcpy(const C &a, const C &b, size_t n) { +XSPAN_FWD_TU(void *) memcpy(const C &a, const C &b, size_t n) { return memcpy(a.raw_bytes(n), b.raw_bytes(n), n); } #ifdef D -SPAN_FWD_TU(void *) memcpy(const C &a, const D &b, size_t n) { +XSPAN_FWD_TU(void *) memcpy(const C &a, const D &b, size_t n) { return memcpy(a.raw_bytes(n), b.raw_bytes(n), n); } #endif #ifdef E -SPAN_FWD_TU(void *) memcpy(const C &a, const E &b, size_t n) { +XSPAN_FWD_TU(void *) memcpy(const C &a, const E &b, size_t n) { return memcpy(a.raw_bytes(n), b.raw_bytes(n), n); } #endif @@ -96,16 +96,16 @@ template inline void *memmove(void *a, const C &b, size_t n) { return memmove(a, b.raw_bytes(n), n); } -SPAN_FWD_TU(void *) memmove(const C &a, const C &b, size_t n) { +XSPAN_FWD_TU(void *) memmove(const C &a, const C &b, size_t n) { return memmove(a.raw_bytes(n), b.raw_bytes(n), n); } #ifdef D -SPAN_FWD_TU(void *) memmove(const C &a, const D &b, size_t n) { +XSPAN_FWD_TU(void *) memmove(const C &a, const D &b, size_t n) { return memmove(a.raw_bytes(n), b.raw_bytes(n), n); } #endif #ifdef E -SPAN_FWD_TU(void *) memmove(const C &a, const E &b, size_t n) { +XSPAN_FWD_TU(void *) memmove(const C &a, const E &b, size_t n) { return memmove(a.raw_bytes(n), b.raw_bytes(n), n); } #endif @@ -127,16 +127,16 @@ template inline int ptr_diff_bytes(const void *a, const C &b) { return ptr_diff_bytes(a, b.raw_bytes(0)); } -SPAN_FWD_TU(int) ptr_diff_bytes(const C &a, const C &b) { +XSPAN_FWD_TU(int) ptr_diff_bytes(const C &a, const C &b) { return ptr_diff_bytes(a.raw_bytes(0), b.raw_bytes(0)); } #ifdef D -SPAN_FWD_TU(int) ptr_diff_bytes(const C &a, const D &b) { +XSPAN_FWD_TU(int) ptr_diff_bytes(const C &a, const D &b) { return ptr_diff_bytes(a.raw_bytes(0), b.raw_bytes(0)); } #endif #ifdef E -SPAN_FWD_TU(int) ptr_diff_bytes(const C &a, const E &b) { +XSPAN_FWD_TU(int) ptr_diff_bytes(const C &a, const E &b) { return ptr_diff_bytes(a.raw_bytes(0), b.raw_bytes(0)); } #endif @@ -149,16 +149,16 @@ template inline unsigned ptr_udiff_bytes(const void *a, const C &b) { return ptr_udiff_bytes(a, b.raw_bytes(0)); } -SPAN_FWD_TU(unsigned) ptr_udiff_bytes(const C &a, const C &b) { +XSPAN_FWD_TU(unsigned) ptr_udiff_bytes(const C &a, const C &b) { return ptr_udiff_bytes(a.raw_bytes(0), b.raw_bytes(0)); } #ifdef D -SPAN_FWD_TU(unsigned) ptr_udiff_bytes(const C &a, const D &b) { +XSPAN_FWD_TU(unsigned) ptr_udiff_bytes(const C &a, const D &b) { return ptr_udiff_bytes(a.raw_bytes(0), b.raw_bytes(0)); } #endif #ifdef E -SPAN_FWD_TU(unsigned) ptr_udiff_bytes(const C &a, const E &b) { +XSPAN_FWD_TU(unsigned) ptr_udiff_bytes(const C &a, const E &b) { return ptr_udiff_bytes(a.raw_bytes(0), b.raw_bytes(0)); } #endif @@ -295,6 +295,6 @@ typename std::enable_if::type upx_safe_strlen(const #endif // UPX_VERSION_HEX -#undef SPAN_FWD_TU +#undef XSPAN_FWD_TU /* vim:set ts=4 sw=4 et: */ diff --git a/src/util/xspan_impl.h b/src/util/xspan_impl.h index 8e3b29d1..431b1db9 100644 --- a/src/util/xspan_impl.h +++ b/src/util/xspan_impl.h @@ -26,37 +26,37 @@ #pragma once -#if WITH_SPAN +#if WITH_XSPAN #if 1 -#define SPAN_NAMESPACE_NAME XSpan -#define SPAN_NAMESPACE_BEGIN namespace SPAN_NAMESPACE_NAME { -#define SPAN_NAMESPACE_END } -#define SPAN_NS(x) SPAN_NAMESPACE_NAME ::x +#define XSPAN_NAMESPACE_NAME XSpan +#define XSPAN_NAMESPACE_BEGIN namespace XSPAN_NAMESPACE_NAME { +#define XSPAN_NAMESPACE_END } +#define XSPAN_NS(x) XSPAN_NAMESPACE_NAME ::x #else -#define SPAN_NAMESPACE_BEGIN /*empty*/ -#define SPAN_NAMESPACE_END /*empty*/ -#define SPAN_NS(x) ::x +#define XSPAN_NAMESPACE_BEGIN /*empty*/ +#define XSPAN_NAMESPACE_END /*empty*/ +#define XSPAN_NS(x) ::x #endif -SPAN_NAMESPACE_BEGIN +XSPAN_NAMESPACE_BEGIN // HINT: set env-var "UPX_DEBUG_DOCTEST_DISABLE=1" for improved debugging experience -__acc_noinline void span_fail_nullptr(); -__acc_noinline void span_fail_nullbase(); -__acc_noinline void span_fail_not_same_base(); -__acc_noinline void span_fail_range_nullptr(); -__acc_noinline void span_fail_range_nullbase(); -__acc_noinline void span_fail_range_range(); -void span_check_range(const void *p, const void *base, ptrdiff_t size_in_bytes); +__acc_noinline void xspan_fail_nullptr(); +__acc_noinline void xspan_fail_nullbase(); +__acc_noinline void xspan_fail_not_same_base(); +__acc_noinline void xspan_fail_range_nullptr(); +__acc_noinline void xspan_fail_range_nullbase(); +__acc_noinline void xspan_fail_range_range(); +void xspan_check_range(const void *p, const void *base, ptrdiff_t size_in_bytes); // help constructor to distinguish between number of elements and bytes -struct SpanCount { - explicit SpanCount(size_t n) : count(n) {} +struct XSpanCount { + explicit XSpanCount(size_t n) : count(n) {} size_t count; // public }; -struct SpanSizeInBytes { - explicit SpanSizeInBytes(size_t bytes) : size_in_bytes(bytes) {} +struct XSpanSizeInBytes { + explicit XSpanSizeInBytes(size_t bytes) : size_in_bytes(bytes) {} size_t size_in_bytes; // public }; @@ -84,9 +84,9 @@ ACC_COMPILE_TIME_ASSERT_HEADER(ValueForSizeOf::value == 1) ACC_COMPILE_TIME_ASSERT_HEADER(ValueForSizeOf::value == 1) ACC_COMPILE_TIME_ASSERT_HEADER(ValueForSizeOf::value == 4) -#ifndef span_mem_size_impl +#ifndef xspan_mem_size_impl template -inline size_t span_mem_size_impl(size_t n) { +inline size_t xspan_mem_size_impl(size_t n) { #ifdef UPX_VERSION_HEX // check for overflow and sane limits return mem_size(sizeof(T), n); @@ -97,82 +97,82 @@ inline size_t span_mem_size_impl(size_t n) { #endif template -inline size_t span_mem_size(size_t n) { - return span_mem_size_impl::type>(n); +inline size_t xspan_mem_size(size_t n) { + return xspan_mem_size_impl::type>(n); } template -inline void span_mem_size_assert_ptrdiff(ptrdiff_t n) { +inline void xspan_mem_size_assert_ptrdiff(ptrdiff_t n) { if (n >= 0) - (void) span_mem_size((size_t) n); + (void) xspan_mem_size((size_t) n); else - (void) span_mem_size((size_t) -n); + (void) xspan_mem_size((size_t) -n); } #if 0 template -struct Span_is_convertible : public std::is_convertible {}; +struct XSpan_is_convertible : public std::is_convertible {}; #else namespace detail { template -struct Span_void_to_T { +struct XSpan_void_to_T { typedef U type; }; template -struct Span_void_to_T { +struct XSpan_void_to_T { typedef typename std::remove_const::type type; }; template -struct Span_void_to_T { +struct XSpan_void_to_T { // typedef typename std::add_const::type type; typedef T type; }; template -struct Span_ptr_is_convertible : public std::false_type {}; +struct XSpan_ptr_is_convertible : public std::false_type {}; template -struct Span_ptr_is_convertible : public std::true_type {}; +struct XSpan_ptr_is_convertible : public std::true_type {}; template -struct Span_ptr_is_convertible : public std::true_type {}; +struct XSpan_ptr_is_convertible : public std::true_type {}; } // namespace detail template -struct Span_is_convertible - : public detail::Span_ptr_is_convertible::type> {}; +struct XSpan_is_convertible + : public detail::XSpan_ptr_is_convertible::type> {}; #endif #if 1 // char => char -ACC_COMPILE_TIME_ASSERT_HEADER((Span_is_convertible::value)) -ACC_COMPILE_TIME_ASSERT_HEADER((Span_is_convertible::value)) -ACC_COMPILE_TIME_ASSERT_HEADER((Span_is_convertible::value)) -ACC_COMPILE_TIME_ASSERT_HEADER((!Span_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER((XSpan_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER((XSpan_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER((XSpan_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER((!XSpan_is_convertible::value)) // void => void -ACC_COMPILE_TIME_ASSERT_HEADER((Span_is_convertible::value)) -ACC_COMPILE_TIME_ASSERT_HEADER((Span_is_convertible::value)) -ACC_COMPILE_TIME_ASSERT_HEADER((Span_is_convertible::value)) -ACC_COMPILE_TIME_ASSERT_HEADER((!Span_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER((XSpan_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER((XSpan_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER((XSpan_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER((!XSpan_is_convertible::value)) // char => void -ACC_COMPILE_TIME_ASSERT_HEADER((Span_is_convertible::value)) -ACC_COMPILE_TIME_ASSERT_HEADER((Span_is_convertible::value)) -ACC_COMPILE_TIME_ASSERT_HEADER((Span_is_convertible::value)) -ACC_COMPILE_TIME_ASSERT_HEADER((!Span_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER((XSpan_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER((XSpan_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER((XSpan_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER((!XSpan_is_convertible::value)) // void => char -ACC_COMPILE_TIME_ASSERT_HEADER((!Span_is_convertible::value)) -ACC_COMPILE_TIME_ASSERT_HEADER((!Span_is_convertible::value)) -ACC_COMPILE_TIME_ASSERT_HEADER((!Span_is_convertible::value)) -ACC_COMPILE_TIME_ASSERT_HEADER((!Span_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER((!XSpan_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER((!XSpan_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER((!XSpan_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER((!XSpan_is_convertible::value)) // char => int -ACC_COMPILE_TIME_ASSERT_HEADER(!(Span_is_convertible::value)) -ACC_COMPILE_TIME_ASSERT_HEADER(!(Span_is_convertible::value)) -ACC_COMPILE_TIME_ASSERT_HEADER(!(Span_is_convertible::value)) -ACC_COMPILE_TIME_ASSERT_HEADER((!Span_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER(!(XSpan_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER(!(XSpan_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER(!(XSpan_is_convertible::value)) +ACC_COMPILE_TIME_ASSERT_HEADER((!XSpan_is_convertible::value)) #endif /************************************************************************* @@ -193,44 +193,44 @@ struct Span; template struct Ptr; -class SpanInternalDummyArg; // not implemented +class XSpanInternalDummyArg; // not implemented -SPAN_NAMESPACE_END +XSPAN_NAMESPACE_END -#ifndef SPAN_DELETED_FUNCTION -#define SPAN_DELETED_FUNCTION = delete +#ifndef XSPAN_DELETED_FUNCTION +#define XSPAN_DELETED_FUNCTION = delete #endif -#define SPAN_REQUIRES_CONVERTIBLE_UT(T, U, RType) \ - typename std::enable_if::value, RType > ::type -#define SPAN_REQUIRES_CONVERTIBLE_ANY_DIRECTION(T, U, RType) \ - typename std::enable_if::value || \ - SPAN_NS(Span_is_convertible)::value, \ +#define XSPAN_REQUIRES_CONVERTIBLE_UT(T, U, RType) \ + typename std::enable_if::value, RType > ::type +#define XSPAN_REQUIRES_CONVERTIBLE_ANY_DIRECTION(T, U, RType) \ + typename std::enable_if::value || \ + XSPAN_NS(XSpan_is_convertible)::value, \ RType > ::type // note: these use "T" and "U" -#define SPAN_REQUIRES_CONVERTIBLE_R(RType) SPAN_REQUIRES_CONVERTIBLE_UT(T, U, RType) -#define SPAN_REQUIRES_CONVERTIBLE_A \ - SPAN_REQUIRES_CONVERTIBLE_R(SPAN_NS(SpanInternalDummyArg) *) = nullptr -#define SPAN_REQUIRES_CONVERTIBLE_T SPAN_REQUIRES_CONVERTIBLE_R(SPAN_NS(SpanInternalDummyArg) *) +#define XSPAN_REQUIRES_CONVERTIBLE_R(RType) XSPAN_REQUIRES_CONVERTIBLE_UT(T, U, RType) +#define XSPAN_REQUIRES_CONVERTIBLE_A \ + XSPAN_REQUIRES_CONVERTIBLE_R(XSPAN_NS(XSpanInternalDummyArg) *) = nullptr +#define XSPAN_REQUIRES_CONVERTIBLE_T XSPAN_REQUIRES_CONVERTIBLE_R(XSPAN_NS(XSpanInternalDummyArg) *) // note: these use "T" and "U" -#define SPAN_REQUIRES_SIZE_1_R(RType) \ - typename std::enable_if::value &&SPAN_NS( \ +#define XSPAN_REQUIRES_SIZE_1_R(RType) \ + typename std::enable_if::value &&XSPAN_NS( \ ValueForSizeOf)::value == 1 && \ - SPAN_NS(ValueForSizeOf)::value == 1, \ + XSPAN_NS(ValueForSizeOf)::value == 1, \ RType > ::type -#define SPAN_REQUIRES_SIZE_1_A SPAN_REQUIRES_SIZE_1_R(SPAN_NS(SpanInternalDummyArg) *) = nullptr +#define XSPAN_REQUIRES_SIZE_1_A XSPAN_REQUIRES_SIZE_1_R(XSPAN_NS(XSpanInternalDummyArg) *) = nullptr #include "xspan_impl_ptr_or_null.h" #include "xspan_impl_ptr_or_span.h" #include "xspan_impl_span.h" #include "xspan_impl_ptr.h" -#undef SPAN_REQUIRES_CONVERTIBLE_UT -#undef SPAN_REQUIRES_CONVERTIBLE_ANY_DIRECTION -#undef SPAN_REQUIRES_CONVERTIBLE_A -#undef SPAN_REQUIRES_CONVERTIBLE_R -#undef SPAN_REQUIRES_CONVERTIBLE_T -#undef SPAN_REQUIRES_SIZE_1_A -#undef SPAN_REQUIRES_SIZE_1_R +#undef XSPAN_REQUIRES_CONVERTIBLE_UT +#undef XSPAN_REQUIRES_CONVERTIBLE_ANY_DIRECTION +#undef XSPAN_REQUIRES_CONVERTIBLE_A +#undef XSPAN_REQUIRES_CONVERTIBLE_R +#undef XSPAN_REQUIRES_CONVERTIBLE_T +#undef XSPAN_REQUIRES_SIZE_1_A +#undef XSPAN_REQUIRES_SIZE_1_R -#endif // WITH_SPAN +#endif // WITH_XSPAN /* vim:set ts=4 sw=4 et: */ diff --git a/src/util/xspan_impl_common.h b/src/util/xspan_impl_common.h index 503e678f..dad5602e 100644 --- a/src/util/xspan_impl_common.h +++ b/src/util/xspan_impl_common.h @@ -42,7 +42,7 @@ friend struct PtrOrSpanOrNull; template friend struct Span; -#if SPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION +#if XSPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION operator pointer() const { return ptr; } #endif @@ -59,7 +59,7 @@ __acc_noinline void assertInvariants() const { if __acc_cte (configRequireBase) assert(base != nullptr); if __acc_cte ((configRequirePtr || ptr != nullptr) && (configRequireBase || base != nullptr)) - span_check_range(ptr, base, size_in_bytes); + xspan_check_range(ptr, base, size_in_bytes); } #else __acc_forceinline void assertInvariants() const {} @@ -67,74 +67,74 @@ __acc_forceinline void assertInvariants() const {} static __acc_forceinline pointer makeNotNull(pointer p) { if __acc_very_unlikely (p == nullptr) - span_fail_nullptr(); + xspan_fail_nullptr(); return p; } // enforce config invariants at constructor time - static functions static __acc_forceinline pointer makePtr(pointer p) { if __acc_cte (configRequirePtr && p == nullptr) - span_fail_nullptr(); + xspan_fail_nullptr(); return p; } static __acc_forceinline pointer makeBase(pointer b) { if __acc_cte (configRequireBase && b == nullptr) - span_fail_nullbase(); + xspan_fail_nullbase(); return b; } // inverse logic for ensuring valid pointers from existing objets __acc_forceinline pointer ensurePtr() const { if __acc_cte (!configRequirePtr && ptr == nullptr) - span_fail_nullptr(); + xspan_fail_nullptr(); return ptr; } __acc_forceinline pointer ensureBase() const { if __acc_cte (!configRequireBase && base == nullptr) - span_fail_nullbase(); + xspan_fail_nullbase(); return base; } public: inline ~CSelf() {} // constructors from pointers -CSelf(pointer first, SpanCount count) - : ptr(makePtr(first)), base(makeBase(first)), size_in_bytes(span_mem_size(count.count)) { +CSelf(pointer first, XSpanCount count) + : ptr(makePtr(first)), base(makeBase(first)), size_in_bytes(xspan_mem_size(count.count)) { assertInvariants(); } -CSelf(pointer first, SpanSizeInBytes bytes) +CSelf(pointer first, XSpanSizeInBytes bytes) : ptr(makePtr(first)), base(makeBase(first)), - size_in_bytes(span_mem_size(bytes.size_in_bytes)) { + size_in_bytes(xspan_mem_size(bytes.size_in_bytes)) { assertInvariants(); } // enable this constructor only if the underlying type is char or void template -CSelf(U *first, size_type count, SPAN_REQUIRES_SIZE_1_A) - : ptr(makePtr(first)), base(makeBase(first)), size_in_bytes(span_mem_size(count)) { +CSelf(U *first, size_type count, XSPAN_REQUIRES_SIZE_1_A) + : ptr(makePtr(first)), base(makeBase(first)), size_in_bytes(xspan_mem_size(count)) { assertInvariants(); } -CSelf(pointer first, SpanCount count, pointer base_) - : ptr(makePtr(first)), base(makeBase(base_)), size_in_bytes(span_mem_size(count.count)) { +CSelf(pointer first, XSpanCount count, pointer base_) + : ptr(makePtr(first)), base(makeBase(base_)), size_in_bytes(xspan_mem_size(count.count)) { // check invariants if __acc_cte ((configRequirePtr || ptr != nullptr) && (configRequireBase || base != nullptr)) - span_check_range(ptr, base, size_in_bytes); + xspan_check_range(ptr, base, size_in_bytes); // double sanity check assertInvariants(); } -CSelf(pointer first, SpanSizeInBytes bytes, pointer base_) +CSelf(pointer first, XSpanSizeInBytes bytes, pointer base_) : ptr(makePtr(first)), base(makeBase(base_)), - size_in_bytes(span_mem_size(bytes.size_in_bytes)) { + size_in_bytes(xspan_mem_size(bytes.size_in_bytes)) { // check invariants if __acc_cte ((configRequirePtr || ptr != nullptr) && (configRequireBase || base != nullptr)) - span_check_range(ptr, base, size_in_bytes); + xspan_check_range(ptr, base, size_in_bytes); // double sanity check assertInvariants(); } // enable this constructor only if the underlying type is char or void template -CSelf(pointer first, size_type count, U *base_, SPAN_REQUIRES_SIZE_1_A) - : ptr(makePtr(first)), base(makeBase(base_)), size_in_bytes(span_mem_size(count)) { +CSelf(pointer first, size_type count, U *base_, XSPAN_REQUIRES_SIZE_1_A) + : ptr(makePtr(first)), base(makeBase(base_)), size_in_bytes(xspan_mem_size(count)) { // check invariants if __acc_cte ((configRequirePtr || ptr != nullptr) && (configRequireBase || base != nullptr)) - span_check_range(ptr, base, size_in_bytes); + xspan_check_range(ptr, base, size_in_bytes); // double sanity check assertInvariants(); } @@ -142,23 +142,23 @@ CSelf(pointer first, size_type count, U *base_, SPAN_REQUIRES_SIZE_1_A) // constructors from MemBuffer CSelf(MemBuffer &mb) : CSelf(makeNotNull((pointer) membuffer_get_void_ptr(mb)), - SpanSizeInBytes(membuffer_get_size(mb))) {} + XSpanSizeInBytes(membuffer_get_size(mb))) {} CSelf(pointer first, MemBuffer &mb) - : CSelf(first, SpanSizeInBytes(membuffer_get_size(mb)), + : CSelf(first, XSpanSizeInBytes(membuffer_get_size(mb)), makeNotNull((pointer) membuffer_get_void_ptr(mb))) {} -CSelf(std::nullptr_t, MemBuffer &) SPAN_DELETED_FUNCTION; +CSelf(std::nullptr_t, MemBuffer &) XSPAN_DELETED_FUNCTION; #endif // disable constructors from nullptr to catch compile-time misuse private: -CSelf(std::nullptr_t, SpanCount) SPAN_DELETED_FUNCTION; -CSelf(std::nullptr_t, SpanCount, std::nullptr_t) SPAN_DELETED_FUNCTION; -CSelf(const void *, SpanCount, std::nullptr_t) SPAN_DELETED_FUNCTION; -CSelf(std::nullptr_t, SpanSizeInBytes) SPAN_DELETED_FUNCTION; -CSelf(std::nullptr_t, SpanSizeInBytes, std::nullptr_t) SPAN_DELETED_FUNCTION; -CSelf(const void *, SpanSizeInBytes, std::nullptr_t) SPAN_DELETED_FUNCTION; -CSelf(std::nullptr_t, size_type) SPAN_DELETED_FUNCTION; -CSelf(std::nullptr_t, size_type, std::nullptr_t) SPAN_DELETED_FUNCTION; -CSelf(const void *, size_type, std::nullptr_t) SPAN_DELETED_FUNCTION; +CSelf(std::nullptr_t, XSpanCount) XSPAN_DELETED_FUNCTION; +CSelf(std::nullptr_t, XSpanCount, std::nullptr_t) XSPAN_DELETED_FUNCTION; +CSelf(const void *, XSpanCount, std::nullptr_t) XSPAN_DELETED_FUNCTION; +CSelf(std::nullptr_t, XSpanSizeInBytes) XSPAN_DELETED_FUNCTION; +CSelf(std::nullptr_t, XSpanSizeInBytes, std::nullptr_t) XSPAN_DELETED_FUNCTION; +CSelf(const void *, XSpanSizeInBytes, std::nullptr_t) XSPAN_DELETED_FUNCTION; +CSelf(std::nullptr_t, size_type) XSPAN_DELETED_FUNCTION; +CSelf(std::nullptr_t, size_type, std::nullptr_t) XSPAN_DELETED_FUNCTION; +CSelf(const void *, size_type, std::nullptr_t) XSPAN_DELETED_FUNCTION; // unchecked constructor protected: @@ -192,7 +192,7 @@ Self &assign(pointer other) { assertInvariants(); other = makePtr(other); if __acc_cte ((configRequirePtr || other != nullptr) && (configRequireBase || base != nullptr)) - span_check_range(other, base, size_in_bytes); + xspan_check_range(other, base, size_in_bytes); // ok ptr = other; assertInvariants(); @@ -205,7 +205,7 @@ Self &assign(const Self &other) { // magic 1: if base is unset, automatically set base/size_in_bytes from other if __acc_cte ((configRequirePtr || other.ptr != nullptr) && (configRequireBase || other.base != nullptr)) - span_check_range(other.ptr, other.base, other.size_in_bytes); + xspan_check_range(other.ptr, other.base, other.size_in_bytes); // ok ptr = other.ptr; base = other.base; @@ -214,10 +214,10 @@ Self &assign(const Self &other) { // magic 2: assert same base (but ignore size_in_bytes !) if __acc_cte (configRequireBase || other.base != nullptr) if __acc_very_unlikely (base != other.base) - span_fail_not_same_base(); + xspan_fail_not_same_base(); if __acc_cte ((configRequirePtr || other.ptr != nullptr) && (configRequireBase || base != nullptr)) - span_check_range(other.ptr, base, size_in_bytes); + xspan_check_range(other.ptr, base, size_in_bytes); // ok ptr = other.ptr; } @@ -231,7 +231,7 @@ Self &operator=(const Self &other) { return assign(other); } // FIXME: this is not called?? template -SPAN_REQUIRES_CONVERTIBLE_R(Self &) +XSPAN_REQUIRES_CONVERTIBLE_R(Self &) operator=(const CSelf &other) { // assert(0); return assign(Self(other)); @@ -252,65 +252,65 @@ Self subspan(ptrdiff_t offset, ptrdiff_t count) { bool operator==(pointer other) const { return ptr == other; } template -SPAN_REQUIRES_CONVERTIBLE_R(bool) +XSPAN_REQUIRES_CONVERTIBLE_R(bool) operator==(U *other) const { return ptr == other; } bool operator!=(pointer other) const { return ptr != other; } template -SPAN_REQUIRES_CONVERTIBLE_R(bool) +XSPAN_REQUIRES_CONVERTIBLE_R(bool) operator!=(U *other) const { return ptr != other; } template -SPAN_REQUIRES_CONVERTIBLE_R(bool) +XSPAN_REQUIRES_CONVERTIBLE_R(bool) operator==(const PtrOrSpan &other) const { return ptr == other.ptr; } template -SPAN_REQUIRES_CONVERTIBLE_R(bool) +XSPAN_REQUIRES_CONVERTIBLE_R(bool) operator==(const PtrOrSpanOrNull &other) const { return ptr == other.ptr; } template -SPAN_REQUIRES_CONVERTIBLE_R(bool) +XSPAN_REQUIRES_CONVERTIBLE_R(bool) operator==(const Span &other) const { return ptr == other.ptr; } template -SPAN_REQUIRES_CONVERTIBLE_R(bool) +XSPAN_REQUIRES_CONVERTIBLE_R(bool) operator!=(const PtrOrSpan &other) const { return !(*this == other); } template -SPAN_REQUIRES_CONVERTIBLE_R(bool) +XSPAN_REQUIRES_CONVERTIBLE_R(bool) operator!=(const PtrOrSpanOrNull &other) const { return !(*this == other); } template -SPAN_REQUIRES_CONVERTIBLE_R(bool) +XSPAN_REQUIRES_CONVERTIBLE_R(bool) operator!=(const Span &other) const { return !(*this == other); } // check for notNull here -bool operator<(std::nullptr_t) const SPAN_DELETED_FUNCTION; +bool operator<(std::nullptr_t) const XSPAN_DELETED_FUNCTION; bool operator<(pointer other) const { return ensurePtr() < makeNotNull(other); } template -SPAN_REQUIRES_CONVERTIBLE_R(bool) +XSPAN_REQUIRES_CONVERTIBLE_R(bool) operator<(const PtrOrSpan &other) const { return ensurePtr() < other.ensurePtr(); } template -SPAN_REQUIRES_CONVERTIBLE_R(bool) +XSPAN_REQUIRES_CONVERTIBLE_R(bool) operator<(const PtrOrSpanOrNull &other) const { return ensurePtr() < other.ensurePtr(); } template -SPAN_REQUIRES_CONVERTIBLE_R(bool) +XSPAN_REQUIRES_CONVERTIBLE_R(bool) operator<(const Span &other) const { return ensurePtr() < other.ensurePtr(); } @@ -364,36 +364,36 @@ Self operator-(ptrdiff_t n) const { private: pointer check_deref(pointer p) const { if __acc_cte (!configRequirePtr && p == nullptr) - span_fail_nullptr(); + xspan_fail_nullptr(); if __acc_cte (configRequireBase || base != nullptr) - span_check_range(p, base, size_in_bytes - sizeof(T)); + xspan_check_range(p, base, size_in_bytes - sizeof(T)); assertInvariants(); return p; } pointer check_deref(pointer p, ptrdiff_t n) const { if __acc_cte (!configRequirePtr && p == nullptr) - span_fail_nullptr(); - span_mem_size_assert_ptrdiff(n); + xspan_fail_nullptr(); + xspan_mem_size_assert_ptrdiff(n); p += n; if __acc_cte (configRequireBase || base != nullptr) - span_check_range(p, base, size_in_bytes - sizeof(T)); + xspan_check_range(p, base, size_in_bytes - sizeof(T)); assertInvariants(); return p; } pointer check_add(pointer p, ptrdiff_t n) const { if __acc_cte (!configRequirePtr && p == nullptr) - span_fail_nullptr(); - span_mem_size_assert_ptrdiff(n); + xspan_fail_nullptr(); + xspan_mem_size_assert_ptrdiff(n); p += n; if __acc_cte (configRequireBase || base != nullptr) - span_check_range(p, base, size_in_bytes); + xspan_check_range(p, base, size_in_bytes); assertInvariants(); return p; } // disable taking the address => force passing by reference // [I'm not too sure about this design decision, but we can always allow it if needed] -Self *operator&() const SPAN_DELETED_FUNCTION; +Self *operator&() const XSPAN_DELETED_FUNCTION; public: // raw access pointer raw_ptr() const { return ptr; } @@ -404,9 +404,9 @@ pointer raw_bytes(size_t bytes) const { assertInvariants(); if (bytes > 0) { if __acc_cte (!configRequirePtr && ptr == nullptr) - span_fail_nullptr(); + xspan_fail_nullptr(); if __acc_cte (configRequireBase || base != nullptr) { - span_check_range(ptr, base, size_in_bytes - bytes); + xspan_check_range(ptr, base, size_in_bytes - bytes); } } return ptr; diff --git a/src/util/xspan_impl_ptr.h b/src/util/xspan_impl_ptr.h index 3b22dc24..c18b56fe 100644 --- a/src/util/xspan_impl_ptr.h +++ b/src/util/xspan_impl_ptr.h @@ -26,7 +26,7 @@ #pragma once -SPAN_NAMESPACE_BEGIN +XSPAN_NAMESPACE_BEGIN /************************************************************************* // Ptr @@ -58,7 +58,7 @@ private: __acc_forceinline void assertInvariants() const {} public: -#if SPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION || 1 +#if XSPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION || 1 operator pointer() const { return ptr; } #endif @@ -68,14 +68,14 @@ public: // constructors from pointers CSelf(pointer p) : ptr(makePtr(p)) { assertInvariants(); } template - CSelf(U *p, SPAN_REQUIRES_CONVERTIBLE_A) : ptr(makePtr(p)) { + CSelf(U *p, XSPAN_REQUIRES_CONVERTIBLE_A) : ptr(makePtr(p)) { assertInvariants(); } // constructors CSelf(const Self &other) : ptr(other.ptr) { assertInvariants(); } template - CSelf(const CSelf &other, SPAN_REQUIRES_CONVERTIBLE_A) : ptr(other.ptr) { + CSelf(const CSelf &other, XSPAN_REQUIRES_CONVERTIBLE_A) : ptr(other.ptr) { assertInvariants(); } @@ -92,7 +92,7 @@ public: // FIXME: this is not called !! template - SPAN_REQUIRES_CONVERTIBLE_R(Self &) + XSPAN_REQUIRES_CONVERTIBLE_R(Self &) operator=(U *other) { // assert(0); return assign(Self(other)); @@ -100,7 +100,7 @@ public: // FIXME: this is not called !! template - SPAN_REQUIRES_CONVERTIBLE_R(Self &) + XSPAN_REQUIRES_CONVERTIBLE_R(Self &) operator=(const CSelf &other) { // assert(0); return assign(Self(other)); @@ -110,12 +110,12 @@ public: bool operator==(pointer other) const { return ptr == other; } template - SPAN_REQUIRES_CONVERTIBLE_R(bool) + XSPAN_REQUIRES_CONVERTIBLE_R(bool) operator==(U *other) const { return ptr == other; } template - SPAN_REQUIRES_CONVERTIBLE_R(bool) + XSPAN_REQUIRES_CONVERTIBLE_R(bool) operator==(const Ptr &other) const { return ptr == other.ptr; } @@ -183,7 +183,7 @@ public: // raw access assertInvariants(); if (bytes > 0) { if __acc_cte (ptr == nullptr) - span_fail_nullptr(); + xspan_fail_nullptr(); } return ptr; } @@ -207,11 +207,11 @@ inline typename Ptr::pointer raw_index_bytes(const Ptr &a, size_t index, // **************************************************************************/ -SPAN_NAMESPACE_END +XSPAN_NAMESPACE_END #if 1 -#define C SPAN_NS(Ptr) +#define C XSPAN_NS(Ptr) #include "xspan_fwd.h" #undef C diff --git a/src/util/xspan_impl_ptr_or_null.h b/src/util/xspan_impl_ptr_or_null.h index 8e16aa7b..20cbfe99 100644 --- a/src/util/xspan_impl_ptr_or_null.h +++ b/src/util/xspan_impl_ptr_or_null.h @@ -26,7 +26,7 @@ #pragma once -SPAN_NAMESPACE_BEGIN +XSPAN_NAMESPACE_BEGIN /************************************************************************* // PtrOrSpanOrNull @@ -56,31 +56,31 @@ public: assertInvariants(); } template - CSelf(const CSelf &other, SPAN_REQUIRES_CONVERTIBLE_A) + CSelf(const CSelf &other, XSPAN_REQUIRES_CONVERTIBLE_A) : ptr(other.ptr), base(other.base), size_in_bytes(other.size_in_bytes) { assertInvariants(); } // constructors from Span friends template - CSelf(const PtrOrSpan &other, SPAN_REQUIRES_CONVERTIBLE_A) + CSelf(const PtrOrSpan &other, XSPAN_REQUIRES_CONVERTIBLE_A) : ptr(other.ptr), base(other.base), size_in_bytes(other.size_in_bytes) { assertInvariants(); } template - CSelf(const Span &other, SPAN_REQUIRES_CONVERTIBLE_A) + CSelf(const Span &other, XSPAN_REQUIRES_CONVERTIBLE_A) : ptr(other.ptr), base(other.base), size_in_bytes(other.size_in_bytes) { assertInvariants(); } // assignment from Span friends template - SPAN_REQUIRES_CONVERTIBLE_R(Self &) + XSPAN_REQUIRES_CONVERTIBLE_R(Self &) operator=(const PtrOrSpan &other) { return assign(Self(other)); } template - SPAN_REQUIRES_CONVERTIBLE_R(Self &) + XSPAN_REQUIRES_CONVERTIBLE_R(Self &) operator=(const Span &other) { return assign(Self(other)); } @@ -107,13 +107,13 @@ inline typename PtrOrSpanOrNull::pointer raw_index_bytes(const PtrOrSpanOrNul // **************************************************************************/ -SPAN_NAMESPACE_END +XSPAN_NAMESPACE_END -#if !SPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION || 1 +#if !XSPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION || 1 -#define C SPAN_NS(PtrOrSpanOrNull) -#define D SPAN_NS(PtrOrSpan) -#define E SPAN_NS(Span) +#define C XSPAN_NS(PtrOrSpanOrNull) +#define D XSPAN_NS(PtrOrSpan) +#define E XSPAN_NS(Span) #include "xspan_fwd.h" #undef C #undef D diff --git a/src/util/xspan_impl_ptr_or_span.h b/src/util/xspan_impl_ptr_or_span.h index 6e37f4e7..9a13e085 100644 --- a/src/util/xspan_impl_ptr_or_span.h +++ b/src/util/xspan_impl_ptr_or_span.h @@ -26,7 +26,7 @@ #pragma once -SPAN_NAMESPACE_BEGIN +XSPAN_NAMESPACE_BEGIN /************************************************************************* // PtrOrSpan @@ -58,20 +58,20 @@ public: assertInvariants(); } template - CSelf(const CSelf &other, SPAN_REQUIRES_CONVERTIBLE_A) + CSelf(const CSelf &other, XSPAN_REQUIRES_CONVERTIBLE_A) : ptr(other.ensurePtr()), base(other.base), size_in_bytes(other.size_in_bytes) { assertInvariants(); } // constructors from Span friends template - CSelf(const Span &other, SPAN_REQUIRES_CONVERTIBLE_A) + CSelf(const Span &other, XSPAN_REQUIRES_CONVERTIBLE_A) : ptr(other.ensurePtr()), base(other.base), size_in_bytes(other.size_in_bytes) { assertInvariants(); } -#if SPAN_CONFIG_ENABLE_SPAN_CONVERSION +#if XSPAN_CONFIG_ENABLE_SPAN_CONVERSION template - CSelf(const PtrOrSpanOrNull &other, SPAN_REQUIRES_CONVERTIBLE_A) + CSelf(const PtrOrSpanOrNull &other, XSPAN_REQUIRES_CONVERTIBLE_A) : ptr(other.ensurePtr()), base(other.base), size_in_bytes(other.size_in_bytes) { assertInvariants(); } @@ -80,13 +80,13 @@ public: // assignment from Span friends // TODO: use Unchecked to avoid double checks in both constructor and assignment template - SPAN_REQUIRES_CONVERTIBLE_R(Self &) + XSPAN_REQUIRES_CONVERTIBLE_R(Self &) operator=(const Span &other) { return assign(Self(other)); } -#if SPAN_CONFIG_ENABLE_SPAN_CONVERSION +#if XSPAN_CONFIG_ENABLE_SPAN_CONVERSION template - SPAN_REQUIRES_CONVERTIBLE_R(Self &) + XSPAN_REQUIRES_CONVERTIBLE_R(Self &) operator=(const PtrOrSpanOrNull &other) { if (other.base == nullptr) return assign(Self(other.ptr, size_in_bytes, base)); @@ -95,15 +95,15 @@ public: #endif // nullptr - CSelf(std::nullptr_t) SPAN_DELETED_FUNCTION; - CSelf(std::nullptr_t, SpanSizeInBytes, const void *) SPAN_DELETED_FUNCTION; - CSelf(std::nullptr_t, SpanCount, const void *) SPAN_DELETED_FUNCTION; - CSelf(std::nullptr_t, size_type, const void *) SPAN_DELETED_FUNCTION; - Self &operator=(std::nullptr_t) SPAN_DELETED_FUNCTION; + CSelf(std::nullptr_t) XSPAN_DELETED_FUNCTION; + CSelf(std::nullptr_t, XSpanCount, const void *) XSPAN_DELETED_FUNCTION; + CSelf(std::nullptr_t, XSpanSizeInBytes, const void *) XSPAN_DELETED_FUNCTION; + CSelf(std::nullptr_t, size_type, const void *) XSPAN_DELETED_FUNCTION; + Self &operator=(std::nullptr_t) XSPAN_DELETED_FUNCTION; #if 0 // don't enable, this prevents generic usage - bool operator==(std::nullptr_t) const SPAN_DELETED_FUNCTION; - bool operator!=(std::nullptr_t) const SPAN_DELETED_FUNCTION; + bool operator==(std::nullptr_t) const XSPAN_DELETED_FUNCTION; + bool operator!=(std::nullptr_t) const XSPAN_DELETED_FUNCTION; #else bool operator==(std::nullptr_t) const { assertInvariants(); @@ -133,13 +133,13 @@ inline typename PtrOrSpan::pointer raw_index_bytes(const PtrOrSpan &a, siz // **************************************************************************/ -SPAN_NAMESPACE_END +XSPAN_NAMESPACE_END -#if !SPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION || 1 +#if !XSPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION || 1 -#define C SPAN_NS(PtrOrSpan) -#define D SPAN_NS(PtrOrSpanOrNull) -#define E SPAN_NS(Span) +#define C XSPAN_NS(PtrOrSpan) +#define D XSPAN_NS(PtrOrSpanOrNull) +#define E XSPAN_NS(Span) #include "xspan_fwd.h" #undef C #undef D diff --git a/src/util/xspan_impl_span.h b/src/util/xspan_impl_span.h index 3a382a38..7908931e 100644 --- a/src/util/xspan_impl_span.h +++ b/src/util/xspan_impl_span.h @@ -26,7 +26,7 @@ #pragma once -SPAN_NAMESPACE_BEGIN +XSPAN_NAMESPACE_BEGIN /************************************************************************* // Span @@ -48,7 +48,7 @@ private: #include "xspan_impl_common.h" public: // constructors from pointers - CSelf(pointer first) SPAN_DELETED_FUNCTION; + CSelf(pointer first) XSPAN_DELETED_FUNCTION; // constructors CSelf(const Self &other) @@ -56,37 +56,37 @@ public: assertInvariants(); } template - CSelf(const CSelf &other, SPAN_REQUIRES_CONVERTIBLE_A) + CSelf(const CSelf &other, XSPAN_REQUIRES_CONVERTIBLE_A) : ptr(other.ensurePtr()), base(other.ensureBase()), size_in_bytes(other.size_in_bytes) { assertInvariants(); } // constructors from Span friends -#if SPAN_CONFIG_ENABLE_SPAN_CONVERSION +#if XSPAN_CONFIG_ENABLE_SPAN_CONVERSION template - CSelf(const PtrOrSpanOrNull &other, SPAN_REQUIRES_CONVERTIBLE_A) + CSelf(const PtrOrSpanOrNull &other, XSPAN_REQUIRES_CONVERTIBLE_A) : ptr(other.ensurePtr()), base(other.ensureBase()), size_in_bytes(other.size_in_bytes) { assertInvariants(); } template - CSelf(const PtrOrSpan &other, SPAN_REQUIRES_CONVERTIBLE_A) + CSelf(const PtrOrSpan &other, XSPAN_REQUIRES_CONVERTIBLE_A) : ptr(other.ensurePtr()), base(other.ensureBase()), size_in_bytes(other.size_in_bytes) { assertInvariants(); } #endif // assignment from Span friends -#if SPAN_CONFIG_ENABLE_SPAN_CONVERSION +#if XSPAN_CONFIG_ENABLE_SPAN_CONVERSION // TODO: use Unchecked to avoid double checks in both constructor and assignment template - SPAN_REQUIRES_CONVERTIBLE_R(Self &) + XSPAN_REQUIRES_CONVERTIBLE_R(Self &) operator=(const PtrOrSpan &other) { if (other.base == nullptr) return assign(Self(other.ptr, size_in_bytes, base)); return assign(Self(other.ptr, other.size_in_bytes, other.base)); } template - SPAN_REQUIRES_CONVERTIBLE_R(Self &) + XSPAN_REQUIRES_CONVERTIBLE_R(Self &) operator=(const PtrOrSpanOrNull &other) { if (other.base == nullptr) return assign(Self(other.ptr, size_in_bytes, base)); @@ -95,15 +95,15 @@ public: #endif // nullptr - CSelf(std::nullptr_t) SPAN_DELETED_FUNCTION; - CSelf(std::nullptr_t, SpanSizeInBytes, const void *) SPAN_DELETED_FUNCTION; - CSelf(std::nullptr_t, SpanCount, const void *) SPAN_DELETED_FUNCTION; - CSelf(std::nullptr_t, size_type, const void *) SPAN_DELETED_FUNCTION; - Self &operator=(std::nullptr_t) SPAN_DELETED_FUNCTION; + CSelf(std::nullptr_t) XSPAN_DELETED_FUNCTION; + CSelf(std::nullptr_t, XSpanCount, const void *) XSPAN_DELETED_FUNCTION; + CSelf(std::nullptr_t, XSpanSizeInBytes, const void *) XSPAN_DELETED_FUNCTION; + CSelf(std::nullptr_t, size_type, const void *) XSPAN_DELETED_FUNCTION; + Self &operator=(std::nullptr_t) XSPAN_DELETED_FUNCTION; #if 0 // don't enable, this prevents generic usage - bool operator==(std::nullptr_t) const SPAN_DELETED_FUNCTION; - bool operator!=(std::nullptr_t) const SPAN_DELETED_FUNCTION; + bool operator==(std::nullptr_t) const XSPAN_DELETED_FUNCTION; + bool operator!=(std::nullptr_t) const XSPAN_DELETED_FUNCTION; #else bool operator==(std::nullptr_t) const { assertInvariants(); @@ -133,13 +133,13 @@ inline typename Span::pointer raw_index_bytes(const Span &a, size_t index, // **************************************************************************/ -SPAN_NAMESPACE_END +XSPAN_NAMESPACE_END -#if !SPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION || 1 +#if !XSPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION || 1 -#define C SPAN_NS(Span) -#define D SPAN_NS(PtrOrSpanOrNull) -#define E SPAN_NS(PtrOrSpan) +#define C XSPAN_NS(Span) +#define D XSPAN_NS(PtrOrSpanOrNull) +#define E XSPAN_NS(PtrOrSpan) #include "xspan_fwd.h" #undef C #undef D