Merge pull request #1899 from nicolasnoble/read-slice

Adding the ability to read slices from Lua.

Author: nicolasnoble

src/lua/fileffi-cdef.lua

@@ -56,6 +56,8 @@ void closeFile(LuaFile* wrapper);
 
 uint64_t readFileRawPtr(LuaFile* wrapper, void* dst, uint64_t size);
 uint64_t readFileBuffer(LuaFile* wrapper, LuaBuffer* buffer);
+LuaSlice* readFileToSlice(LuaFile* wrapper, uint64_t size);
+uint64_t readFileToExistingSlice(LuaFile* wrapper, LuaSlice* slice, uint64_t size);
 
 uint64_t writeFileRawPtr(LuaFile* wrapper, const const void* data, uint64_t size);
 uint64_t writeFileBuffer(LuaFile* wrapper, const LuaBuffer* buffer);
@@ -70,6 +72,8 @@ uint64_t getFileSize(LuaFile*);
 
 uint64_t readFileAtRawPtr(LuaFile* wrapper, void* dst, uint64_t size, uint64_t pos);
 uint64_t readFileAtBuffer(LuaFile* wrapper, LuaBuffer* buffer, uint64_t pos);
+LuaSlice* readFileAtToSlice(LuaFile* wrapper, uint64_t size, uint64_t pos);
+uint64_t readFileAtToExistingSlice(LuaFile* wrapper, LuaSlice* slice, uint64_t size, uint64_t pos);
 
 uint64_t writeFileAtRawPtr(LuaFile* wrapper, const const void* data, uint64_t size, uint64_t pos);
 uint64_t writeFileAtBuffer(LuaFile* wrapper, const LuaBuffer* buffer, uint64_t pos);

src/lua/fileffi.lua

@@ -20,7 +20,7 @@ local C = ffi.load 'SUPPORT_FILE'
 local function validateBuffer(buffer)
     if buffer:maxsize() < buffer.size then
         error('Invalid or corrupted LuaBuffer: claims size of ' .. buffer.size .. ' but actual size is ' ..
-                  buffer:maxsize())
+            buffer:maxsize())
     end
     return buffer
 end
@@ -34,13 +34,21 @@ local function read(self, ptr, size)
         return validateBuffer(buf)
     elseif type(ptr) == 'cdata' and size == nil and ffi.typeof(ptr) == Support.File._LuaBuffer then
         return Support.extra.safeFFI('File::read(C.readFileBuffer)', C.readFileBuffer, self._wrapper,
-                                     validateBuffer(ptr))
+            validateBuffer(ptr))
     elseif type(ptr) == 'userdata' and size == nil then
         return Support._internal.readFileUserData(self._wrapper, ptr)
+    elseif type(ptr) == 'table' and ptr._type == 'Slice' then
+        return Support.extra.safeFFI('File::read(C.readFileToExistingSlice)', C.readFileToExistingSlice, self._wrapper,
+            ptr._wrapper, size or ptr:size())
     end
     return Support.extra.safeFFI('File::read(C.readFileRawPtr)', C.readFileRawPtr, self._wrapper, ptr, size)
 end
 
+local function readToSlice(self, size)
+    return Support.File._createSliceWrapper(Support.extra.safeFFI('File::read(C.readFileToSlice)', C.readFileToSlice,
+        self._wrapper, size))
+end
+
 local function readAt(self, ptr, size, pos)
     if type(ptr) == 'number' and type(size) == 'number' and pos == nil then
         pos = size
@@ -51,40 +59,48 @@ local function readAt(self, ptr, size, pos)
         return validateBuffer(buf)
     elseif type(ptr) == 'cdata' and type(size) == 'number' and pos == nil and ffi.typeof(ptr) == LuaBuffer then
         return Support.extra.safeFFI('File::readAt(C.readFileAtBuffer)', C.readFileAtBuffer, self._wrapper,
-                                     validateBuffer(ptr), size)
+            validateBuffer(ptr), size)
     elseif type(ptr) == 'userdata' and type(size) == 'number' and pos == nil then
         return Support._internal.readFileAtUserData(self._wrapper, ptr, size)
+    elseif type(ptr) == 'table' and ptr._type == 'Slice' then
+        return Support.extra.safeFFI('File::readAt(C.readFileAtToExistingSlice)', C.readFileAtToExistingSlice,
+            self._wrapper, ptr._wrapper, size or ptr:size(), pos)
     end
     return Support.extra.safeFFI('File::readAt(C.readFileAtRawPtr)', C.readFileAtRawPtr, self._wrapper, ptr, size, pos)
 end
 
