drinkingtea/nostalgia
drinkingtea/nostalgia
2
0
Fork 0
Code Issues 6 Pull Requests Actions Releases 6 Activity

[ox/std] Enable unsafe buffer warnings

Browse Source
This commit is contained in:
Gary Talent 2024-11-26 21:59:26 -06:00
parent e44fa288fd
commit 9b8a8c4e46
24 changed files with 119 additions and 202 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
deps/ox/src/ox/std/CMakeLists.txt vendored
View File

@ -1,3 +1,9 @@
if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
# enable warnings
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wunsafe-buffer-usage")
endif()
if(OX_USE_STDLIB AND OX_ENABLE_TRACEHOOK)
add_library(
OxTraceHook SHARED

6
deps/ox/src/ox/std/algorithm.hpp vendored
View File

@ -8,6 +8,10 @@
#pragma once
#include "def.hpp"
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
namespace ox {
template<typename It, typename T>
@ -41,3 +45,5 @@ constexpr OutIt copy_n(It in, Size cnt, OutIt out) {
}
}
OX_CLANG_NOWARN_END

9
deps/ox/src/ox/std/array.hpp vendored
View File

@ -9,6 +9,7 @@
#pragma once
#include "bit.hpp"
#include "def.hpp"
#include "error.hpp"
#include "initializerlist.hpp"
#include "iterator.hpp"
@ -17,6 +18,8 @@
#include "types.hpp"
#include "utility.hpp"
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
namespace ox {
template<typename T, std::size_t ArraySize>
@ -35,6 +38,10 @@ class Array {
public:
constexpr Array() noexcept = default;
template<typename ...Args>
constexpr Array(Args ...list) noexcept: m_items{std::move(list)...} {
}
constexpr Array(std::initializer_list<T> list) noexcept;
constexpr Array(const Array &other);
@ -200,3 +207,5 @@ constexpr bool Array<T, ArraySize>::contains(const T &v) const {
}
}
OX_CLANG_NOWARN_END

7
deps/ox/src/ox/std/basestringview.hpp vendored
View File

@ -9,9 +9,12 @@
#pragma once
#include "bit.hpp"
#include "def.hpp"
#include "cstrops.hpp"
#include "iterator.hpp"
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
namespace ox::detail {
class BaseStringView {
@ -202,7 +205,7 @@ class BaseStringView {
}
[[nodiscard]]
constexpr auto operator[](std::size_t i) const noexcept {
constexpr auto &operator[](std::size_t i) const noexcept {
return m_str[i];
}
@ -215,3 +218,5 @@ class BaseStringView {
};
}
OX_CLANG_NOWARN_END

4
deps/ox/src/ox/std/buffer.hpp vendored
View File

@ -14,6 +14,8 @@
#include "vector.hpp"
#include "writer.hpp"
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
namespace ox {
extern template class Vector<char>;
@ -233,3 +235,5 @@ extern template class WriterT<BufferWriter>;
extern template class WriterT<CharBuffWriter>;
}
OX_CLANG_NOWARN_END

5
deps/ox/src/ox/std/cstrops.hpp vendored
View File

@ -8,9 +8,12 @@
#pragma once
#include "def.hpp"
#include "types.hpp"
#include "typetraits.hpp"
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
namespace ox {
template<typename T1, typename T2>
@ -113,3 +116,5 @@ constexpr int lastIndexOf(const auto &str, int character, std::size_t maxLen = 0
}
}
OX_CLANG_NOWARN_END

11
deps/ox/src/ox/std/def.hpp vendored
View File

@ -71,6 +71,17 @@ constexpr void oxAssert(const ox::Error&, const char*) noexcept {}
#define ox_alloca(size) __builtin_alloca(size)
#endif
#define OX_PRAGMA(x) _Pragma(#x)
#ifdef __clang__
#define OX_CLANG_NOWARN_BEGIN(warnoption) \
OX_PRAGMA(clang diagnostic push) \
OX_PRAGMA(clang diagnostic ignored #warnoption)
#define OX_CLANG_NOWARN_END OX_PRAGMA(clang diagnostic pop)
#else
#define OX_CLANG_NOWARN_BEGIN(warnoption)
#define OX_CLANG_NOWARN_END
#endif
/**
* @return an ox::MallocaPtr of the given type pointing to the requested size memory allocation
*/

4
deps/ox/src/ox/std/fmt.hpp vendored
View File

@ -25,6 +25,8 @@
#include "types.hpp"
#include "typetraits.hpp"
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
namespace ox {
namespace detail {
@ -225,3 +227,5 @@ constexpr Result<T> join(auto const&d, auto const&list) {
}
}
OX_CLANG_NOWARN_END

5
deps/ox/src/ox/std/heapmgr.cpp vendored
View File

@ -8,8 +8,11 @@
#include "assert.hpp"
#include "bit.hpp"
#include "def.hpp"
#include "heapmgr.hpp"
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
namespace ox::heapmgr {
static struct HeapSegment *volatile g_heapBegin = nullptr;
@ -142,3 +145,5 @@ void operator delete[](void *ptr, unsigned long int) noexcept {
}
#endif
OX_CLANG_NOWARN_END

3
deps/ox/src/ox/std/istring.hpp vendored
View File

@ -10,6 +10,7 @@
#include "array.hpp"
#include "concepts.hpp"
#include "def.hpp"
#include "cstrops.hpp"
#include "memops.hpp"
#include "error.hpp"
@ -175,7 +176,9 @@ constexpr Error IString<StrCap>::append(const char *str, std::size_t strLen) noe
strLen = cap() - currentLen;
err = OxError(1, "Insufficient space for full string");
}
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
ox::strncpy(m_buff.data() + currentLen, str, strLen);
OX_CLANG_NOWARN_END
// make sure last element is a null terminator
m_buff[currentLen + strLen] = 0;
m_size += strLen;

5
deps/ox/src/ox/std/iterator.hpp vendored
View File

@ -8,6 +8,7 @@
#pragma once
#include "def.hpp"
#include "error.hpp"
#include "math.hpp"
@ -39,6 +40,8 @@ struct contiguous_iterator_tag: public random_access_iterator_tag {
#include <iterator>
#endif
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
namespace ox {
template<typename Category, typename T, typename DiffType = std::ptrdiff_t,
@ -171,3 +174,5 @@ struct SpanIterator {
};
}
OX_CLANG_NOWARN_END

4
deps/ox/src/ox/std/memops.cpp vendored
View File

@ -10,6 +10,8 @@
#include "types.hpp"
#include "memops.hpp"
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
#ifndef OX_USE_STDLIB
#define ox_inhibit_loop_to_libcall __attribute__((__optimize__("-fno-tree-loop-distribute-patterns")))
@ -96,3 +98,5 @@ int memcmp(const void *ptr1, const void *ptr2, std::size_t size) noexcept {
}
}
OX_CLANG_NOWARN_END

5
deps/ox/src/ox/std/memops.hpp vendored
View File

@ -8,6 +8,7 @@
#pragma once
#include "def.hpp"
#include "types.hpp"
#include "typetraits.hpp"
@ -27,6 +28,8 @@ int memcmp(const void *ptr1, const void *ptr2, std::size_t size) noexcept;
}
#endif
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
namespace ox {
template<typename T1, typename T2>
@ -56,3 +59,5 @@ void *memsetElements(T *ptr, T val, std::size_t elements) noexcept {
}
}
OX_CLANG_NOWARN_END

5
deps/ox/src/ox/std/random.hpp vendored
View File

@ -9,9 +9,12 @@
#pragma once
#include "bit.hpp"
#include "def.hpp"
#include "stddef.hpp"
#include "types.hpp"
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
namespace ox {
using RandomSeed = uint64_t[2];
@ -51,3 +54,5 @@ constexpr uint64_t Random::gen() noexcept {
}
}
OX_CLANG_NOWARN_END

5
deps/ox/src/ox/std/stacktrace.cpp vendored
View File

@ -18,11 +18,14 @@
#endif
#endif
#include "def.hpp"
#include "defines.hpp"
#include "string.hpp"
#include "trace.hpp"
#include "vector.hpp"
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
namespace ox {
#if defined(OX_USE_STDLIB) && __has_include(<unistd.h>)
@ -100,3 +103,5 @@ void printStackTrace([[maybe_unused]]unsigned shave) noexcept {
}
}
OX_CLANG_NOWARN_END

9
deps/ox/src/ox/std/string.hpp vendored
View File

@ -13,6 +13,7 @@
#endif
#include "algorithm.hpp"
#include "def.hpp"
#include "ignore.hpp"
#include "memops.hpp"
#include "serialize.hpp"
@ -22,6 +23,8 @@
#include "strops.hpp"
#include "vector.hpp"
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
namespace ox {
template<typename Integer>
@ -496,12 +499,12 @@ constexpr char &BasicString<SmallStringSize_v>::operator[](std::size_t i) noexce
template<std::size_t SmallStringSize_v>
constexpr BasicString<SmallStringSize_v> BasicString<SmallStringSize_v>::substr(std::size_t pos) const noexcept {
return BasicString(m_buff.data() + pos, m_buff.size() - pos - 1);
return BasicString(&m_buff[pos], m_buff.size() - pos - 1);
}
template<std::size_t SmallStringSize_v>
constexpr BasicString<SmallStringSize_v> BasicString<SmallStringSize_v>::substr(std::size_t begin, std::size_t end) const noexcept {
const auto src = m_buff.data() + begin;
const auto src = &m_buff[begin];
const auto size = end - begin;
BasicString<SmallStringSize_v> out(size);
const auto buff = out.data();
@ -568,3 +571,5 @@ struct MaybeView<ox::BasicString<sz>> {
};
}
OX_CLANG_NOWARN_END

3
deps/ox/src/ox/std/stringview.hpp vendored
View File

@ -17,6 +17,8 @@
#include "maybeview.hpp"
#include "writer.hpp"
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
namespace ox {
template<std::size_t buffLen>
@ -116,3 +118,4 @@ constexpr ox::Result<int> atoi(ox::StringViewCR str) noexcept {
}
OX_CLANG_NOWARN_END

3
deps/ox/src/ox/std/strops.cpp vendored
View File

@ -6,6 +6,7 @@
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*/
#include "def.hpp"
#include "strops.hpp"
static_assert(ox::strcmp("asdf", "hijk") < 0, "asdf < hijk");
@ -17,7 +18,9 @@ static_assert(ox::strcmp("", "") == 0, "\"\" == \"\"");
static_assert([] {
auto testStr = "asdf";
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
return ox::strchr(testStr, 0, 4) == &testStr[4];
OX_CLANG_NOWARN_END
}(), "ox::strchr 0");
static_assert([] {

9
deps/ox/src/ox/std/strops.hpp vendored
View File

@ -9,18 +9,21 @@
#pragma once
#include "cstrops.hpp"
#include "def.hpp"
#include "error.hpp"
#include "math.hpp"
#include "stringview.hpp"
#include "types.hpp"
#include "vector.hpp"
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
namespace ox {
[[nodiscard]]
constexpr ox::StringView substr(ox::StringView const&str, std::size_t pos) noexcept {
if (str.len() >= pos) {
return {str.data() + pos, str.len() - pos};
return {&str[pos], str.len() - pos};
}
return {};
}
@ -28,7 +31,7 @@ constexpr ox::StringView substr(ox::StringView const&str, std::size_t pos) noexc
[[nodiscard]]
constexpr ox::StringView substr(ox::StringView const&str, std::size_t start, std::size_t end) noexcept {
if (str.len() >= start && end >= start) {
return {str.data() + start, end - start};
return {&str[start], end - start};
}
return {};
}
@ -113,3 +116,5 @@ constexpr ox::Result<std::size_t> lastIndexOf(ox::StringViewCR str, int characte
}
}
OX_CLANG_NOWARN_END

4
deps/ox/src/ox/std/test/tests.cpp vendored
View File

@ -121,7 +121,9 @@ static std::map<ox::StringView, ox::Error(*)()> tests = {
auto a1 = static_cast<char*>(ox::heapmgr::malloc(5));
auto a2 = static_cast<char*>(ox::heapmgr::malloc(5));
oxAssert(a1 >= buff.front().unwrap() && a1 < buff.back().unwrap(), "malloc is broken");
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
oxAssert(a2 >= buff.front().unwrap() && a2 < buff.back().unwrap() && a2 > a1 + 5, "malloc is broken");
OX_CLANG_NOWARN_END
ox::heapmgr::free(a1);
ox::heapmgr::free(a2);
return OxError(0);
@ -474,7 +476,9 @@ int main(int argc, const char **args) {
if (argc < 2) {
oxError("Must specify test to run");
}
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
auto const testName = args[1];
OX_CLANG_NOWARN_END
auto const func = tests.find(testName);
if (func != tests.end()) {
oxAssert(func->second(), "Test returned Error");

5
deps/ox/src/ox/std/uuid.hpp vendored
View File

@ -9,6 +9,7 @@
#pragma once
#include "bit.hpp"
#include "def.hpp"
#include "ignore.hpp"
#include "istring.hpp"
#include "buffer.hpp"
@ -18,6 +19,8 @@
#include "stringview.hpp"
#include "strops.hpp"
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
namespace ox {
using UUIDStr = ox::IString<36>;
@ -220,3 +223,5 @@ constexpr Error model(T *io, ox::CommonPtrWith<UUID> auto *obj) noexcept {
}
}
OX_CLANG_NOWARN_END

2
deps/ox/src/ox/std/vec.cpp vendored
View File

@ -14,7 +14,7 @@ namespace ox {
static_assert([] {
Vec2 v(1, 2);
return v.x == 1 && v.y == 2 && v[0] == 1 && v[1] == 2 && v.size() == 2;
return v.x == 1 && v.y == 2 && v.size() == 2;
}());
}

196
deps/ox/src/ox/std/vec.hpp vendored
View File

@ -34,112 +34,6 @@ class Vec2 {
float x = 0;
float y = 0;
template<typename RefType = value_type&, typename PtrType = value_type*, bool reverse = false>
struct iterator: public ox::Iterator<std::bidirectional_iterator_tag, value_type> {
private:
PtrType m_t = nullptr;
size_type m_offset = 0;
size_type m_max = 0;
public:
constexpr iterator() noexcept = default;
constexpr iterator(PtrType t, size_type offset, size_type max) noexcept {
m_t = t;
m_offset = offset;
m_max = max;
}
[[nodiscard]]
constexpr auto offset() const noexcept {
return m_offset;
}
constexpr iterator operator+(size_type s) const noexcept {
if constexpr(reverse) {
return iterator(m_t, ox::max<size_type>(m_offset - s, 0), m_max);
} else {
return iterator(m_t, ox::min<size_type>(m_offset + s, m_max), m_max);
}
}
constexpr typename ox::Iterator<std::bidirectional_iterator_tag, value_type>::difference_type
operator-(const iterator &other) const noexcept {
if constexpr(reverse) {
return m_offset + other.m_offset;
} else {
return m_offset - other.m_offset;
}
}
constexpr iterator operator-(size_type s) const noexcept {
if constexpr(reverse) {
return iterator(m_t, ox::min<size_type>(m_offset + s, m_max), m_max);
} else {
return iterator(m_t, ox::max<size_type>(m_offset - s, 0), m_max);
}
}
constexpr iterator &operator+=(size_type s) noexcept {
if constexpr(reverse) {
m_offset = ox::max<size_type>(m_offset - s, 0);
} else {
m_offset = ox::min(m_offset + s, m_max);
}
return *this;
}
constexpr iterator &operator-=(size_type s) noexcept {
if constexpr(reverse) {
m_offset = ox::min(m_offset + s, m_max);
} else {
m_offset = ox::max<size_type>(m_offset - s, 0);
}
return *this;
}
constexpr iterator &operator++() noexcept {
return operator+=(1);
}
constexpr iterator &operator--() noexcept {
return operator-=(1);
}
constexpr RefType operator*() const noexcept {
return m_t[m_offset];
}
constexpr RefType operator[](size_type s) const noexcept {
return m_t[s];
}
constexpr bool operator<(const iterator &other) const noexcept {
return m_offset < other.m_offset;
}
constexpr bool operator>(const iterator &other) const noexcept {
return m_offset > other.m_offset;
}
constexpr bool operator<=(const iterator &other) const noexcept {
return m_offset <= other.m_offset;
}
constexpr bool operator>=(const iterator &other) const noexcept {
return m_offset >= other.m_offset;
}
constexpr bool operator==(const iterator &other) const noexcept {
return m_t == other.m_t && m_offset == other.m_offset && m_max == other.m_max;
}
constexpr bool operator!=(const iterator &other) const noexcept {
return m_t != other.m_t || m_offset != other.m_offset || m_max != other.m_max;
}
};
constexpr Vec2() noexcept = default;
explicit constexpr Vec2(class Point const&pt) noexcept;
@ -159,85 +53,8 @@ class Vec2 {
}
#endif
[[nodiscard]]
constexpr iterator<> begin() noexcept {
return {start(), 0, size()};
}
[[nodiscard]]
constexpr iterator<> end() noexcept {
return {start(), size(), size()};
}
[[nodiscard]]
constexpr iterator<const value_type&, const value_type*> begin() const noexcept {
return {start(), 0, size()};
}
[[nodiscard]]
constexpr iterator<const value_type&, const value_type*> end() const noexcept {
return {start(), size(), size()};
}
[[nodiscard]]
constexpr iterator<value_type&, value_type*, true> rbegin() noexcept {
return {start(), size() - 1, size()};
}
[[nodiscard]]
constexpr iterator<value_type&, value_type*, true> rend() noexcept {
return {start(), ox::MaxValue<size_type>, size()};
}
[[nodiscard]]
constexpr iterator<const value_type&, const value_type*, true> rbegin() const noexcept {
return {start(), size() - 1, size()};
}
[[nodiscard]]
constexpr iterator<const value_type&, const value_type*, true> rend() const noexcept {
return {start(), ox::MaxValue<size_type>, size()};
}
constexpr auto &operator[](std::size_t i) noexcept {
if (std::is_constant_evaluated()) {
switch (i) {
case 0:
return x;
case 1:
return y;
default:
oxAssert(false, "Read past end of Vec2");
return y;
}
} else {
return start()[i];
}
}
constexpr const auto &operator[](std::size_t i) const noexcept {
if (std::is_constant_evaluated()) {
switch (i) {
case 0:
return x;
case 1:
return y;
default:
oxAssert(false, "Read past end of Vec2");
return y;
}
} else {
return start()[i];
}
}
constexpr auto operator==(const Vec2 &v) const noexcept {
for (auto i = 0u; i < v.size(); ++i) {
if ((*this)[i] != v[i]) {
return false;
}
}
return true;
return x == v.x && y == v.y;
}
constexpr auto operator!=(const Vec2 &v) const noexcept {
@ -292,17 +109,6 @@ class Vec2 {
y /= i;
return *this;
}
protected:
[[nodiscard]]
constexpr float *start() noexcept {
return&x;
}
[[nodiscard]]
constexpr const float *start() const noexcept {
return &x;
}
};
template<typename T>

4
deps/ox/src/ox/std/vector.hpp vendored
View File

@ -20,6 +20,8 @@
#include "types.hpp"
#include "utility.hpp"
OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
namespace ox {
namespace detail {
@ -709,3 +711,5 @@ constexpr auto alignOf(const Vector<T>&) noexcept {
}
}
OX_CLANG_NOWARN_END