Merge pull request #1885 from nicolasnoble/bundle

Bunch of changes all around.

Author: nicolasnoble

src/core/psxemulator.cc

@@ -90,7 +90,7 @@ void PCSX::Emulator::setLua() {
             return L.error("t_ expects a string");
         }
         auto str = L.tostring(1);
-        L.push(g_system->getStr(djbHash::hash(str), str.c_str()));
+        L.push(g_system->getStr(djb::hash(str), str.c_str()));
         return 1;
     });
     L.load("ffi = require('ffi')", "internal:setffi.lua");

src/core/system.cc

@@ -232,7 +232,7 @@ bool PCSX::System::loadLocale(const std::string& name, const std::filesystem::pa
                                 if (!currentString.empty() && !fuzzy) locale[hashValue] = currentString;
                                 break;
                             case WAITING_MSGSTRTOKEN:
-                                hashValue = djbHash::hash(currentString);
+                                hashValue = djb::hash(currentString);
                                 break;
                         }
                         currentString = "";

src/core/system.h

@@ -291,8 +291,8 @@ extern System *g_system;
 
 // i18n macros
 // Normal string lookup to const char *
-#define _(str) PCSX::g_system->getStr(PCSX::djbHash::ctHash(str), str)
+#define _(str) PCSX::g_system->getStr(PCSX::djb::ctHash(str), str)
 // Formatting string lookup to use with fmt::format or fmt::printf
-#define f_(str) fmt::runtime(PCSX::g_system->getStr(PCSX::djbHash::ctHash(str), str))
+#define f_(str) fmt::runtime(PCSX::g_system->getStr(PCSX::djb::ctHash(str), str))
 // Lambda string lookup to use with static arrays of strings
-#define l_(str) []() { return PCSX::g_system->getStr(PCSX::djbHash::ctHash(str), str); }
+#define l_(str) []() { return PCSX::g_system->getStr(PCSX::djb::ctHash(str), str); }

src/lua/extra.cc

@@ -28,6 +28,7 @@
 #include "lua/luawrapper.h"
 #include "support/file.h"
 #include "support/strings-helpers.h"
