mirrors/pound-emu_pound
0
0
Fork 0
mirror of https://github.com/pound-emu/pound.git synced 2025-12-13 13:37:02 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

HOPEFULLY NOW IT WILL WORK I HATE NT I HATE NT I HATE NT

Browse source
This commit is contained in:
ownedbywuigi 2025-07-08 04:22:29 +01:00
parent 982c0e9cd4
commit b7fc40f4f6
3 changed files with 4 additions and 3 deletions
Download patch file Download diff file Expand all files Collapse all files

4
core/memory/arena.cpp
View file

@ -1,6 +1,6 @@
#include "arena.h"
#include "Base/Assert.h"
#include "sys/mman.h" // Required for mmap and MAP_FAILED
#include "sys/mman.h"
// Memory::Arena Memory::arena_init() {
// // TODO(GloriousTaco): The line below is stupidly unsafe. Replace malloc with mmap() and check the return value.
@ -27,7 +27,7 @@ Memory::Arena Memory::arena_init() {
};
return arena;
}
// new more memsafe code (ownedbywuigi)
// new more memsafe code (ownedbywuigi) (i give up on windows compatibility for now, will stick to the old unsafe code)
const uint8_t* Memory::arena_allocate(Memory::Arena* arena,
const std::size_t size) {

52
core/sys/mman.h Normal file
View file

@ -0,0 +1,52 @@
// mman.h
// only there for Windows compatibility
#ifndef MMAN_H
#define MMAN_H
#if defined(__linux__) || defined(__APPLE__)
// Linux or macOS: Use standard sys/mman.h
#include <sys/mman.h>
#else
// Windows: Define mmap, munmap, and MAP_FAILED
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#define MAP_FAILED ((void*)-1)
// Protection and flag constants (minimal subset for your use case)
#define PROT_READ 0x1
#define PROT_WRITE 0x2
#define MAP_PRIVATE 0x2
#define MAP_ANONYMOUS 0x20
// mmap equivalent using VirtualAlloc
inline void* mmap(void* addr, size_t length, int prot, int flags, int fd, off_t offset) {
(void)addr; // Ignored (VirtualAlloc doesn't support specific address)
(void)flags; // Ignored (simplified for anonymous mapping)
(void)fd; // Ignored (no file mapping)
(void)offset; // Ignored (no file mapping)
DWORD protect = 0;
if (prot & PROT_READ && prot & PROT_WRITE) {
protect = PAGE_READWRITE;
} else if (prot & PROT_READ) {
protect = PAGE_READONLY;
} else {
return MAP_FAILED; // Unsupported protection
}
void* ptr = VirtualAlloc(nullptr, length, MEM_COMMIT | MEM_RESERVE, protect);
return ptr ? ptr : MAP_FAILED;
}
// munmap equivalent using VirtualFree
inline int munmap(void* addr, size_t length) {
(void)length; // Ignored (VirtualFree doesn't need length for committed memory)
BOOL result = VirtualFree(addr, 0, MEM_RELEASE);
return result ? 0 : -1; // Return 0 on success, -1 on failure
}
#endif
#endif // MMAN_H