GameModding
/
lightningbolt
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Make codebase tabs

This commit is contained in:
Lily Tsuru 2023-11-19 20:24:40 -05:00
parent eeb69fe0df
commit fbe24aa0f8
8 changed files with 88 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
.editorconfig Normal file
View File

@ -0,0 +1,11 @@
root = true
[*]
end_of_line = lf
insert_final_newline = true
indent_style = tab
indent_size = 4
# specifically for YAML
[{yml, yaml}]
indent_style = space

28
lib/base/MmapFile.hpp
View File

@ -7,22 +7,22 @@
namespace lightningbolt {
/// A read-only file opened via memory mapping.
/// On POSIX systems, we use mmap(2). Etc etc.
struct MmapFile {
MmapFile();
~MmapFile();
/// A read-only file opened via memory mapping.
/// On POSIX systems, we use mmap(2). Etc etc.
struct MmapFile {
MmapFile();
~MmapFile();
// Opens for read-only mode.
ErrorOr<void> Open(const fs::path& path);
void Close();
// Opens for read-only mode.
ErrorOr<void> Open(const fs::path& path);
void Close();
u8* GetMapping() const;
usize GetMappingSize() const;
u8* GetMapping() const;
usize GetMappingSize() const;
private:
struct Impl;
Unique<Impl> impl;
};
private:
struct Impl;
Unique<Impl> impl;
};
}

84
lib/base/MmapFile.linux.cpp
View File

@ -10,57 +10,57 @@ namespace lightningbolt {
struct MmapFile::Impl {
~Impl() {
Close();
}
~Impl() {
Close();
}
void Close() {
if(mapping) {
munmap(mapping, mappingSize);
mapping = nullptr;
mappingSize = 0;
}
}
void Close() {
if(mapping) {
munmap(mapping, mappingSize);
mapping = nullptr;
mappingSize = 0;
}
}
ErrorOr<void> Open(const fs::path& path) {
int fd = open(path.string().c_str(), O_RDONLY);
ErrorOr<void> Open(const fs::path& path) {
int fd = open(path.string().c_str(), O_RDONLY);
// Error opening file.
if(fd == -1)
return std::error_code{errno, std::system_category()};
// Error opening file.
if(fd == -1)
return std::error_code{errno, std::system_category()};
{
auto last = lseek64(fd, 0, SEEK_END);
mappingSize = lseek64(fd, 0, SEEK_CUR);
lseek64(fd, last, SEEK_SET);
}
{
auto last = lseek64(fd, 0, SEEK_END);
mappingSize = lseek64(fd, 0, SEEK_CUR);
lseek64(fd, last, SEEK_SET);
}
mapping = static_cast<u8*>(mmap(nullptr, mappingSize, PROT_READ, MAP_PRIVATE, fd, 0));
if(mapping == static_cast<u8*>(MAP_FAILED)) {
mappingSize = 0;
return std::error_code{errno, std::system_category()};
}
mapping = static_cast<u8*>(mmap(nullptr, mappingSize, PROT_READ, MAP_PRIVATE, fd, 0));
if(mapping == static_cast<u8*>(MAP_FAILED)) {
mappingSize = 0;
return std::error_code{errno, std::system_category()};
}
// Once the mapping has successfully been created
// we can close the file descriptor instead of needing
// to remember it (the kernel will do so for us.)
close(fd);
// Once the mapping has successfully been created
// we can close the file descriptor instead of needing
// to remember it (the kernel will do so for us.)
close(fd);
// No error.
return {};
}
// No error.
return {};
}
u8* GetMapping() const {
return mapping;
}
u8* GetMapping() const {
return mapping;
}
usize GetMappingSize() const {
return mappingSize;
}
usize GetMappingSize() const {
return mappingSize;
}
private:
u8* mapping;
usize mappingSize;
};
private:
u8* mapping;
usize mappingSize;
};
} // namespace lightningbolt

88
lib/base/OffsetPtr.hpp
View File