+local function readAtToSlice(self, size, pos)
+    return Support.File._createSliceWrapper(Support.extra.safeFFI('File::readAt(C.readFileAtToSlice)',
+        C.readFileAtToSlice, self._wrapper, size, pos))
+end
+
 local function write(self, data, size)
     if type(data) == 'cdata' and size == nil and ffi.typeof(data) == LuaBuffer then
         return Support.extra.safeFFI('File::write(C.writeFileBuffer)', C.writeFileBuffer, self._wrapper,
-                                     validateBuffer(data))
+            validateBuffer(data))
     elseif type(data) == 'userdata' and size == nil then
         return Support._internal.writeFileUserData(self._wrapper, data)
     elseif type(size) == 'number' then
         return Support.extra.safeFFI('File::write(C.writeFileRawPtr)', C.writeFileRawPtr, self._wrapper, data, size)
     end
     if type(data) ~= 'string' then data = tostring(data) end
     return Support.extra.safeFFI('File::write(C.writeFileRawPtr)', C.writeFileRawPtr, self._wrapper, data,
-                                 string.len(data))
+        string.len(data))
 end
 
 local function writeAt(self, data, size, pos)
     if type(data) == 'cdata' and type(size) == 'number' and pos == nil and ffi.typeof(data) == LuaBuffer then
         return Support.extra.safeFFI('File::writeAt(C.writeFileAtBuffer)', C.writeFileAtBuffer, self._wrapper,
-                                     validateBuffer(data), size)
+            validateBuffer(data), size)
     elseif type(data) == 'userdata' and type(size) == 'number' and pos == nil then
         return Support._internal.writeFileAtUserData(self._wrapper, data, size)
     elseif type(size) == 'number' and type(pos) == 'number' then
         return Support.extra.safeFFI('File::writeAt(C.writeFileAtRawPtr)', C.writeFileAtRawPtr, self._wrapper, data,
-                                     size, pos)
+            size, pos)
     end
     if type(data) ~= 'string' then data = tostring(data) end
     return Support.extra.safeFFI('File::writeAt(C.writeFileAtRawPtr)', C.writeFileAtRawPtr, self._wrapper, data,
-                                 string.len(data), size)
+        string.len(data), size)
 end
 
 local function writeMoveSlice(self, slice) C.writeFileMoveSlice(self._wrapper, slice._wrapper) end
@@ -172,7 +188,9 @@ local function createFileWrapper(wrapper)
         _type = 'File',
         close = function(self) Support.extra.safeFFI('File::close', C.closeFile, self._wrapper) end,
         read = read,
+        readToSlice = readToSlice,
         readAt = readAt,
+        readAtToSlice = readAtToSlice,
         gets = function(self) return Support._internal.readFileGets(self._wrapper) end,
         write = write,
         writeAt = writeAt,
@@ -301,10 +319,10 @@ end
 local function ffmpegAudioFile(file, options)
     if type(options) ~= 'table' then options = {} end
     local channels, endianness, sampleFormat, frequency = options.channels, options.endianness, options.sampleFormat,
-                                                          options.frequency
+        options.frequency
     return createFileWrapper(Support.extra.safeFFI('Support.File.ffmpegAudioFile', C.ffmpegAudioFile, file._wrapper,
-                                                   channels or 'Stereo', endianness or 'Little', sampleFormat or 'S16',
-                                                   frequency or 44100))
+        channels or 'Stereo', endianness or 'Little', sampleFormat or 'S16',
+        frequency or 44100))
 end
 
 if (type(Support) ~= 'table') then Support = {} end

src/lua/luafile.cc

@@ -86,6 +86,12 @@ uint64_t readFileBuffer(LuaFile* wrapper, void* buffer) {
     uint8_t* data = reinterpret_cast<uint8_t*>(pSize + 1);
     return *pSize = wrapper->file->read(data, *pSize);
 }
+PCSX::Slice* readFileToSlice(LuaFile* wrapper, uint64_t size) {
+    return new PCSX::Slice(std::move(wrapper->file->read(size)));
+}
+uint64_t readFileToExistingSlice(LuaFile* wrapper, PCSX::Slice* slice, uint64_t size) {
+    return wrapper->file->read(slice->mutableData(), size);
+}
 
 uint64_t writeFileRawPtr(LuaFile* wrapper, const uint8_t* data, uint64_t size) {
     return wrapper->file->write(data, size);
@@ -117,6 +123,12 @@ uint64_t readFileAtBuffer(LuaFile* wrapper, void* buffer, uint64_t pos) {
     uint8_t* data = reinterpret_cast<uint8_t*>(pSize + 1);
     return *pSize = wrapper->file->readAt(data, *pSize, pos);
 }
+PCSX::Slice* readFileAtToSlice(LuaFile* wrapper, uint64_t size, uint64_t pos) {
+    return new PCSX::Slice(std::move(wrapper->file->readAt(pos, size)));
+}
+uint64_t readFileAtToExistingSlice(LuaFile* wrapper, PCSX::Slice* slice, uint64_t size, uint64_t pos) {
+    return wrapper->file->readAt(slice->mutableData(), size, pos);
+}
 
 uint64_t writeFileAtRawPtr(LuaFile* wrapper, const uint8_t* data, uint64_t size, uint64_t pos) {
     return wrapper->file->writeAt(data, size, pos);
@@ -312,6 +324,9 @@ static void registerAllSymbols(PCSX::Lua L) {
 
     REGISTER(L, readFileRawPtr);
     REGISTER(L, readFileBuffer);
+    REGISTER(L, readFileToSlice);
+    REGISTER(L, readFileToExistingSlice);
+
     REGISTER(L, writeFileRawPtr);
     REGISTER(L, writeFileBuffer);
     REGISTER(L, writeFileMoveSlice);
@@ -325,6 +340,8 @@ static void registerAllSymbols(PCSX::Lua L) {
 
     REGISTER(L, readFileAtRawPtr);
     REGISTER(L, readFileAtBuffer);
+    REGISTER(L, readFileAtToSlice);
+    REGISTER(L, readFileAtToExistingSlice);
 
     REGISTER(L, writeFileAtRawPtr);
     REGISTER(L, writeFileAtBuffer);