fennec-org/fennec
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Fixed a bunch of compilation errors and warnings

Browse Source 
- Added frameworks for retrieving specific filesystem information for a target platform
This commit is contained in:
Medusa Slockbower
2025-07-10 01:10:13 -04:00
parent cc20af7504
commit 4c0d36c933
22 changed files with 510 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
include/fennec/fproc/io/common.h Normal file
View File

@@ -0,0 +1,31 @@
// =====================================================================================================================
// fennec, a free and open source game engine
// Copyright © 2025 Medusa Slockbower
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
#ifndef FENNEC_FPROC_IO_COMMON_H
#define FENNEC_FPROC_IO_COMMON_H
#include <fennec/fproc/strings/string.h>
namespace fennec
{
string getcwd();
}
#endif // FENNEC_FPROC_IO_COMMON_H

15
include/fennec/fproc/io/file.h
View File

@@ -21,7 +21,6 @@
#include <fennec/fproc/strings/cstring.h>
#include <fennec/fproc/strings/string.h>
#include <fennec/fproc/filesystem/path.h>
struct FILE;
@@ -32,10 +31,10 @@ namespace fennec
/// \brief Mode flags for opening a file
enum fmode : uint8_t
{
read = 0b00000001
, write = 0b00000010
, append = 0b00000100
, no_overwrite = 0b00001000
read = 0b00000001
, write = 0b00000010
, append = 0b00000100
, noexists = 0b00001000
};
class file
@@ -50,7 +49,8 @@ public:
/// \param mode the flags for opening the file
file(const cstring& path, fmode mode);
file(const string& path, fmode mode);
file(const path& path, fmode mode);
file(file&& file);
file(const file&) = delete;
@@ -59,7 +59,6 @@ public:
void open(const cstring& filename, fmode mode);
void open(const string& filename, fmode mode);
void open(const path& filename, fmode mode);
void close();
void commit();
@@ -89,6 +88,8 @@ public:
private:
FILE* _handle;
string _path;
fmode _mode;
};
}

2
include/fennec/fproc/strings/cstring.h
View File