@ -1,88 +0,0 @@
// Copyright 2023 The LightningBolt Authors
// SPDX-License-Identifier: MIT
#pragma once
#include <bit>
#include <base/Types.hpp>
#include <type_traits>
#include <span>
namespace lightningbolt {
namespace detail {
template <class NativeT, class OffsetType>
constexpr NativeT* CreatePointerFromAddend(void* BasePointer, OffsetType addend) noexcept {
return std::bit_cast<NativeT*>(static_cast<char*>(BasePointer) + addend);
}
} // namespace detail
/// An "auto-resolving" semi-sweet (/s) pointer type.
/// This is designed to allow resolving offsets in data for
/// games written before 64-bit pointers were common/used at all.
/// This allows looking up data a lot easier :)
///
/// [NativeT] is the type of data this would point to
/// [OffsetType] is the type of data the "pointer" is repressented as
template <class NativeT, class OffsetType = u32>
struct OffsetPtr final {
using Type = std::remove_cvref_t<NativeT>;
using Pointer = Type*;
using ConstPointer = const Type*;
/// Set the offset. Duh!
constexpr void Set(OffsetType newOffset) noexcept { rawOffset = newOffset; }
[[nodiscard]] constexpr OffsetType Raw() const noexcept { return rawOffset; }
[[nodiscard]] constexpr Pointer operator()(void* baseAddr) const noexcept {
// While yucky, it should show problem areas which aren't checking things
// immediately rather than read invalid data that might do much worse.
if(rawOffset == 0)
return nullptr;
return detail::CreatePointerFromAddend<Type>(baseAddr, rawOffset);
}
template<class NativeU>
constexpr OffsetPtr<NativeU, OffsetType>& PtrCast() {
// Safety: The data layout of OffsetPtr<> stays
// the exact same regardless of the result type, therefore
// even though this is *techinically* UB (? using bit_cast it shouldn't be ?),
// this isn't problematic
return *std::bit_cast<OffsetPtr<NativeU, OffsetType>*>(this);
}
private:
OffsetType rawOffset;
};
/// Like OffsetPtr<T> but for arrays of data
template <class NativeT, class OffsetType = u32>
struct OffsetArrayPtr final {
using Type = std::remove_cvref_t<NativeT>;
using Pointer = Type*;
using ConstPointer = const Type*;
using Span = std::span<NativeT>;
/// Set the offset. Duh!
constexpr void Set(OffsetType newOffset) noexcept { rawOffset = newOffset; }
[[nodiscard]] constexpr OffsetType Raw() const noexcept { return rawOffset; }
[[nodiscard]] constexpr Span operator()(void* baseAddr, OffsetType length) const noexcept {
// While yucky, it should show problem areas which aren't checking things
// immediately rather than read invalid data that might do much worse.
if(rawOffset == 0 || length == 0)
return {};
return { detail::CreatePointerFromAddend<Type>(baseAddr, rawOffset), length };
}
private:
OffsetType rawOffset;
};
} // namespace ssxtools::core

2
lib/base/Types.hpp
View File

@ -23,7 +23,7 @@ using usize = std::size_t;
using isize = std::intptr_t;
namespace lightningbolt {
namespace fs = std::filesystem;
namespace fs = std::filesystem;
template <class T, class Deleter = std::default_delete<T>>
using Unique = std::unique_ptr<T, Deleter>;

30
lib/structs/BoltStructs.hpp
View File

@ -9,7 +9,7 @@ namespace lightningbolt {
namespace elf {
/// Table entry in the ELF. We use this to create file names.
/// Table entry in the ELF. We use this to create file names.
struct [[gnu::packed]] BoltTableEntry {
/// Pointer to filename. Should be adjusted
u32 filenamePtr;
@ -17,21 +17,19 @@ namespace lightningbolt {
u16 groupId; // (entryId & 0xff00)
};
/// Offsets in the ELF to the table.
struct BoltTableOffsets {
u32 usTable;
};
/// Offsets in the ELF to the table.
struct BoltTableOffsets {
u32 usTable;
};
/// Convert a address to ELF file offset.
constexpr u32 AddressToElfFileOffset(u32 address) {
constexpr u32 LoadAddress = 0x00100000;
constexpr u32 SectionOffset = 0x80;
return (address - LoadAddress) + SectionOffset;
}
/// Convert a address to ELF file offset.
constexpr u32 AddressToElfFileOffset(u32 address) {
constexpr u32 LoadAddress = 0x00100000;
constexpr u32 SectionOffset = 0x80;
return (address - LoadAddress) + SectionOffset;
}
static constexpr BoltTableOffsets BoltTableOffsets = {
.usTable = AddressToElfFileOffset(0x0033d400)
};
static constexpr BoltTableOffsets BoltTableOffsets = { .usTable = AddressToElfFileOffset(0x0033d400) };
} // namespace elf
@ -51,8 +49,8 @@ namespace lightningbolt {
u32 groupSize;
u32 groupOffset;
// PS2 pointer padding; bolt library stuffs something here
u32 pad;
// PS2 pointer padding; bolt library stuffs something here
u32 pad;
u32 EntryCount() {
// Special case: 0x0 == 256 entries.