+#include "support/djbhash.h"
 #include "support/zip.h"
 
 namespace {
@@ -81,6 +82,30 @@ PCSX::File* load(std::string_view name, std::string_view from, bool inArchives =
     return new PCSX::PosixFile(absolutePath);
 }
 
+uint64_t djbHash(const char* str, size_t len) {
+    return PCSX::djb::hash(str, len);
+}
+
+template <typename T, size_t S>
+void registerSymbol(PCSX::Lua L, const char (&name)[S], const T ptr) {
+    L.push<S>(name);
+    L.push((void*)ptr);
+    L.settable();
+}
+
+#define REGISTER(L, s) registerSymbol(L, #s, s)
+
+void registerAllSymbols(PCSX::Lua L) {
+    L.getfieldtable("_CLIBS", LUA_REGISTRYINDEX);
+    L.push("SUPPORT_EXTRA");
+    L.newtable();
+
+    REGISTER(L, djbHash);
+
+    L.settable();
+    L.pop();
+}
+
 }  // namespace
 
 PCSX::ZipArchive& PCSX::LuaFFI::addArchive(Lua L, IO<File> file) {
@@ -138,6 +163,7 @@ void PCSX::LuaFFI::open_extra(Lua L) {
     static const char* extra = (
 #include "lua/extra.lua"
     );
+    registerAllSymbols(L);
     L.load(pprint, "third_party:pprint.lua/pprint.lua");
     L.load(pprint_internals, "third_party:pprint.lua/pprint-internals.lua");
     L.load(reflectFFI, "third_party:ffi-reflect/reflect.lua");

src/lua/extra.lua

@@ -15,6 +15,13 @@
 --   along with this program; if not, write to the
 --   Free Software Foundation, Inc.,
 --   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+ffi.cdef [[
+uint64_t djbHash(const char* str, size_t len);
+]]
+
+local C = ffi.load 'SUPPORT_EXTRA'
+
 Support.extra = {
 
     loadfile = function(name) return loadstring(Support._internal.loadfile(name), '@' .. name) end,
@@ -33,5 +40,8 @@ Support.extra = {
         error('FFI call failed in ' .. name .. ': ' .. ret)
     end,
 
+    djbHash = function(str)
+        return C.djbHash(str, #str)
+    end,
 }
 -- )EOF"

src/lua/fileffi-cdef.lua

@@ -89,8 +89,11 @@ LuaFile* dupFile(LuaFile*);
 
 LuaFile* zReader(LuaFile*, int64_t size, bool raw);
 
+LuaSlice* createEmptySlice();
 uint64_t getSliceSize(LuaSlice*);
 const void* getSliceData(LuaSlice*);
+void* getSliceMutableData(LuaSlice*);
+void resizeSlice(LuaSlice* slice, uint32_t size);
 void destroySlice(LuaSlice*);
 
 LuaFile* mem4g();

src/lua/fileffimeta.lua

@@ -27,12 +27,28 @@ local sliceMeta = {
             return buffer[index]
         elseif index == 'data' then
             return C.getSliceData(slice._wrapper)
+        elseif index == 'mutable' then
+            return C.getSliceMutableData(slice._wrapper)
         elseif index == 'size' then
             return tonumber(C.getSliceSize(slice._wrapper))
+        elseif index == 'resize' then
+            return function(slice, size)
+                C.resizeSlice(slice._wrapper, size)
+            end
         end
         error('Unknown index `' .. index .. '` for LuaSlice')
     end,
-    __newindex = function(slice, index, value) end,
+    __newindex = function(slice, index, value)
+        if type(index) == 'number' and index >= 0 and index < C.getSliceSize(slice._wrapper) then
+            local data = C.getSliceMutableData(slice._wrapper)
+            local buffer = ffi.cast('uint8_t*', data)
+            buffer[index] = value
+        elseif index == 'size' then
+            C.resizeSlice(slice._wrapper, value)
+        else
+            error('Unknown or immutable index `' .. index .. '` for LuaSlice')
+        end
+    end,
 }
 
 local function createSliceWrapper(wrapper)
@@ -71,5 +87,6 @@ local LuaBuffer = ffi.metatype('LuaBuffer', bufferMeta)
 
 Support.File._LuaBuffer = LuaBuffer
 Support.File._createSliceWrapper = createSliceWrapper
+Support.File.createEmptySlice = function() return createSliceWrapper(C.createEmptySlice()) end
 
 -- )EOF"

src/lua/luafile.cc

@@ -167,10 +167,11 @@ LuaFile* zReader(LuaFile* wrapper, int64_t size, bool raw) {
                            : new PCSX::ZReader(wrapper->file, size));
 }
 
+PCSX::Slice* createEmptySlice() { return new PCSX::Slice(); }
 uint64_t getSliceSize(PCSX::Slice* slice) { return slice->size(); }
-
 const void* getSliceData(PCSX::Slice* slice) { return slice->data(); }
-
+void* getSliceMutableData(PCSX::Slice* slice) { return slice->mutableData(); }
+void resizeSlice(PCSX::Slice* slice, uint32_t size) { slice->resize(size); }
 void destroySlice(PCSX::Slice* slice) { delete slice; }
 
 int readFileUserData(PCSX::Lua L) {
@@ -343,8 +344,11 @@ static void registerAllSymbols(PCSX::Lua L) {
 
     REGISTER(L, zReader);
 
+    REGISTER(L, createEmptySlice);
     REGISTER(L, getSliceSize);
     REGISTER(L, getSliceData);
+    REGISTER(L, getSliceMutableData);
+    REGISTER(L, resizeSlice);
     REGISTER(L, destroySlice);
 
     REGISTER(L, mem4g);

src/mips/common/util/bitfield.hh

@@ -0,0 +1,145 @@
+/*
+
+MIT License
+
+Copyright (c) 2025 PCSX-Redux authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+
+#include <stdint.h>
+
+#include <concepts>
+#include <type_traits>
+
+#include "util.h"
+
+namespace Utilities {
+
+namespace BitFieldInternal {
+
+template <typename T>
+struct DefaultBitSize {
+    static constexpr unsigned size = sizeof(T) * 8;
+};
+
+template <>
+struct DefaultBitSize<bool> {
+    static constexpr unsigned size = 1;
+};
+
+template <typename... T>
+struct ComputeStorage {
+    static constexpr unsigned size() { return (sizeInBits() + 7) / 8; }
+
+  private:
+    static constexpr unsigned sizeInBits() { return recSize<0, T...>(); }
+    template <unsigned index>
+    static constexpr unsigned recSize() {
+        return 0;
+    }
+    template <unsigned index, typename One, typename... Rest>
+    static constexpr unsigned recSize() {
+        return One::Width + recSize<index + 1, Rest...>();
+    }
+};
+
+template <typename Target, typename... T>
+struct ComputeOffset {
+    static constexpr unsigned offset() { return recOffset<0, T...>(); }
+
+  private:
+    template <unsigned index>
+    static constexpr unsigned recOffset() {
+        return 0;
+    }
+    template <unsigned index, typename One, typename... Rest>
+    static constexpr unsigned recOffset() {
+        if constexpr (std::is_same_v<Target, One>) {
+            return 0;
+        } else {
+            return recOffset<index + 1, Rest...>() + One::Width;
+        }
+    }
+};
+
+}  // namespace BitFieldInternal
+
+template <std::integral T, unsigned width = BitFieldInternal::DefaultBitSize<T>::size>
+struct BitSpan {
+    static constexpr unsigned Width = width;
+    using Underlying = T;
+};
+
+template <typename... T>
+struct BitField {
+    template <typename One>
+    constexpr typename One::Underlying get() {
+        if constexpr (std::is_signed_v<typename One::Underlying>) {
+            return get<BitFieldInternal::ComputeOffset<One, T...>::offset(), One::Width, signed>();
+        } else if constexpr (std::is_unsigned_v<typename One::Underlying>) {
+            return get<BitFieldInternal::ComputeOffset<One, T...>::offset(), One::Width, unsigned>();
+        }
+        return 0;
+    }
+    template <typename One>
+    constexpr void set(typename One::Underlying v) {
+        if constexpr (std::is_signed_v<typename One::Underlying>) {
+            set<BitFieldInternal::ComputeOffset<One, T...>::offset(), One::Width, signed>(v);
+        } else if constexpr (std::is_unsigned_v<typename One::Underlying>) {
+            set<BitFieldInternal::ComputeOffset<One, T...>::offset(), One::Width, unsigned>(v);
+        }
+    }
+
+  private:
+    template <unsigned offset, unsigned width, std::integral U>
+    constexpr U get() {
+        constexpr unsigned firstByteOffset = offset / 8;
+        constexpr unsigned lastByteOffset = (offset + width - 1) / 8;
+        constexpr unsigned shift = offset % 8;
+        constexpr uint32_t mask = (1 << width) - 1;
+        if constexpr ((firstByteOffset % 4) == 0) {
+            return reinterpret_cast<const U*>(storage)[firstByteOffset / 4] >> shift & mask;
+        } else if constexpr ((firstByteOffset % 4) != 0) {
+            return (loadUnaligned<U>(storage + firstByteOffset, lastByteOffset - firstByteOffset + 1) >> shift) & mask;
+        }
+        return 0;
+    }
+    template <unsigned offset, unsigned width, std::integral U>
+    constexpr void set(U v) {
+        constexpr unsigned firstByteOffset = offset / 8;
+        constexpr unsigned lastByteOffset = (offset + width - 1) / 8;
+        constexpr unsigned shift = offset % 8;
+        constexpr uint32_t mask = (1 << width) - 1;
+        if constexpr ((firstByteOffset % 4) == 0) {
+            U* ptr = reinterpret_cast<U*>(storage);
+            ptr[firstByteOffset / 4] &= ~(mask << shift);
+            ptr[firstByteOffset / 4] |= (v & mask) << shift;
+        } else if constexpr ((firstByteOffset % 4) != 0) {
+            U span = loadUnaligned<U>(storage + firstByteOffset, lastByteOffset - firstByteOffset + 1);
+            span &= ~(mask << shift);
+            span |= (v & mask) << shift;
+            storeUnaligned<U>(storage + firstByteOffset, span, lastByteOffset - firstByteOffset + 1);
+        }
+    }
+    uint8_t storage[BitFieldInternal::ComputeStorage<T...>::size()];
+};
+
+}  // namespace Utilities

src/mips/common/util/djbhash.h

@@ -28,8 +28,32 @@ SOFTWARE.
 
 #include <stdint.h>
 
+#ifdef __cplusplus
+#include <concepts>
+
+namespace djb {
+
+template <std::integral T = uint32_t>
+static inline constexpr T process(T hash, const char str[], unsigned n) {
+    return n ? process(((hash << 5) + hash) ^ static_cast<uint8_t>(str[0]), str + 1, n - 1) : hash;
+}
+
+template <std::integral T = uint32_t>
+static inline T constexpr hash(const char* str, unsigned n) {
+    return process(T(5381), str, n);
+}
+
+template <std::integral T = uint32_t, unsigned S>
+static inline T constexpr hash(const char (&str)[S]) {
+    return process(T(5381), str, S - 1);
+}
+
+}  // namespace djb
+
+#endif
+
 static inline uint32_t djbProcess(uint32_t hash, const char str[], unsigned n) {
-    return n ? djbProcess(((hash << 5) + hash) ^ str[0], str + 1, n - 1) : hash;
+    return n ? djbProcess(((hash << 5) + hash) ^ ((uint8_t)str[0]), str + 1, n - 1) : hash;
 }
 
 static inline uint32_t djbHash(const char* str, unsigned n) { return djbProcess(5381, str, n); }