@@ -24,6 +24,8 @@
#include <fennec/lang/assert.h>
#include <fennec/math/common.h>
namespace fennec
{

5
include/fennec/fproc/strings/string.h
View File

@@ -42,7 +42,7 @@ using string = _string<>;
/// \brief Struct for wrapping c-style strings
///
/// \details behaviour guarantees that the underlying string is null-terminated
template<typename AllocT = allocator<char>>
template<typename AllocT>
struct _string
{
public:
@@ -120,7 +120,6 @@ public:
/// \param i the index to access
/// \returns a reference to the character
constexpr char& operator[](int i) {
assertd(i >= 0 && i < size(), "Array Out of Bounds");
return _str[i];
}
@@ -284,7 +283,7 @@ public:
/// \param str the string to copy
/// \returns a reference to `this`
constexpr string& operator=(const string& str) {
if (str.size() > size()) string::resize(str.size());
if (str.size() > size()) resize(str.size());
fennec::memcpy(_str, str, str.size());
_str[str.size()] = '\0';
return *this;

2
include/fennec/lang/assert.h
View File

@@ -65,7 +65,7 @@
using assert_handler = void (*)(const char *, const char *, int , const char *);
extern void __assert_impl(const char* expression, const char* file, int line, const char* function, const char* desc);
void __assert_impl(const char* expression, const char* file, int line, const char* function, const char* desc);
// flagged unlikely to optimize branch prediction
#define assert(expression, description) \

1
include/fennec/lang/detail/__int.h
View File

@@ -28,6 +28,7 @@
#pragma push_macro("__cplusplus")
#undef __cplusplus
#include <stddef.h>
#include <stdint.h>
#pragma pop_macro("__cplusplus")

4
include/fennec/lang/detail/__numeric_transforms.h
View File

@@ -28,7 +28,7 @@ namespace fennec
namespace detail
{
template<typename> struct __make_unsigned : undefined_t {};
template<typename> struct __make_unsigned : type_transform<undefined_t> {};
template<> struct __make_unsigned<char_t> : type_transform<uchar_t> {};
template<> struct __make_unsigned<uchar_t> : type_transform<uchar_t> {};
@@ -43,7 +43,7 @@ template<> struct __make_unsigned<llong_t> : type_transform<ullong_t> {};
template<> struct __make_unsigned<ullong_t> : type_transform<ullong_t> {};
template<typename> struct __make_signed : undefined_t {};
template<typename> struct __make_signed : type_transform<undefined_t> {};
template<> struct __make_signed<char_t> : type_transform<schar_t> {};
template<> struct __make_signed<uchar_t> : type_transform<schar_t> {};

8
include/fennec/lang/intrinsics.h
View File

@@ -191,6 +191,14 @@
# define FENNEC_HAS_BUILTIN_IS_FINAL 0
#endif
// Inconsistent with dynamic intrinsics, requires a massive table for static intrinsics
#if __has_builtin(__is_fundamental)
# define FENNEC_HAS_BUILTIN_IS_FUNDAMENTAL 1
# define FENNEC_BUILTIN_IS_FUNDAMENTAL(arg) __is_fundamental(arg)
#else
# define FENNEC_HAS_BUILTIN_IS_FUNDAMENTAL 0
#endif
// Inconsistent without intrinsics
#if __has_builtin(__is_polymorphic)
# define FENNEC_HAS_BUILTIN_IS_POLYMORPHIC 1

17
include/fennec/lang/type_traits.h
View File

@@ -288,6 +288,21 @@ template<typename T> struct is_arithmetic
/// \tparam T type to check
template<typename T> constexpr bool_t is_arithmetic_v = is_arithmetic<T>::value;
// fennec::is_fundamental ==============================================================================================
///
/// \brief check if \p T is a fundamental type, i.e. arithmetic, void, or nullptr_t
/// \tparam T type to check
template<typename T> struct is_fundamental
: bool_constant<is_arithmetic_v<T> || is_void_v<T> || is_null_pointer_v<T>>{};
///
/// \brief shorthand for ```is_fundamental<T>::value```
/// \tparam T type to check
template<typename T> constexpr bool_t is_fundamental_v = is_fundamental<T>::value;
// fennec::is_same =====================================================================================================
///
@@ -306,7 +321,7 @@ template<typename T> struct is_same<T, T> : true_type {};
/// \tparam T type to check
template<typename T0, typename T1> constexpr bool_t is_same_v = is_same<T0, T1> {};
// fennec::can_convert =================================================================================================
// fennec::is_convertible ==============================================================================================
///
/// \brief check if type `T0` can be converted `T1`

7
include/fennec/lang/types.h
View File

@@ -203,6 +203,8 @@
#include <fennec/lang/detail/__int.h>
#include <fennec/lang/conditional_types.h>
namespace fennec
{
// Basic Types =========================================================================================================
@@ -253,12 +255,7 @@ namespace fennec
template<typename...> using void_t = void; ///< \brief Void type used for SFINAE
/// @}
}
#include <fennec/lang/conditional_types.h>
namespace fennec
{
// Sized Arithmetic Types ==============================================================================================

4
include/fennec/math/common.h
View File

@@ -271,6 +271,8 @@
#include <fennec/math/detail/__math.h>
#include <fennec/lang/limits.h>
#include <fennec/math/vector.h>
#if _MSC_VER
@@ -462,7 +464,7 @@ constexpr vector<genType, i...> trunc(const vector<genType, i...>& x) {
/// \param x input value
template<typename genType>
constexpr genType roundEven(genType x) {
static const genType e = std::numeric_limits<genType>::epsilon();
static const genType e = numeric_limits<genType>::epsilon();
int I = static_cast<int>(x);
genType i = static_cast<genType>(I);
genType f = x - i;

201
include/fennec/memory/allocator.h
View File

@@ -1,4 +1,4 @@
2// =====================================================================================================================
// =====================================================================================================================
// fennec, a free and open source game engine
// Copyright (C) 2025 Medusa Slockbower
//
@@ -33,15 +33,22 @@
#define FENNEC_MEMORY_ALLOCATOR_H
#include <fennec/memory/ptr_traits.h>
#include <fennec/memory/new.h>
#include <fennec/lang/conditional_types.h>
#include <fennec/lang/numeric_transforms.h>
#include <fennec/lang/types.h>
#include <fennec/lang/type_traits.h>
#include <fennec/math/ext/constants.h>
#include <fennec/math/common.h>
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wchanges-meaning"
#endif
namespace fennec
{
@@ -177,14 +184,92 @@ public:
}
/// \brief Allocate a block of memory large enough to hold `n` elements of type `T`
constexpr T* allocate(size_t n) {
return ::operator new(n * sizeof(T));
constexpr T* allocate(size_t n) {
return static_cast<T*>(::operator new(n * sizeof(T)));
}
/// \brief Allocate a block of memory large enough to hold `n` elements of type `T`
constexpr T* allocate(size_t n, align_t align) {
return static_cast<T*>(::operator new(n * sizeof(T), align));
}
/// \brief Deallocate a block of memory with type `T`
constexpr void deallocate(T* ptr) {
return ::operator delete(ptr);
}
/// \brief Deallocate a block of memory with type `T`
constexpr void deallocate(T* ptr, align_t align) {
return ::operator delete(ptr, align);
}
};
///
/// \brief Allocator implementation, uses `new` and `delete` operators.
/// \tparam T The data type to allocate
template<typename T>
class allocator<T[]>
{
public:
/// \brief Alias for the data type used for metaprogramming
using value_t = T;
/// \brief Metaprogramming utility to rebind an allocator to a different data type
template<typename R> using rebind = allocator<R>;
/// \brief Default Constructor
constexpr allocator() = default;
/// \brief Default Destructor
constexpr ~allocator() = default;
/// \brief Copy Constructor
constexpr allocator(const allocator&) = default;
/// \brief Copy Assignment
constexpr allocator& operator=(const allocator&) = default;
/// \brief Equality operator
constexpr bool_t operator==(const allocator&) {
return true;
}
/// \brief Inequality operator
constexpr bool_t operator!=(const allocator&) {
return false;
}
/// \brief Equality operator for allocators of same type but with different data type
template<typename U> constexpr bool_t operator==(const allocator<U>&) {
return true;
}
/// \brief Inequality operator for allocators of same type but with different data type
template<typename U> constexpr bool_t operator!=(const allocator<U>&) {
return true;
}
/// \brief Allocate a block of memory large enough to hold `n` elements of type `T`
constexpr T* allocate(size_t n) {
return static_cast<T*>(::operator new[](n * sizeof(T)));
}
/// \brief Allocate a block of memory large enough to hold `n` elements of type `T`
constexpr T* allocate(size_t n, align_t align) {
return static_cast<T*>(::operator new[](n * sizeof(T), align));
}
/// \brief Deallocate a block of memory with type `T`
constexpr void deallocate(T* ptr) {
return ::operator delete[](ptr);
}
/// \brief Deallocate a block of memory with type `T`
constexpr void deallocate(T* ptr, align_t align) {
return ::operator delete[](ptr, align);
}
};
@@ -211,6 +296,9 @@ public:
/// \brief diff type definition for ptr_traits
using diff_t = ptrdiff_t;
// Cosntructors ========================================================================================================
///
/// \brief Default Constructor, initializes internal data to `null` and the capacity to `0`
constexpr allocation() noexcept
@@ -235,6 +323,24 @@ public:
fennec::memcpy(_data, data, n);
}
///
/// \brief Sized Constructor, initializes the allocation with a block of size `n * sizeof(T)` bytes
/// \param n The number of elements of type `T` to allocate for
constexpr allocation(size_t n, align_t align) noexcept
: _data(nullptr), _capacity(0), _alignment(zero<align_t>()) {
allocate(n, align);
}
///
/// \brief Buffer Copy Constructor, initializes the allocation with a block of size `n * sizeof(T)` bytes.
/// Then, the contents of data are copied into the allocation.
/// \param data the buffer to copy
/// \param n the number of elements
constexpr allocation(const T* data, size_t n, align_t align)
: allocation(n, align) {
fennec::memcpy(_data, data, n);
}
///
/// \brief Allocator Constructor
/// \param alloc The allocation object to copy.
@@ -268,6 +374,30 @@ public:
fennec::memcpy(_data, data, n);
}
///
/// \brief Sized Allocator Constructor
/// \param n The number of elements of type `T` to allocate for
/// \param alloc The allocation object to copy.
///
/// \details This constructor should be used when the type `AllocT` needs internal data.
constexpr allocation(size_t n, align_t align, const alloc_t& alloc) noexcept
: _alloc(alloc), _data(nullptr), _capacity(0), _alignment(zero<align_t>()) {
allocate(n, align);
}
///
/// \brief Buffer Copy Allocator Constructor, initializes the allocation with a block of size `n * sizeof(T)` bytes.
/// Then, the contents of data are copied into the allocation.
/// \param data the buffer to copy
/// \param n the number of elements
/// \param alloc The allocation object to copy.
///
/// \details This constructor should be used when the type `AllocT` needs internal data.
constexpr allocation(const T* data, size_t n, align_t align, const alloc_t& alloc)
: allocation(n, align, alloc) {
fennec::memcpy(_data, data, n);
}
///
/// \brief Copy Constructor, creates an allocation of equal size and performs a byte-wise copy
/// \param alloc The allocation to copy
@@ -292,6 +422,9 @@ public:
if (_data) _alloc.deallocate(_data);
}
// Assignment ==========================================================================================================
///
/// \brief Copy Assignment Operator
/// \param alloc the allocation to copy
@@ -319,37 +452,45 @@ public:
return *this;
}
// Allocation and Deallocation =========================================================================================
///
/// \brief Allocate a block of memory for the allocation.
/// If there is already an allocated block of memory, the previous allocation is released.
/// \param n The number of elements of type `T` to allocate for
constexpr void allocate(size_t n) noexcept {
if (_data) {
_alloc.deallocate(_data);
}
constexpr void allocate(size_t n, align_t align = zero<align_t>()) noexcept {
deallocate();
_data = _alloc.allocate(_capacity = n);
if (_alignment != zero<align_t>()) {
_data = _alloc.allocate(_capacity = n, _alignment = align);
} else {
_data = _alloc.allocate(_capacity = n);
}
}
///
/// \brief Release the block of memory.
constexpr void release() noexcept
{
constexpr void deallocate() noexcept {
if (_data) {
_alloc.deallocate(_data);
if (_alignment != zero<align_t>()) {
_alloc.deallocate(_data, _alignment);
} else {
_alloc.deallocate(_data);
}
}
_data = nullptr;
_capacity = 0;
_alignment = zero<align_t>();
}
///
/// \brief Reallocate the block with a new size.
/// Contents are copied to the new allocation.
constexpr void reallocate(size_t n) noexcept
{
constexpr void reallocate(size_t n, align_t align = zero<align_t>()) noexcept {
if (_data == nullptr) {
return _alloc.allocate(_capacity = n);
allocate(n, align);
}
value_t* old = _data;
@@ -359,6 +500,27 @@ public:
_capacity = n;
}
// Access ==============================================================================================================
constexpr value_t& operator[](size_t i) {
assertd(i < size(), "Array Out of Bounds");
return _data[i];
}
constexpr const value_t operator[](size_t i) const requires requires { is_fundamental_v<value_t> == true; } {
assertd(i < size(), "Array Out of Bounds");
return _data[i];
}
constexpr const value_t& operator[](size_t i) const requires requires { is_fundamental_v<value_t> == false; } {
assertd(i < size(), "Array Out of Bounds");
return _data[i];
}
// Modification ========================================================================================================
///
/// \brief Clear the block of memory, setting all bytes to 0.
constexpr void clear() noexcept {
@@ -387,11 +549,16 @@ public:
}
private:
alloc_t _alloc; // Allocator object
value_t* _data; // Handle for the memory block
size_t _capacity; // Capacity of the memory block in elements.
alloc_t _alloc; // Allocator object
value_t* _data; // Handle for the memory block
size_t _capacity; // Capacity of the memory block in elements.
align_t _alignment; // Alignment information
};
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
}
#endif // FENNEC_MEMORY_ALLOCATOR_H

2
include/fennec/memory/detail/__ptr_traits.h
View File

@@ -36,7 +36,7 @@ struct __ptr_get_element : first_element<ClassT> { }; // Default case, return th
// overload for types that have a member `ClassT::element_t`
template<typename ClassT> requires requires { typename ClassT::element_t; }
struct __ptr_get_element { using type = typename ClassT::element_t; };
struct __ptr_get_element<ClassT, ClassT> { using type = typename ClassT::element_t; };
// helper for generating `pointer_to`
template<typename PtrT, typename ElemT, bool_t = is_void_v<ElemT>>

5
include/fennec/memory/detail/__string.h
View File

@@ -19,10 +19,6 @@
#ifndef FENNEC_MEMORY_DETAIL_MEMORY_H
#define FENNEC_MEMORY_DETAIL_MEMORY_H
#include <fennec/lang/types.h>
// deprecated, switched to ISO C implementation
// see https://git.mslockbo.org/mslockbo/fennec/src/commit/0eeb7ae3cff9d78e98dc5d9fc09bcb98b10986b9 for previous
// implementation
@@ -39,6 +35,7 @@
#pragma push_macro("__cplusplus")
#undef __cplusplus
#include <string.h>
#include <wchar.h>
#pragma pop_macro("__cplusplus")
#if __GNUC__

31
include/fennec/memory/new.h
View File

@@ -49,6 +49,10 @@ struct nothrow_t
explicit nothrow_t() noexcept { }
};
///
/// \returns the page size for the current environment
size_t pagesize();
template<typename TypeT> void construct(TypeT* ptr) {
ptr->TypeT();
}
@@ -71,4 +75,31 @@ template<typename TypeT> void destruct(TypeT* ptr) {
}
void* operator new (fennec::size_t size);
void* operator new[](fennec::size_t size);
void* operator new (fennec::size_t size, const fennec::nothrow_t&);
void* operator new[](fennec::size_t size, const fennec::nothrow_t&);
void* operator new (fennec::size_t size, fennec::align_t align);
void* operator new[](fennec::size_t size, fennec::align_t align);
void* operator new (fennec::size_t size, fennec::align_t align, const fennec::nothrow_t&);
void* operator new[](fennec::size_t size, fennec::align_t align, const fennec::nothrow_t&);
void operator delete (void* ptr) noexcept;
void operator delete[](void* ptr) noexcept;
void operator delete (void* ptr, fennec::size_t) noexcept;
void operator delete[](void* ptr, fennec::size_t) noexcept;
void operator delete (void* ptr, const fennec::nothrow_t&) noexcept;
void operator delete[](void* ptr, const fennec::nothrow_t&) noexcept;
void operator delete (void* ptr, fennec::size_t, const fennec::nothrow_t&) noexcept;
void operator delete[](void* ptr, fennec::size_t, const fennec::nothrow_t&) noexcept;
void operator delete (void* ptr, fennec::align_t) noexcept;
void operator delete[](void* ptr, fennec::align_t) noexcept;
void operator delete (void* ptr, fennec::size_t, fennec::align_t) noexcept;
void operator delete[](void* ptr, fennec::size_t, fennec::align_t) noexcept;
void operator delete (void* ptr, fennec::align_t, const fennec::nothrow_t&) noexcept;
void operator delete[](void* ptr, fennec::align_t, const fennec::nothrow_t&) noexcept;
#endif // FENNEC_MEMORY_NEW_H