From 5424f51f7035dfc4da2f77a9c19821da2f9bae5b Mon Sep 17 00:00:00 2001 From: Onran Date: Sun, 21 Jun 2026 19:04:58 +0900 Subject: [PATCH 01/18] added io_stream.wrap_bytearray --- doc/ru/scripting/io_stream.md | 10 ++ .../internal/stream_providers/bytearray.lua | 126 ++++++++++++++++++ res/scripts/stdlib.lua | 2 + 3 files changed, 138 insertions(+) create mode 100644 res/modules/internal/stream_providers/bytearray.lua diff --git a/doc/ru/scripting/io_stream.md b/doc/ru/scripting/io_stream.md index cc3403eda..2362682ad 100644 --- a/doc/ru/scripting/io_stream.md +++ b/doc/ru/scripting/io_stream.md @@ -188,6 +188,16 @@ io_stream:close() -- Вызывает ioLib.flush() в all flush-режиме io_stream:flush() +-- Создаёт новый поток из Bytearray. +-- Может использоваться одновременно как для чтения, так и для записи. +-- Результат записи будет записан в тот же Bytearray, что был передан в функцию. +io_stream.wrap_bytearray( + buffer: Bytearray, + + -- по-умолчанию равен true, поскольку функция из вводных аргументов + -- будет использоваться преимущественно для работы с двоичными данными. + [опционально] binaryMode: boolean = true + ) -> io_stream -- Создаёт новый поток с переданным дескриптором и использующим переданную I/O библиотеку. (Более подробно в core:io_stream.lua) io_stream.new( diff --git a/res/modules/internal/stream_providers/bytearray.lua b/res/modules/internal/stream_providers/bytearray.lua new file mode 100644 index 000000000..6909bdf5c --- /dev/null +++ b/res/modules/internal/stream_providers/bytearray.lua @@ -0,0 +1,126 @@ +local io_stream = require "core:io_stream" + +local lib = { } + +local buffers = { } +local positions = { } + +local nextDescriptor = 0 + +local function openDescriptor(buffer) + nextDescriptor = nextDescriptor + 1 + + buffers[nextDescriptor] = buffer + positions[nextDescriptor] = 1 + + return nextDescriptor +end + +local function requireDescriptor(descriptor) + if not buffers[descriptor] then + error("unknown descriptor") + end +end + +function lib.read(descriptor, length) + requireDescriptor(descriptor) + + local buf = buffers[descriptor] + local bufLength = #buf + local pos = positions[descriptor] + + local toRead = math.min(bufLength - pos + 1, length) + + if toRead <= 0 then + return Bytearray() + end + + local segment = buf:slice(pos, toRead) + + positions[descriptor] = pos + toRead + + return segment +end + +function lib.write(descriptor, data) + requireDescriptor(descriptor) + + local buf = buffers[descriptor] + local pos = positions[descriptor] + + local bufLength = #buf + local dataLength = #data + + local endPos = pos + dataLength - 1 + + -- size ensuring + if endPos > bufLength then + for i = bufLength + 1, endPos do + buf[i] = 0 + end + end + + for i = 1, dataLength do + buf[i + pos - 1] = data[i] + end + + positions[descriptor] = pos + dataLength +end + +function lib.seek(descriptor, mode, offset) + requireDescriptor(descriptor) + + local buf = buffers[descriptor] + local bufLength = #buf + + local base + + if mode == 'b' then + base = 1 + elseif mode == 'c' then + base = positions[descriptor] + elseif mode == 'e' then + base = bufLength + 1 + else error('invalid seek mode') end + + local newPos = base + offset + + if newPos < 1 then + error('failed to seek stream') + end + + positions[descriptor] = newPos +end + +function lib.tell(descriptor) + requireDescriptor(descriptor) + + return positions[descriptor] +end + +function lib.flush(descriptor) + requireDescriptor(descriptor) +end + +function lib.is_alive(descriptor) + return buffers[descriptor] ~= nil +end + +function lib.close(descriptor) + requireDescriptor(descriptor) + + buffers[descriptor] = nil + positions[descriptor] = nil +end + +return function(buffer, binaryMode) + if binaryMode == nil then + binaryMode = true + end + + return io_stream.new( + openDescriptor(buffer), + binaryMode, + lib + ) +end \ No newline at end of file diff --git a/res/scripts/stdlib.lua b/res/scripts/stdlib.lua index 093501d75..17da8ba85 100644 --- a/res/scripts/stdlib.lua +++ b/res/scripts/stdlib.lua @@ -332,6 +332,8 @@ else os.pid = ffi.C.getpid() end +require("core:io_stream").wrap_bytearray = require "core:internal/stream_providers/bytearray" + math.randomseed(time.uptime() * 1536227939) rules = require "core:internal/rules" From fdec2d722d2b81e7bdbdfec2209a9df28d10dde0 Mon Sep 17 00:00:00 2001 From: Onran Date: Sun, 21 Jun 2026 19:20:37 +0900 Subject: [PATCH 02/18] fix of io_stream:read_fully for binary and yield mode --- res/modules/io_stream.lua | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/res/modules/io_stream.lua b/res/modules/io_stream.lua index b608a22a9..5350abb9f 100644 --- a/res/modules/io_stream.lua +++ b/res/modules/io_stream.lua @@ -145,8 +145,12 @@ function io_stream:__update_read_buffer() end end -function io_stream:__read(length) +function io_stream:__read(length, fromReadFully) if self.mode == YIELD_MODE then + if fromReadFully then + return self.ioLib.read(self.descriptor, length) + end + local buffer = Bytearray() while #buffer < length do @@ -203,7 +207,9 @@ function io_stream:read_fully(useTable) if self.binaryMode then local result = useTable and Bytearray() or { } - readFully(result, function() return self:__read(self.maxBufferSize) end) + readFully(result, function() return self:__read(self.maxBufferSize, true) end) + + return result else if useTable then local lines = { } From bf98091a9ce86e0cfbcbf5bffaf853e77fcf936f Mon Sep 17 00:00:00 2001 From: Onran Date: Sun, 21 Jun 2026 20:19:24 +0900 Subject: [PATCH 03/18] added low-level ioLib.available for io_stream's --- doc/ru/scripting/io_stream.md | 18 ++++++------- .../internal/stream_providers/bytearray.lua | 9 +++++++ .../internal/stream_providers/file.lua | 1 + .../stream_providers/named_pipe_unix.lua | 14 ++++++++++ .../stream_providers/named_pipe_windows.lua | 16 +++++++++++ res/modules/io_stream.lua | 7 +++-- src/logic/scripting/descriptors_manager.cpp | 27 +++++++++++++++++++ src/logic/scripting/descriptors_manager.hpp | 2 ++ src/logic/scripting/lua/libs/libfile.cpp | 15 +++++++++++ 9 files changed, 97 insertions(+), 12 deletions(-) diff --git a/doc/ru/scripting/io_stream.md b/doc/ru/scripting/io_stream.md index 2362682ad..0c853131f 100644 --- a/doc/ru/scripting/io_stream.md +++ b/doc/ru/scripting/io_stream.md @@ -154,16 +154,6 @@ io_stream:seek( ## Методы Buffered-режима ```lua ---[[ -Если length определён, то возвращает true, если length байт доступно к чтению. Иначе возвращает false - -Если не определён, то возвращает количество байт, которое можно прочитать - ---]] -io_stream:available( - [опционально] length: number -) -> number | boolean - -- Возвращает максимальный размер буферов io_stream:get_max_buffer_size() -> number @@ -174,6 +164,14 @@ io_stream:set_max_buffer_size(max_size: number) ## Методы контроля состояния потока ```lua +--[[ +Если length определён, то возвращает true, если length байт доступно к чтению. Иначе возвращает false. + +Если не определён, то возвращает количество байт, которое можно прочитать. +--]] +io_stream:available( + [опционально] length: number +) -> number | boolean -- Возвращает true, если поток открыт на данный момент io_stream:is_alive() -> bool diff --git a/res/modules/internal/stream_providers/bytearray.lua b/res/modules/internal/stream_providers/bytearray.lua index 6909bdf5c..35a15b654 100644 --- a/res/modules/internal/stream_providers/bytearray.lua +++ b/res/modules/internal/stream_providers/bytearray.lua @@ -102,6 +102,15 @@ function lib.flush(descriptor) requireDescriptor(descriptor) end +function lib.available(descriptor) + requireDescriptor(descriptor) + + local buf = buffers[descriptor] + local pos = positions[descriptor] + + return math.max(#buf - pos + 1, 0) +end + function lib.is_alive(descriptor) return buffers[descriptor] ~= nil end diff --git a/res/modules/internal/stream_providers/file.lua b/res/modules/internal/stream_providers/file.lua index ec81a42c0..f73961e22 100644 --- a/res/modules/internal/stream_providers/file.lua +++ b/res/modules/internal/stream_providers/file.lua @@ -5,6 +5,7 @@ local lib = { write = file.__write_descriptor, seek = file.__seek_descriptor, flush = file.__flush_descriptor, + available = file.__available_descriptor, is_alive = file.__has_descriptor, close = file.__close_descriptor } diff --git a/res/modules/internal/stream_providers/named_pipe_unix.lua b/res/modules/internal/stream_providers/named_pipe_unix.lua index 8b924f47a..237910ecb 100644 --- a/res/modules/internal/stream_providers/named_pipe_unix.lua +++ b/res/modules/internal/stream_providers/named_pipe_unix.lua @@ -9,6 +9,7 @@ int close(int fd); ssize_t read(int fd, void *buf, size_t count); ssize_t write(int fd, const void *buf, size_t count); int fcntl(int fd, int cmd, ...); +int ioctl(int fd, unsigned long request, ...); const char *strerror(int errnum); ]] @@ -20,6 +21,7 @@ local O_WRONLY = 0x1 local O_RDWR = 0x2 local O_NONBLOCK = 0x800 local F_GETFL = 3 +local FIONREAD = 0x541B local function getError() local err = FFI.errno() @@ -66,6 +68,18 @@ function lib.flush(fd) -- no flush on unix end +function lib.available(fd) + if fd == nil or fd < 0 then return 0 end + + local bytes_ready = FFI.new("int[1]", 0) + + if C.ioctl(fd, FIONREAD, bytes_ready) == -1 then + return 0 + end + + return tonumber(bytes_ready[0]) +end + function lib.is_alive(fd) if fd == nil or fd < 0 then return false end diff --git a/res/modules/internal/stream_providers/named_pipe_windows.lua b/res/modules/internal/stream_providers/named_pipe_windows.lua index 3d4b31af1..3a18f4928 100644 --- a/res/modules/internal/stream_providers/named_pipe_windows.lua +++ b/res/modules/internal/stream_providers/named_pipe_windows.lua @@ -105,6 +105,22 @@ function lib.flush(handle) C.FlushFileBuffers(handle) end +function lib.available(handle) + if handle == nil or handle == INVALID_HANDLE_VALUE then + return 0 + end + + local bytes_available = FFI.new("DWORD[1]") + + local success = C.PeekNamedPipe(handle, nil, 0, nil, bytes_available, nil) + + if success == 0 then + return 0 + end + + return tonumber(bytes_available[0]) +end + function lib.is_alive(handle) if handle == nil or handle == INVALID_HANDLE_VALUE then return false diff --git a/res/modules/io_stream.lua b/res/modules/io_stream.lua index 5350abb9f..3dff50ce4 100644 --- a/res/modules/io_stream.lua +++ b/res/modules/io_stream.lua @@ -42,14 +42,17 @@ local function readFully(result, readFunc) end --[[ - descriptor - descriptor of stream for provided I/O library binaryMode - if enabled, most methods will expect bytes instead of strings ioLib - I/O library. Should include the following functions: read(descriptor: int, length: int) -> Bytearray May return bytearray with a smaller size if bytes have not arrived yet or have run out write(descriptor: int, data: Bytearray) + seek(descriptor: int, mode: string, offset: int) + Mode may be 'b' (relative begin), 'c' (relative current), 'e' (relative end + 1) flush(descriptor: int) + available(descriptor: int) -> int + May return 0 if environment is not support available method is_alive(descriptor: int) -> bool close(descriptor: int) --]] @@ -130,7 +133,7 @@ function io_stream:available(length) else return #self.readBuffer >= length end - end + else return self.ioLib.available(self.descriptor) end end function io_stream:__update_read_buffer() diff --git a/src/logic/scripting/descriptors_manager.cpp b/src/logic/scripting/descriptors_manager.cpp index f7458ccc5..0ff2f018b 100644 --- a/src/logic/scripting/descriptors_manager.cpp +++ b/src/logic/scripting/descriptors_manager.cpp @@ -28,6 +28,33 @@ namespace scripting { } } + int descriptors_manager::available(int descriptor) { + if (!is_readable(descriptor)) + return 0; + + auto* stream = descriptors[descriptor]->in.get(); + + auto current_pos = stream->tellg(); + + if (current_pos == -1) { + return 0; + } + + stream->seekg(0, std::ios::end); + + auto end_pos = stream->tellg(); + + stream->seekg(current_pos, std::ios::beg); + + auto remaining = end_pos - current_pos; + + if (remaining > std::numeric_limits::max()) { + return std::numeric_limits::max(); + } + + return static_cast(remaining); + } + bool descriptors_manager::has_descriptor(int descriptor) { return is_readable(descriptor) || is_writeable(descriptor); } diff --git a/src/logic/scripting/descriptors_manager.hpp b/src/logic/scripting/descriptors_manager.hpp index ccd1b67a3..64373c7a4 100644 --- a/src/logic/scripting/descriptors_manager.hpp +++ b/src/logic/scripting/descriptors_manager.hpp @@ -26,6 +26,8 @@ namespace scripting { static void flush(int descriptor); + static int available(int descriptor); + static bool has_descriptor(int descriptor); static bool is_readable(int descriptor); diff --git a/src/logic/scripting/lua/libs/libfile.cpp b/src/logic/scripting/lua/libs/libfile.cpp index 26248379c..4fd006582 100644 --- a/src/logic/scripting/lua/libs/libfile.cpp +++ b/src/logic/scripting/lua/libs/libfile.cpp @@ -397,6 +397,20 @@ static int l_flush_descriptor(lua::State* L) { return 0; } +static int l_available_descriptor(lua::State* L) { + int descriptor = lua::tointeger(L, 1); + + if (!scripting::descriptors_manager::has_descriptor(descriptor)) { + throw std::runtime_error("unknown descriptor"); + } + + if (!scripting::descriptors_manager::is_readable(descriptor)) { + throw std::runtime_error("descriptor is not readable"); + } + + return lua::pushinteger(L, scripting::descriptors_manager::available(descriptor)); +} + static int l_close_descriptor(lua::State* L) { int descriptor = lua::tointeger(L, 1); @@ -443,6 +457,7 @@ const luaL_Reg filelib[] = { {"__write_descriptor", lua::wrap}, {"__seek_descriptor", lua::wrap}, {"__flush_descriptor", lua::wrap}, + {"__available_descriptor", lua::wrap}, {"__close_descriptor", lua::wrap}, {"__close_all_descriptors", lua::wrap}, {nullptr, nullptr} From dfd67011a40382e0c10edff648e9d82b45eb169a Mon Sep 17 00:00:00 2001 From: Onran Date: Sun, 21 Jun 2026 20:51:49 +0900 Subject: [PATCH 04/18] added socket:as_stream() --- doc/ru/scripting/builtins/libnetwork.md | 5 ++ .../internal/stream_providers/socket.lua | 76 +++++++++++++++++++ res/scripts/classes.lua | 1 + res/scripts/stdlib.lua | 2 + 4 files changed, 84 insertions(+) create mode 100644 res/modules/internal/stream_providers/socket.lua diff --git a/doc/ru/scripting/builtins/libnetwork.md b/doc/ru/scripting/builtins/libnetwork.md index 31f59fb25..5bc5eaafd 100644 --- a/doc/ru/scripting/builtins/libnetwork.md +++ b/doc/ru/scripting/builtins/libnetwork.md @@ -92,6 +92,11 @@ socket:recv_async( [опционально] usetable: boolean=false ) -> nil|table|Bytearray +-- Оборачивает сокет в io_stream (см. ../io_stream.md) +socket:as_stream( + [опционально] binaryMode: boolean=true +) -> io_stream + -- Закрывает соединение socket:close() diff --git a/res/modules/internal/stream_providers/socket.lua b/res/modules/internal/stream_providers/socket.lua new file mode 100644 index 000000000..88684b0ff --- /dev/null +++ b/res/modules/internal/stream_providers/socket.lua @@ -0,0 +1,76 @@ +local io_stream = require "core:io_stream" + +local lib = { } + +local sockets = { } + +local nextDescriptor = 0 + +local function openDescriptor(socket) + nextDescriptor = nextDescriptor + 1 + + sockets[nextDescriptor] = socket + + return nextDescriptor +end + +local function requireDescriptor(descriptor) + if not sockets[descriptor] then + error("unknown descriptor") + end +end + +function lib.read(descriptor, length) + requireDescriptor(descriptor) + + return sockets[descriptor]:recv(length) +end + +function lib.write(descriptor, data) + requireDescriptor(descriptor) + + sockets[descriptor]:send(data) +end + +function lib.seek(descriptor, mode, offset) + error("cannot seek socket") +end + +function lib.tell(descriptor) + error("cannot tell socket") +end + +function lib.flush(descriptor) + requireDescriptor(descriptor) +end + +function lib.available(descriptor) + requireDescriptor(descriptor) + + return sockets[descriptor]:available() +end + +function lib.is_alive(descriptor) + local socket = sockets[descriptor] + + return socket ~= nil and socket:is_alive() +end + +function lib.close(descriptor) + requireDescriptor(descriptor) + + sockets[descriptor]:close() + sockets[descriptor] = nil +end + +return function(socket, binaryMode) + if binaryMode == nil then + binaryMode = true + end + + return io_stream.new( + openDescriptor(socket), + binaryMode, + lib + ) +end \ No newline at end of file diff --git a/res/scripts/classes.lua b/res/scripts/classes.lua index 664710a30..a057d52e6 100644 --- a/res/scripts/classes.lua +++ b/res/scripts/classes.lua @@ -49,6 +49,7 @@ local Socket = {__index={ end return self:recv(length, usetable) end, + as_stream=network.__as_stream, close=function(self) return network.__close(self.id) end, available=function(self) return network.__available(self.id) or 0 end, is_alive=function(self) return network.__is_alive(self.id) end, diff --git a/res/scripts/stdlib.lua b/res/scripts/stdlib.lua index 17da8ba85..6d25ed86c 100644 --- a/res/scripts/stdlib.lua +++ b/res/scripts/stdlib.lua @@ -334,6 +334,8 @@ end require("core:io_stream").wrap_bytearray = require "core:internal/stream_providers/bytearray" +network.__as_stream = require "core:internal/stream_providers/socket" + math.randomseed(time.uptime() * 1536227939) rules = require "core:internal/rules" From f8317e05c413331aab81f1d271477ec9c00b9bc7 Mon Sep 17 00:00:00 2001 From: Onran Date: Sun, 21 Jun 2026 21:01:53 +0900 Subject: [PATCH 05/18] available in io_stream docs moved to I/O section --- doc/ru/scripting/io_stream.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/doc/ru/scripting/io_stream.md b/doc/ru/scripting/io_stream.md index 0c853131f..eab023f67 100644 --- a/doc/ru/scripting/io_stream.md +++ b/doc/ru/scripting/io_stream.md @@ -139,7 +139,16 @@ io_stream:read_fully( ) -> Bytearray | table | table | string --[[ -Устанавливает позицию в потоке +Если length определён, то возвращает true, если length байт доступно к чтению. Иначе возвращает false. + +Если не определён, то возвращает количество байт, которое можно прочитать. +--]] +io_stream:available( + [опционально] length: number +) -> number | boolean + +--[[ +Устанавливает позицию в потоке (всегда в байтах) Режимы: b - Задаёт позицию относительно начало файла c - Задаёт позицию относительно текущей позиции @@ -164,15 +173,6 @@ io_stream:set_max_buffer_size(max_size: number) ## Методы контроля состояния потока ```lua ---[[ -Если length определён, то возвращает true, если length байт доступно к чтению. Иначе возвращает false. - -Если не определён, то возвращает количество байт, которое можно прочитать. ---]] -io_stream:available( - [опционально] length: number -) -> number | boolean - -- Возвращает true, если поток открыт на данный момент io_stream:is_alive() -> bool From cd040cfeb47f91b29c6d138f745b442483f4cf44 Mon Sep 17 00:00:00 2001 From: Onran Date: Sun, 21 Jun 2026 21:13:30 +0900 Subject: [PATCH 06/18] fix of io_stream:available for non-buffered streams when "length" arg defined --- res/modules/io_stream.lua | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/res/modules/io_stream.lua b/res/modules/io_stream.lua index 3dff50ce4..d2f132802 100644 --- a/res/modules/io_stream.lua +++ b/res/modules/io_stream.lua @@ -125,15 +125,21 @@ function io_stream:set_max_buffer_size(maxBufferSize) end function io_stream:available(length) + local available + if self.mode == BUFFERED_MODE then self:__update_read_buffer() - if not length then - return #self.readBuffer - else - return #self.readBuffer >= length - end - else return self.ioLib.available(self.descriptor) end + available = #self.readBuffer + else + available = self.ioLib.available(self.descriptor) + end + + if not length then + return available + else + return available >= length + end end function io_stream:__update_read_buffer() From dd9ba26f7b019a9558ea8b62949444bf6ec7bc23 Mon Sep 17 00:00:00 2001 From: Onran Date: Mon, 22 Jun 2026 00:29:08 +0900 Subject: [PATCH 07/18] conflicts fix --- .../internal/stream_providers/file.lua | 1 + src/logic/scripting/descriptors_manager.cpp | 131 ------------------ src/logic/scripting/descriptors_manager.hpp | 41 ------ src/logic/scripting/io_descriptors.cpp | 27 ++++ src/logic/scripting/io_descriptors.hpp | 1 + src/logic/scripting/lua/libs/libfile.cpp | 6 +- 6 files changed, 32 insertions(+), 175 deletions(-) delete mode 100644 src/logic/scripting/descriptors_manager.cpp delete mode 100644 src/logic/scripting/descriptors_manager.hpp diff --git a/res/modules/internal/stream_providers/file.lua b/res/modules/internal/stream_providers/file.lua index 178b153d3..5e186ae16 100644 --- a/res/modules/internal/stream_providers/file.lua +++ b/res/modules/internal/stream_providers/file.lua @@ -18,6 +18,7 @@ file.__write_descriptor = nil file.__seek_descriptor = nil file.__tell_descriptor = nil file.__flush_descriptor = nil +file.__available_descriptor = nil file.__has_descriptor = nil file.__close_descriptor = nil diff --git a/src/logic/scripting/descriptors_manager.cpp b/src/logic/scripting/descriptors_manager.cpp deleted file mode 100644 index 0ff2f018b..000000000 --- a/src/logic/scripting/descriptors_manager.cpp +++ /dev/null @@ -1,131 +0,0 @@ -#include "logic/scripting/descriptors_manager.hpp" - -#include "debug/Logger.hpp" - -static debug::Logger logger("descriptors-manager"); - -namespace scripting { - - std::vector> descriptors_manager::descriptors; - - std::istream* descriptors_manager::get_input(int descriptor) { - if (!is_readable(descriptor)) - return nullptr; - - return descriptors[descriptor]->in.get(); - } - - std::ostream* descriptors_manager::get_output(int descriptor) { - if (!is_writeable(descriptor)) - return nullptr; - - return descriptors[descriptor]->out.get(); - } - - void descriptors_manager::flush(int descriptor) { - if (is_writeable(descriptor)) { - descriptors[descriptor]->out->flush(); - } - } - - int descriptors_manager::available(int descriptor) { - if (!is_readable(descriptor)) - return 0; - - auto* stream = descriptors[descriptor]->in.get(); - - auto current_pos = stream->tellg(); - - if (current_pos == -1) { - return 0; - } - - stream->seekg(0, std::ios::end); - - auto end_pos = stream->tellg(); - - stream->seekg(current_pos, std::ios::beg); - - auto remaining = end_pos - current_pos; - - if (remaining > std::numeric_limits::max()) { - return std::numeric_limits::max(); - } - - return static_cast(remaining); - } - - bool descriptors_manager::has_descriptor(int descriptor) { - return is_readable(descriptor) || is_writeable(descriptor); - } - - bool descriptors_manager::is_readable(int descriptor) { - return descriptor >= 0 && descriptor < static_cast(descriptors.size()) - && descriptors[descriptor].has_value() - && descriptors[descriptor]->in != nullptr; - } - - bool descriptors_manager::is_writeable(int descriptor) { - return descriptor >= 0 && descriptor < static_cast(descriptors.size()) - && descriptors[descriptor].has_value() - && descriptors[descriptor]->out != nullptr; - } - - void descriptors_manager::close(int descriptor) { - if (descriptor >= 0 && descriptor < static_cast(descriptors.size())) { - if (descriptors[descriptor].has_value()) { - auto& desc = descriptors[descriptor].value(); - - if (desc.out) - desc.out->flush(); - - desc.in.reset(); - desc.out.reset(); - } - - descriptors[descriptor].reset(); - - descriptors[descriptor] = std::nullopt; - } - } - - int descriptors_manager::open_descriptor(const io::path& path, bool write, bool read) { - std::unique_ptr in; - std::unique_ptr out; - - try { - if (read) - in = io::read(path); - - if (write) - out = io::write(path); - } catch (const std::exception& e) { - logger.error() << "failed to open descriptor for " << path.string() - << ": " << e.what(); - - return -1; - } - - for (int i = 0; i < static_cast(descriptors.size()); ++i) { - if (!descriptors[i].has_value()) { - descriptors[i] = StreamDescriptor{ std::move(in), std::move(out) }; - return i; - } - } - - descriptors.emplace_back(StreamDescriptor{ std::move(in), std::move(out) }); - - return static_cast(descriptors.size() - 1); - } - - - void descriptors_manager::close_all_descriptors() { - for (int i = 0; i < static_cast(descriptors.size()); ++i) { - if (descriptors[i].has_value()) { - close(i); - } - } - - descriptors.clear(); - } -} \ No newline at end of file diff --git a/src/logic/scripting/descriptors_manager.hpp b/src/logic/scripting/descriptors_manager.hpp deleted file mode 100644 index 64373c7a4..000000000 --- a/src/logic/scripting/descriptors_manager.hpp +++ /dev/null @@ -1,41 +0,0 @@ -#pragma once - -#include -#include -#include -#include -#include -#include - -#include "io/io.hpp" - -namespace scripting { - - struct StreamDescriptor { - std::unique_ptr in; - std::unique_ptr out; - }; - - class descriptors_manager { - private: - static std::vector> descriptors; - - public: - static std::istream* get_input(int descriptor); - static std::ostream* get_output(int descriptor); - - static void flush(int descriptor); - - static int available(int descriptor); - - static bool has_descriptor(int descriptor); - - static bool is_readable(int descriptor); - static bool is_writeable(int descriptor); - - static void close(int descriptor); - static int open_descriptor(const io::path& path, bool write, bool read); - - static void close_all_descriptors(); - }; -} \ No newline at end of file diff --git a/src/logic/scripting/io_descriptors.cpp b/src/logic/scripting/io_descriptors.cpp index 132eea0eb..ead8566d1 100644 --- a/src/logic/scripting/io_descriptors.cpp +++ b/src/logic/scripting/io_descriptors.cpp @@ -66,6 +66,33 @@ void io_descriptors::flush(int id) { } } +int io_descriptors::available(int id) { + if (!is_readable(id)) + return 0; + + auto* stream = descriptors[id]->in.get(); + + auto current_pos = stream->tellg(); + + if (current_pos == -1) { + return 0; + } + + stream->seekg(0, std::ios::end); + + auto end_pos = stream->tellg(); + + stream->seekg(current_pos, std::ios::beg); + + auto remaining = end_pos - current_pos; + + if (remaining > std::numeric_limits::max()) { + return std::numeric_limits::max(); + } + + return static_cast(remaining); +} + bool io_descriptors::has_descriptor(int id) { return id >= 0 && id < static_cast(::descriptors.size()) && ::descriptors[id].has_value(); diff --git a/src/logic/scripting/io_descriptors.hpp b/src/logic/scripting/io_descriptors.hpp index 7e6207791..56ed21a7a 100644 --- a/src/logic/scripting/io_descriptors.hpp +++ b/src/logic/scripting/io_descriptors.hpp @@ -13,6 +13,7 @@ namespace scripting::io_descriptors { std::ostream& require_output(int id); void flush(int id); + int available(int id); bool has_descriptor(int id); diff --git a/src/logic/scripting/lua/libs/libfile.cpp b/src/logic/scripting/lua/libs/libfile.cpp index e51ce51a0..1bcceb6d3 100644 --- a/src/logic/scripting/lua/libs/libfile.cpp +++ b/src/logic/scripting/lua/libs/libfile.cpp @@ -403,15 +403,15 @@ static int l_flush_descriptor(lua::State* L) { static int l_available_descriptor(lua::State* L) { int descriptor = lua::tointeger(L, 1); - if (!scripting::descriptors_manager::has_descriptor(descriptor)) { + if (!io_descriptors::has_descriptor(descriptor)) { throw std::runtime_error("unknown descriptor"); } - if (!scripting::descriptors_manager::is_readable(descriptor)) { + if (!io_descriptors::is_readable(descriptor)) { throw std::runtime_error("descriptor is not readable"); } - return lua::pushinteger(L, scripting::descriptors_manager::available(descriptor)); + return lua::pushinteger(L, io_descriptors::available(descriptor)); } static int l_close_descriptor(lua::State* L) { From 490db13498fb8f204d3a7d297540a337a77fed04 Mon Sep 17 00:00:00 2001 From: Onran Date: Mon, 22 Jun 2026 00:31:58 +0900 Subject: [PATCH 08/18] added tell stub for named pipe stream's --- res/modules/internal/stream_providers/named_pipe_unix.lua | 4 ++++ res/modules/internal/stream_providers/named_pipe_windows.lua | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/res/modules/internal/stream_providers/named_pipe_unix.lua b/res/modules/internal/stream_providers/named_pipe_unix.lua index 237910ecb..614c9aaf4 100644 --- a/res/modules/internal/stream_providers/named_pipe_unix.lua +++ b/res/modules/internal/stream_providers/named_pipe_unix.lua @@ -64,6 +64,10 @@ function lib.seek(fd, mode, offset) error("cannot seek the named pipe") end +function lib.tell(fd) + error("cannot tell the named pipe") +end + function lib.flush(fd) -- no flush on unix end diff --git a/res/modules/internal/stream_providers/named_pipe_windows.lua b/res/modules/internal/stream_providers/named_pipe_windows.lua index 3a18f4928..d79335f7d 100644 --- a/res/modules/internal/stream_providers/named_pipe_windows.lua +++ b/res/modules/internal/stream_providers/named_pipe_windows.lua @@ -101,6 +101,10 @@ function lib.seek(handle, mode, offset) error("cannot seek the named pipe") end +function lib.tell(handle) + error("cannot tell the named pipe") +end + function lib.flush(handle) C.FlushFileBuffers(handle) end From 21019e6737b14a03f8cf7bf7ab0bdac790dfeda0 Mon Sep 17 00:00:00 2001 From: Onran Date: Mon, 22 Jun 2026 00:57:38 +0900 Subject: [PATCH 09/18] added note about tell to io_stream --- res/modules/io_stream.lua | 3 +++ 1 file changed, 3 insertions(+) diff --git a/res/modules/io_stream.lua b/res/modules/io_stream.lua index 7e5290c1a..3e91daa4e 100644 --- a/res/modules/io_stream.lua +++ b/res/modules/io_stream.lua @@ -50,6 +50,9 @@ ioLib - I/O library. Should include the following functions: write(descriptor: int, data: Bytearray) seek(descriptor: int, mode: string, offset: int) Mode may be 'b' (relative begin), 'c' (relative current), 'e' (relative end + 1) + May throw error if environment is not support seek + tell(descriptor: int) -> int + May throw error if environment is not support tell flush(descriptor: int) available(descriptor: int) -> int May return 0 if environment is not support available method From 82da7e907d569879d8706f381abccb10371e6c7e Mon Sep 17 00:00:00 2001 From: Onran Date: Mon, 22 Jun 2026 14:47:58 +0900 Subject: [PATCH 10/18] removed require to define available, tell, seek in ioLib --- .../internal/stream_providers/bytearray.lua | 4 --- .../stream_providers/named_pipe_unix.lua | 12 -------- .../stream_providers/named_pipe_windows.lua | 8 ----- .../internal/stream_providers/socket.lua | 12 -------- res/modules/io_stream.lua | 29 +++++++++++++------ 5 files changed, 20 insertions(+), 45 deletions(-) diff --git a/res/modules/internal/stream_providers/bytearray.lua b/res/modules/internal/stream_providers/bytearray.lua index 35a15b654..0f168c851 100644 --- a/res/modules/internal/stream_providers/bytearray.lua +++ b/res/modules/internal/stream_providers/bytearray.lua @@ -98,10 +98,6 @@ function lib.tell(descriptor) return positions[descriptor] end -function lib.flush(descriptor) - requireDescriptor(descriptor) -end - function lib.available(descriptor) requireDescriptor(descriptor) diff --git a/res/modules/internal/stream_providers/named_pipe_unix.lua b/res/modules/internal/stream_providers/named_pipe_unix.lua index 614c9aaf4..933f6292b 100644 --- a/res/modules/internal/stream_providers/named_pipe_unix.lua +++ b/res/modules/internal/stream_providers/named_pipe_unix.lua @@ -60,18 +60,6 @@ function lib.write(fd, bytearray) end end -function lib.seek(fd, mode, offset) - error("cannot seek the named pipe") -end - -function lib.tell(fd) - error("cannot tell the named pipe") -end - -function lib.flush(fd) - -- no flush on unix -end - function lib.available(fd) if fd == nil or fd < 0 then return 0 end diff --git a/res/modules/internal/stream_providers/named_pipe_windows.lua b/res/modules/internal/stream_providers/named_pipe_windows.lua index d79335f7d..817925b08 100644 --- a/res/modules/internal/stream_providers/named_pipe_windows.lua +++ b/res/modules/internal/stream_providers/named_pipe_windows.lua @@ -97,14 +97,6 @@ function lib.write(handle, bytearray) end end -function lib.seek(handle, mode, offset) - error("cannot seek the named pipe") -end - -function lib.tell(handle) - error("cannot tell the named pipe") -end - function lib.flush(handle) C.FlushFileBuffers(handle) end diff --git a/res/modules/internal/stream_providers/socket.lua b/res/modules/internal/stream_providers/socket.lua index 88684b0ff..0faedd695 100644 --- a/res/modules/internal/stream_providers/socket.lua +++ b/res/modules/internal/stream_providers/socket.lua @@ -32,18 +32,6 @@ function lib.write(descriptor, data) sockets[descriptor]:send(data) end -function lib.seek(descriptor, mode, offset) - error("cannot seek socket") -end - -function lib.tell(descriptor) - error("cannot tell socket") -end - -function lib.flush(descriptor) - requireDescriptor(descriptor) -end - function lib.available(descriptor) requireDescriptor(descriptor) diff --git a/res/modules/io_stream.lua b/res/modules/io_stream.lua index 3e91daa4e..ef1150237 100644 --- a/res/modules/io_stream.lua +++ b/res/modules/io_stream.lua @@ -47,15 +47,14 @@ binaryMode - if enabled, most methods will expect bytes instead of strings ioLib - I/O library. Should include the following functions: read(descriptor: int, length: int) -> Bytearray May return bytearray with a smaller size if bytes have not arrived yet or have run out + May throw error if descriptor isn't readable write(descriptor: int, data: Bytearray) - seek(descriptor: int, mode: string, offset: int) + May throw error if descriptor isn't writeable + [optional] seek(descriptor: int, mode: string, offset: int) Mode may be 'b' (relative begin), 'c' (relative current), 'e' (relative end + 1) - May throw error if environment is not support seek - tell(descriptor: int) -> int - May throw error if environment is not support tell - flush(descriptor: int) - available(descriptor: int) -> int - May return 0 if environment is not support available method + [optional] tell(descriptor: int) -> int + [optional] flush(descriptor: int) + [optional] available(descriptor: int) -> int is_alive(descriptor: int) -> bool close(descriptor: int) --]] @@ -135,7 +134,7 @@ function io_stream:available(length) available = #self.readBuffer else - available = self.ioLib.available(self.descriptor) + available = self.ioLib.available and self.ioLib.available(self.descriptor) or 0 end if not length then @@ -388,10 +387,18 @@ function io_stream:write(arg, ...) end function io_stream:seek(mode, offset) + if not self.ioLib.seek then + error("cannot seek this stream") + end + self.ioLib.seek(self.descriptor, mode, offset) end function io_stream:tell() + if not self.ioLib.tell then + error("cannot tell this stream") + end + return self.ioLib.tell(self.descriptor) end @@ -418,7 +425,11 @@ function io_stream:flush() self.writeBuffer:clear() end - if self.flushMode ~= FLUSH_MODE_ONLY_BUFFER then self.ioLib.flush(self.descriptor) end + if self.flushMode ~= FLUSH_MODE_ONLY_BUFFER then + if self.ioLib.flush then + self.ioLib.flush(self.descriptor) + elseif self:is_closed() then error("stream is closed") end + end end return io_stream From 15f17a0bc33598812e00fe073fbafa21bdbdf59a Mon Sep 17 00:00:00 2001 From: Onran Date: Mon, 22 Jun 2026 14:49:43 +0900 Subject: [PATCH 11/18] all numbers changed to ints in io_stream docs and documented tell --- doc/ru/scripting/io_stream.md | 51 ++++++++++++++++++++--------------- 1 file changed, 30 insertions(+), 21 deletions(-) diff --git a/doc/ru/scripting/io_stream.md b/doc/ru/scripting/io_stream.md index eab023f67..57f447643 100644 --- a/doc/ru/scripting/io_stream.md +++ b/doc/ru/scripting/io_stream.md @@ -48,13 +48,13 @@ **Независимый флаг** (включается через `set_binary_mode(true)` или при создании потока). Определяет, в каком виде методы `read` и `write` принимают и возвращают данные: -| binary = true | binary = false (по умолчанию) | -|-----------------------------------------|----------------------------------------| +| binary = true | binary = false (по умолчанию) | +|------------------------------------------------------------|----------------------------------------| | Данные — это **байты** (`Bytearray`, таблица чисел 0..255) | Данные — это **текстовые строки** | -| `read(n)` → `Bytearray` или `table`| `read()` → одна строка | -| `read("i4 f")` → распаковка через `byteutil.unpack` | `read(n)` → n строк в таблице | -| `write(Bytearray)` → запись байтов | `write("hello")` → строка + `\n` | -| `write("i4", 42)` → `byteutil.pack` | `write({"a","b"})` → две строки с `\n`| +| `read(n)` → `Bytearray` или `table` | `read()` → одна строка | +| `read("i4 f")` → распаковка через `byteutil.unpack` | `read(n)` → n строк в таблице | +| `write(Bytearray)` → запись байтов | `write("hello")` → строка + `\n` | +| `write("i4", 42)` → `byteutil.pack` | `write({"a","b"})` → две строки с `\n`| `read_line` / `write_line` — работают как в текстовом режиме @@ -90,25 +90,25 @@ io_stream:set_flush_mode(string) --[[ Читает данные из потока В двоичном режиме: - Если arg - number, то читает из потока arg байт и возвращает ввиде Bytearray или таблицы, если useTable = true + Если arg - int, то читает из потока arg байт и возвращает ввиде Bytearray или таблицы, если useTable = true Если arg - string, то функция интерпретирует arg как шаблон для byteutil. Прочитает кол-во байт, которое определено шаблоном, передаст их в byteutil.unpack и вернёт результат В текстовом режиме: - Если arg - number, то читает нужное кол-во строк с окончанием CRLF/LF из arg и возвращает ввиде таблицы. Также, если trimEmptyLines = true, то удаляет пустые строки с начала и конца из итоговой таблицы + Если arg - int, то читает нужное кол-во строк с окончанием CRLF/LF из arg и возвращает ввиде таблицы. Также, если trimEmptyLines = true, то удаляет пустые строки с начала и конца из итоговой таблицы Если arg не определён, то читает одну строку с окончанием CRLF/LF и возвращает её. --]] io_stream:read( - [опционально] arg: number | string, + [опционально] arg: int | string, [опционально] useTable | trimEmptyLines: boolean -) -> Bytearray | table | string | table | ... +) -> Bytearray | table | string | table | ... --[[ Записывает данные в поток В двоичном режиме: Если arg - string, то функция интерпретирует arg как шаблон для byteutil, передаст его и ... в byteutil.pack и результат запишет в поток - Если arg - Bytearray | table, то записывает байты в поток + Если arg - Bytearray | table, то записывает байты в поток В текстовом режиме: Если arg - string, то записывает строку в поток (вместе с окончанием LF) @@ -116,7 +116,7 @@ io_stream:read( Если arg - table, то записывает каждую строку из таблицы отдельно --]] io_stream:write( - arg: Bytearray | table | string | table, + arg: Bytearray | table | string | table, [опционально] ... ) @@ -128,7 +128,7 @@ io_stream:write_line(string) --[[ В двоичном режиме: - Читает все доступные байты из потока и возвращает ввиде Bytearray или table, если useTable = true + Читает все доступные байты из потока и возвращает ввиде Bytearray или table, если useTable = true В текстовом режиме: Читает все доступные строки из потока в table если useTable = true, или в одну строку вместе с окончаниями, если нет @@ -136,16 +136,18 @@ io_stream:write_line(string) --]] io_stream:read_fully( [опционально] useTable: boolean -) -> Bytearray | table | table | string +) -> Bytearray | table | table | string --[[ Если length определён, то возвращает true, если length байт доступно к чтению. Иначе возвращает false. Если не определён, то возвращает количество байт, которое можно прочитать. + +В не буферизированном режиме потока может всегда возвращать 0 или false, если поток не поддерживает available. --]] io_stream:available( - [опционально] length: number -) -> number | boolean + [опционально] length: int +) -> int | boolean --[[ Устанавливает позицию в потоке (всегда в байтах) @@ -153,21 +155,27 @@ io_stream:available( b - Задаёт позицию относительно начало файла c - Задаёт позицию относительно текущей позиции e - Задаёт позицию относительно конца файла + +Может бросать ошибку, если поток не поддерживает seek. --]] io_stream:seek( mode: string - offset: number + offset: int ) + +-- Возвращает текущую позицию в потоке от начала. +-- Может бросать ошибку, если поток не поддерживает tell. +io_stream:tell() -> int ``` ## Методы Buffered-режима ```lua -- Возвращает максимальный размер буферов -io_stream:get_max_buffer_size() -> number +io_stream:get_max_buffer_size() -> int -- Задаёт новый максимальный размер буферов -io_stream:set_max_buffer_size(max_size: number) +io_stream:set_max_buffer_size(max_size: int) ``` ## Методы контроля состояния потока @@ -183,7 +191,8 @@ io_stream:is_closed() -> bool io_stream:close() -- Записывает все данные из write-буфера в поток в buffer/all flush-режимах --- Вызывает ioLib.flush() в all flush-режиме +-- Вызывает ioLib.flush() в all flush-режиме, или ничего не делает, если +-- ioLib не поддерживает flush. io_stream:flush() -- Создаёт новый поток из Bytearray. @@ -200,7 +209,7 @@ io_stream.wrap_bytearray( -- Создаёт новый поток с переданным дескриптором и использующим переданную I/O библиотеку. (Более подробно в core:io_stream.lua) io_stream.new( descriptor: int, - binaryMode: bool, + binaryMode: boolean, ioLib: table, [опционально] mode: string = "default", [опционально] flushMode: string = "all" From 658af207abc31190233e10ab943d8ed17c23e20a Mon Sep 17 00:00:00 2001 From: Onran Date: Mon, 22 Jun 2026 15:09:20 +0900 Subject: [PATCH 12/18] minor change in binary read_fully --- res/modules/io_stream.lua | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/res/modules/io_stream.lua b/res/modules/io_stream.lua index ef1150237..7a760fa69 100644 --- a/res/modules/io_stream.lua +++ b/res/modules/io_stream.lua @@ -218,7 +218,13 @@ function io_stream:read_fully(useTable) if self.binaryMode then local result = useTable and Bytearray() or { } - readFully(result, function() return self:__read(self.maxBufferSize, true) end) + local avail = self:available() + + if avail == 0 then + avail = self.maxBufferSize + end + + readFully(result, function() return self:__read(avail, true) end) return result else From e7bc0bdbda15a31ac1f6fb3efefecc4c4f8a7049 Mon Sep 17 00:00:00 2001 From: Onran Date: Mon, 22 Jun 2026 15:59:45 +0900 Subject: [PATCH 13/18] major fixes of buffered mode in io_stream - fixed underflow and overflow errors: now stream automatically does flush or read --- res/modules/io_stream.lua | 61 +++++++++++++++++---------------------- 1 file changed, 26 insertions(+), 35 deletions(-) diff --git a/res/modules/io_stream.lua b/res/modules/io_stream.lua index 7a760fa69..10f45d6a4 100644 --- a/res/modules/io_stream.lua +++ b/res/modules/io_stream.lua @@ -127,14 +127,10 @@ function io_stream:set_max_buffer_size(maxBufferSize) end function io_stream:available(length) - local available + local available = self.ioLib.available and self.ioLib.available(self.descriptor) or 0 if self.mode == BUFFERED_MODE then - self:__update_read_buffer() - - available = #self.readBuffer - else - available = self.ioLib.available and self.ioLib.available(self.descriptor) or 0 + available = available + #self.readBuffer end if not length then @@ -144,18 +140,6 @@ function io_stream:available(length) end end -function io_stream:__update_read_buffer() - local readed = Bytearray() - - readFully(readed, function(length) return self.ioLib.read(self.descriptor, length) end) - - self.readBuffer:append(readed) - - if #self.readBuffer > self.maxBufferSize then - error "buffer overflow" - end -end - function io_stream:__read(length, fromReadFully) if self.mode == YIELD_MODE then if fromReadFully then @@ -172,27 +156,23 @@ function io_stream:__read(length, fromReadFully) return buffer elseif self.mode == BUFFERED_MODE then - self:__update_read_buffer() + local bufLen = #self.readBuffer - if #self.readBuffer < length then - error "buffer underflow" + if bufLen < length then + self.readBuffer:append( + self.ioLib.read(self.descriptor, self.maxBufferSize - bufLen) + ) end - local copy + bufLen = #self.readBuffer - if #self.readBuffer == length then - copy = Bytearray() - - copy:append(self.readBuffer) + length = math.min(bufLen, length) + local copy = self.readBuffer:slice(1, length) + + if bufLen == length then self.readBuffer:clear() else - copy = Bytearray() - - for i = 1, length do - copy[i] = self.readBuffer[i] - end - self.readBuffer:remove(1, length) end @@ -204,11 +184,22 @@ end function io_stream:__write(data) if self.mode == BUFFERED_MODE then - self.writeBuffer:append(data) + local dataLength = #data - if #self.writeBuffer > self.maxBufferSize then - error "buffer overflow" + if #self.writeBuffer + dataLength > self.maxBufferSize then + self:flush() end + + if dataLength > self.maxBufferSize then + local toWrite = math.floor(dataLength / self.maxBufferSize) * self.maxBufferSize + local toSave = dataLength - toWrite + + self.ioLib.write(self.descriptor, data:slice(1, toWrite)) + + self:flush() + + self.writeBuffer = data:slice(toWrite + 1, toSave) + else self.writeBuffer:append(data) end elseif self.mode == DEFAULT_MODE or self.mode == YIELD_MODE then return self.ioLib.write(self.descriptor, data) end From 36509fb7bca43d53a1946f51991b094cdb716190 Mon Sep 17 00:00:00 2001 From: Onran Date: Mon, 22 Jun 2026 16:03:52 +0900 Subject: [PATCH 14/18] added bytes reserve when creating buffers for stream --- res/modules/io_stream.lua | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/res/modules/io_stream.lua b/res/modules/io_stream.lua index 10f45d6a4..98a37529c 100644 --- a/res/modules/io_stream.lua +++ b/res/modules/io_stream.lua @@ -93,14 +93,19 @@ function io_stream:set_mode(mode) error("invalid stream mode: "..mode) end - if self.mode == BUFFERED_MODE then + if self.writeBuffer then self.writeBuffer:clear() - self.readBuffer:clear() + self.writeBuffer = nil end - if mode == BUFFERED_MODE and not self.writeBuffer then - self.writeBuffer = Bytearray() - self.readBuffer = Bytearray() + if self.readBuffer then + self.readBuffer:clear() + self.readBuffer = nil + end + + if mode == BUFFERED_MODE then + self.writeBuffer = Bytearray(self.maxBufferSize) + self.readBuffer = Bytearray(self.maxBufferSize) end self.mode = mode @@ -124,6 +129,9 @@ end function io_stream:set_max_buffer_size(maxBufferSize) self.maxBufferSize = maxBufferSize + + self.writeBuffer = Bytearray(self.maxBufferSize) + self.readBuffer = Bytearray(self.maxBufferSize) end function io_stream:available(length) From 7d148ae2cf476368e64b086a987d336288c54675 Mon Sep 17 00:00:00 2001 From: Onran Date: Fri, 24 Jul 2026 03:14:47 +0900 Subject: [PATCH 15/18] all camelCase occurences in io_stream changed to snake_case --- res/modules/io_stream.lua | 212 +++++++++++++++++++------------------- 1 file changed, 108 insertions(+), 104 deletions(-) diff --git a/res/modules/io_stream.lua b/res/modules/io_stream.lua index 98a37529c..522e6ecb7 100644 --- a/res/modules/io_stream.lua +++ b/res/modules/io_stream.lua @@ -25,13 +25,13 @@ local ALL_FLUSH_MODES = { local CR = string.byte('\r') local LF = string.byte('\n') -local function readFully(result, readFunc) +local function read_fully(result, read_func) local isTable = type(result) == "table" local buf repeat - buf = readFunc(MAX_BUFFER_SIZE) + buf = read_func(MAX_BUFFER_SIZE) if isTable then for i = 1, #buf do @@ -59,29 +59,29 @@ ioLib - I/O library. Should include the following functions: close(descriptor: int) --]] -function io_stream.new(descriptor, binaryMode, ioLib, mode, flushMode) +function io_stream.new(descriptor, binary_mode, io_lib, mode, flush_mode) mode = mode or DEFAULT_MODE - flushMode = flushMode or FLUSH_MODE_ALL + flush_mode = flush_mode or FLUSH_MODE_ALL local self = setmetatable({}, io_stream) self.descriptor = descriptor - self.binaryMode = binaryMode - self.maxBufferSize = MAX_BUFFER_SIZE - self.ioLib = ioLib + self.binary_mode = binary_mode + self.max_buffer_size = MAX_BUFFER_SIZE + self.io_lib = io_lib self:set_mode(mode) - self:set_flush_mode(flushMode) + self:set_flush_mode(flush_mode) return self end function io_stream:is_binary_mode() - return self.binaryMode + return self.binary_mode end -function io_stream:set_binary_mode(binaryMode) - self.binaryMode = binaryMode ~= nil +function io_stream:set_binary_mode(binary_mode) + self.binary_mode = binary_mode ~= nil end function io_stream:get_mode() @@ -93,52 +93,52 @@ function io_stream:set_mode(mode) error("invalid stream mode: "..mode) end - if self.writeBuffer then - self.writeBuffer:clear() - self.writeBuffer = nil + if self.write_buffer then + self.write_buffer:clear() + self.write_buffer = nil end - if self.readBuffer then - self.readBuffer:clear() - self.readBuffer = nil + if self.read_buffer then + self.read_buffer:clear() + self.read_buffer = nil end if mode == BUFFERED_MODE then - self.writeBuffer = Bytearray(self.maxBufferSize) - self.readBuffer = Bytearray(self.maxBufferSize) + self.write_buffer = Bytearray(self.max_buffer_size) + self.read_buffer = Bytearray(self.max_buffer_size) end self.mode = mode end function io_stream:get_flush_mode() - return self.flushMode + return self.flush_mode end -function io_stream:set_flush_mode(flushMode) - if not table.has(ALL_FLUSH_MODES, flushMode) then - error("invalid flush mode: "..flushMode) +function io_stream:set_flush_mode(flush_mode) + if not table.has(ALL_FLUSH_MODES, flush_mode) then + error("invalid flush mode: " .. flush_mode) end - self.flushMode = flushMode + self.flush_mode = flush_mode end function io_stream:get_max_buffer_size() - return self.maxBufferSize + return self.max_buffer_size end -function io_stream:set_max_buffer_size(maxBufferSize) - self.maxBufferSize = maxBufferSize +function io_stream:set_max_buffer_size(max_buffer_size) + self.max_buffer_size = max_buffer_size - self.writeBuffer = Bytearray(self.maxBufferSize) - self.readBuffer = Bytearray(self.maxBufferSize) + self.write_buffer = Bytearray(self.max_buffer_size) + self.read_buffer = Bytearray(self.max_buffer_size) end function io_stream:available(length) - local available = self.ioLib.available and self.ioLib.available(self.descriptor) or 0 + local available = self.io_lib.available and self.io_lib.available(self.descriptor) or 0 if self.mode == BUFFERED_MODE then - available = available + #self.readBuffer + available = available + #self.read_buffer end if not length then @@ -148,86 +148,86 @@ function io_stream:available(length) end end -function io_stream:__read(length, fromReadFully) +function io_stream:__read(length, from_read_fully) if self.mode == YIELD_MODE then - if fromReadFully then - return self.ioLib.read(self.descriptor, length) + if from_read_fully then + return self.io_lib.read(self.descriptor, length) end local buffer = Bytearray() while #buffer < length do - buffer:append(self.ioLib.read(self.descriptor, length - #buffer)) + buffer:append(self.io_lib.read(self.descriptor, length - #buffer)) if #buffer < length then coroutine.yield() end end return buffer elseif self.mode == BUFFERED_MODE then - local bufLen = #self.readBuffer + local buf_len = #self.read_buffer if bufLen < length then - self.readBuffer:append( - self.ioLib.read(self.descriptor, self.maxBufferSize - bufLen) + self.read_buffer:append( + self.io_lib.read(self.descriptor, self.max_buffer_size - buf_len) ) end - bufLen = #self.readBuffer + bufLen = #self.read_buffer - length = math.min(bufLen, length) + length = math.min(buf_len, length) - local copy = self.readBuffer:slice(1, length) + local copy = self.read_buffer:slice(1, length) if bufLen == length then - self.readBuffer:clear() + self.read_buffer:clear() else - self.readBuffer:remove(1, length) + self.read_buffer:remove(1, length) end return copy elseif self.mode == DEFAULT_MODE then - return self.ioLib.read(self.descriptor, length) + return self.io_lib.read(self.descriptor, length) end end function io_stream:__write(data) if self.mode == BUFFERED_MODE then - local dataLength = #data + local data_length = #data - if #self.writeBuffer + dataLength > self.maxBufferSize then + if #self.write_buffer + data_length > self.max_buffer_size then self:flush() end - if dataLength > self.maxBufferSize then - local toWrite = math.floor(dataLength / self.maxBufferSize) * self.maxBufferSize - local toSave = dataLength - toWrite + if data_length > self.max_buffer_size then + local to_write = math.floor(data_length / self.max_buffer_size) * self.max_buffer_size + local to_save = data_length - to_write - self.ioLib.write(self.descriptor, data:slice(1, toWrite)) + self.io_lib.write(self.descriptor, data:slice(1, to_write)) self:flush() - self.writeBuffer = data:slice(toWrite + 1, toSave) - else self.writeBuffer:append(data) end + self.write_buffer = data:slice(to_write + 1, to_save) + else self.write_buffer:append(data) end elseif self.mode == DEFAULT_MODE or self.mode == YIELD_MODE then - return self.ioLib.write(self.descriptor, data) + return self.io_lib.write(self.descriptor, data) end end -function io_stream:read_fully(useTable) - if self.binaryMode then - local result = useTable and Bytearray() or { } +function io_stream:read_fully(use_table) + if self.binary_mode then + local result = use_table and { } or Bytearray() local avail = self:available() if avail == 0 then - avail = self.maxBufferSize + avail = self.max_buffer_size end - readFully(result, function() return self:__read(avail, true) end) + read_fully(result, function() return self:__read(avail, true) end) return result else - if useTable then + if use_table then local lines = { } local line @@ -242,7 +242,7 @@ function io_stream:read_fully(useTable) else local result = Bytearray() - readFully(result, function() return self:__read(self.maxBufferSize) end) + read_fully(result, function() return self:__read(self.max_buffer_size) end) return utf8.tostring(result) end @@ -284,57 +284,61 @@ function io_stream:write_line(str) self:__write(utf8.tobytes(str .. "\n")) end -function io_stream:read(arg, useTable) - local argType = type(arg) +function io_stream:read(arg, use_table) + local arg_type = type(arg) - if self.binaryMode then - local byteArr + if self.binary_mode then + local byte_arr - if argType == "number" then + if arg_type == "number" then -- using 'arg' as length - byteArr = self:__read(arg) + byte_arr = self:__read(arg) - if useTable == true then + if use_table == true then local t = { } - for i = 1, #byteArr do - t[i] = byteArr[i] + for i = 1, #byte_arr do + t[i] = byte_arr[i] end return t else - return byteArr + return byte_arr end - elseif argType == "string" then + elseif arg_type == "string" then return byteutil.unpack( arg, self:__read(byteutil.get_size(arg)) ) - elseif argType == nil then + elseif arg_type == "nil" then error( "in binary mode the first argument must be a string data format".. " for the library \"byteutil\" or the number of bytes to read" ) else - error("unknown argument type: "..argType) + error("unknown argument type: "..arg_type) end else if not arg then return self:read_line() else - local linesCount = arg - local trimLastEmptyLines = useTable or true + local lines_count = arg + local trim_last_empty_lines = use_table - if linesCount < 0 then error "count of lines to read must be positive" end + if use_table == nil then + trim_last_empty_lines = true + end + + if lines_count < 0 then error "count of lines to read must be positive" end local result = { } - for i = 1, linesCount do + for i = 1, lines_count do result[i] = self:read_line() end - if trimLastEmptyLines then + if trim_last_empty_lines then local i = #result while i >= 0 do @@ -362,53 +366,53 @@ function io_stream:read(arg, useTable) end function io_stream:write(arg, ...) - local argType = type(arg) + local arg_type = type(arg) - if self.binaryMode then - local byteArr + if self.binary_mode then + local byte_arr - if argType ~= "string" then + if arg_type ~= "string" then -- using arg as bytes table/bytearray - if argType == "table" then - byteArr = Bytearray(arg) + if arg_type == "table" then + byte_arr = Bytearray(arg) else - byteArr = arg + byte_arr = arg end else - byteArr = byteutil.pack(arg, ...) + byte_arr = byteutil.pack(arg, ...) end - self:__write(byteArr) + self:__write(byte_arr) else - if argType == "string" then + if arg_type == "string" then self:write_line(arg) elseif argType == "table" then for i = 1, #arg do self:write_line(arg[i]) end - else error("unknown argument type: "..argType) end + else error("unknown argument type: "..arg_type) end end end function io_stream:seek(mode, offset) - if not self.ioLib.seek then + if not self.io_lib.seek then error("cannot seek this stream") end - self.ioLib.seek(self.descriptor, mode, offset) + self.io_lib.seek(self.descriptor, mode, offset) end function io_stream:tell() - if not self.ioLib.tell then + if not self.io_lib.tell then error("cannot tell this stream") end - return self.ioLib.tell(self.descriptor) + return self.io_lib.tell(self.descriptor) end function io_stream:is_alive() - return self.ioLib.is_alive(self.descriptor) + return self.io_lib.is_alive(self.descriptor) end function io_stream:is_closed() @@ -417,24 +421,24 @@ end function io_stream:close() if self.mode == BUFFERED_MODE then - self.readBuffer:clear() - self.writeBuffer:clear() + self.read_buffer:clear() + self.write_buffer:clear() end - return self.ioLib.close(self.descriptor) + return self.io_lib.close(self.descriptor) end function io_stream:flush() - if self.mode == BUFFERED_MODE and #self.writeBuffer > 0 then - self.ioLib.write(self.descriptor, self.writeBuffer) - self.writeBuffer:clear() + if self.mode == BUFFERED_MODE and #self.write_buffer > 0 then + self.io_lib.write(self.descriptor, self.write_buffer) + self.write_buffer:clear() end - if self.flushMode ~= FLUSH_MODE_ONLY_BUFFER then - if self.ioLib.flush then - self.ioLib.flush(self.descriptor) + if self.flush_mode ~= FLUSH_MODE_ONLY_BUFFER then + if self.io_lib.flush then + self.io_lib.flush(self.descriptor) elseif self:is_closed() then error("stream is closed") end end end -return io_stream +return io_stream \ No newline at end of file From 2bbcb77bcf8dbe953702137b41ba716d36a3e540 Mon Sep 17 00:00:00 2001 From: Onran Date: Fri, 24 Jul 2026 03:29:02 +0900 Subject: [PATCH 16/18] camelCase in some stream providers changed to snake_case --- .../internal/stream_providers/bytearray.lua | 70 +++++++++---------- .../internal/stream_providers/socket.lua | 30 ++++---- 2 files changed, 50 insertions(+), 50 deletions(-) diff --git a/res/modules/internal/stream_providers/bytearray.lua b/res/modules/internal/stream_providers/bytearray.lua index 0f168c851..e377ee784 100644 --- a/res/modules/internal/stream_providers/bytearray.lua +++ b/res/modules/internal/stream_providers/bytearray.lua @@ -5,73 +5,73 @@ local lib = { } local buffers = { } local positions = { } -local nextDescriptor = 0 +local next_descriptor = 0 -local function openDescriptor(buffer) - nextDescriptor = nextDescriptor + 1 +local function open_descriptor(buffer) + next_descriptor = next_descriptor + 1 - buffers[nextDescriptor] = buffer - positions[nextDescriptor] = 1 + buffers[next_descriptor] = buffer + positions[next_descriptor] = 1 - return nextDescriptor + return next_descriptor end -local function requireDescriptor(descriptor) +local function require_descriptor(descriptor) if not buffers[descriptor] then error("unknown descriptor") end end function lib.read(descriptor, length) - requireDescriptor(descriptor) + require_descriptor(descriptor) local buf = buffers[descriptor] - local bufLength = #buf + local buf_length = #buf local pos = positions[descriptor] - local toRead = math.min(bufLength - pos + 1, length) + local to_read = math.min(buf_length - pos + 1, length) - if toRead <= 0 then + if to_read <= 0 then return Bytearray() end - local segment = buf:slice(pos, toRead) + local segment = buf:slice(pos, to_read) - positions[descriptor] = pos + toRead + positions[descriptor] = pos + to_read return segment end function lib.write(descriptor, data) - requireDescriptor(descriptor) + require_descriptor(descriptor) local buf = buffers[descriptor] local pos = positions[descriptor] - local bufLength = #buf - local dataLength = #data + local buf_length = #buf + local data_length = #data - local endPos = pos + dataLength - 1 + local end_pos = pos + data_length - 1 -- size ensuring - if endPos > bufLength then - for i = bufLength + 1, endPos do + if endPos > buf_length then + for i = buf_length + 1, end_pos do buf[i] = 0 end end - for i = 1, dataLength do + for i = 1, data_length do buf[i + pos - 1] = data[i] end - positions[descriptor] = pos + dataLength + positions[descriptor] = pos + data_length end function lib.seek(descriptor, mode, offset) - requireDescriptor(descriptor) + require_descriptor(descriptor) local buf = buffers[descriptor] - local bufLength = #buf + local buf_length = #buf local base @@ -80,26 +80,26 @@ function lib.seek(descriptor, mode, offset) elseif mode == 'c' then base = positions[descriptor] elseif mode == 'e' then - base = bufLength + 1 + base = buf_length + 1 else error('invalid seek mode') end - local newPos = base + offset + local new_pos = base + offset - if newPos < 1 then + if new_pos < 1 then error('failed to seek stream') end - positions[descriptor] = newPos + positions[descriptor] = new_pos end function lib.tell(descriptor) - requireDescriptor(descriptor) + require_descriptor(descriptor) return positions[descriptor] end function lib.available(descriptor) - requireDescriptor(descriptor) + require_descriptor(descriptor) local buf = buffers[descriptor] local pos = positions[descriptor] @@ -112,20 +112,20 @@ function lib.is_alive(descriptor) end function lib.close(descriptor) - requireDescriptor(descriptor) + require_descriptor(descriptor) buffers[descriptor] = nil positions[descriptor] = nil end -return function(buffer, binaryMode) - if binaryMode == nil then - binaryMode = true +return function(buffer, binary_mode) + if binary_mode == nil then + binary_mode = true end return io_stream.new( - openDescriptor(buffer), - binaryMode, + open_descriptor(buffer), + binary_mode, lib ) end \ No newline at end of file diff --git a/res/modules/internal/stream_providers/socket.lua b/res/modules/internal/stream_providers/socket.lua index 0faedd695..c9a728a8b 100644 --- a/res/modules/internal/stream_providers/socket.lua +++ b/res/modules/internal/stream_providers/socket.lua @@ -4,36 +4,36 @@ local lib = { } local sockets = { } -local nextDescriptor = 0 +local next_descriptor = 0 -local function openDescriptor(socket) - nextDescriptor = nextDescriptor + 1 +local function open_descriptor(socket) + next_descriptor = next_descriptor + 1 - sockets[nextDescriptor] = socket + sockets[next_descriptor] = socket - return nextDescriptor + return next_descriptor end -local function requireDescriptor(descriptor) +local function require_descriptor(descriptor) if not sockets[descriptor] then error("unknown descriptor") end end function lib.read(descriptor, length) - requireDescriptor(descriptor) + require_descriptor(descriptor) return sockets[descriptor]:recv(length) end function lib.write(descriptor, data) - requireDescriptor(descriptor) + require_descriptor(descriptor) sockets[descriptor]:send(data) end function lib.available(descriptor) - requireDescriptor(descriptor) + require_descriptor(descriptor) return sockets[descriptor]:available() end @@ -45,20 +45,20 @@ function lib.is_alive(descriptor) end function lib.close(descriptor) - requireDescriptor(descriptor) + require_descriptor(descriptor) sockets[descriptor]:close() sockets[descriptor] = nil end -return function(socket, binaryMode) - if binaryMode == nil then - binaryMode = true +return function(socket, binary_mode) + if binary_mode == nil then + binary_mode = true end return io_stream.new( - openDescriptor(socket), - binaryMode, + open_descriptor(socket), + binary_mode, lib ) end \ No newline at end of file From f539ddf9e0ffd954e46f63793e9ae64182aa3bb3 Mon Sep 17 00:00:00 2001 From: Onran Date: Fri, 24 Jul 2026 03:34:28 +0900 Subject: [PATCH 17/18] docs update --- doc/ru/scripting/builtins/libnetwork.md | 2 +- doc/ru/scripting/io_stream.md | 44 ++++++++++++------------- 2 files changed, 23 insertions(+), 23 deletions(-) diff --git a/doc/ru/scripting/builtins/libnetwork.md b/doc/ru/scripting/builtins/libnetwork.md index 5bc5eaafd..46a3eded8 100644 --- a/doc/ru/scripting/builtins/libnetwork.md +++ b/doc/ru/scripting/builtins/libnetwork.md @@ -94,7 +94,7 @@ socket:recv_async( -- Оборачивает сокет в io_stream (см. ../io_stream.md) socket:as_stream( - [опционально] binaryMode: boolean=true + [опционально] binary_mode: boolean=true ) -> io_stream -- Закрывает соединение diff --git a/doc/ru/scripting/io_stream.md b/doc/ru/scripting/io_stream.md index 57f447643..e54ca1fdb 100644 --- a/doc/ru/scripting/io_stream.md +++ b/doc/ru/scripting/io_stream.md @@ -18,7 +18,7 @@ Поток имеет три различных вида режима: - Режим общего поведения (`general` / `mode`) -- Режим сброса (`flush` / `flushMode`) +- Режим сброса (`flush` / `flush_mode`) - Двоичный режим (`binary`) @@ -27,34 +27,34 @@ Определяет, как поток обрабатывает чтение и запись, имеет три подрежима: -| Режим | Описание | -|---------------|--------| -| `"default"` | Прямой режим. `read` может вернуть меньше байт, чем запрошено. `write` сразу отправляет данные в низкоуровневый дескриптор. Нет буферизации. | +| Режим | Описание | +|---------------|-------------------------------------------------------------------------------------------------------------------------------------------------| +| `"default"` | Прямой режим. `read` может вернуть меньше байт, чем запрошено. `write` сразу отправляет данные в низкоуровневый дескриптор. Нет буферизации. | | `"yield"` | Как `default`, но при нехватке данных в `read(n)` поток будет вызывать `coroutine.yield()`, пока не соберёт ровно `n` байт. Удобно для корутин. | -| `"buffered"` | Включает внутренние буферы чтения и записи. `read` берёт данные из буфера, `write` — складывает в буфер. При превышении `maxBufferSize` — ошибка `buffer overflow`. | +| `"buffered"` | Включает внутренние буферы чтения и записи. `read` берёт данные из буфера , `write` — складывает в буфер. | ### flush Работает только в режиме `"buffered"`, имеет два подрежима: -| Режим | Что делает `flush()` | -|------------------|----------------------| -| `"all"` (по умолчанию) | Сначала сбрасывает буфер записи → низкоуровневый `write`, затем вызывает `ioLib.flush(descriptor)` | -| `"buffer"` | Сбрасывает только буфер записи, без вызова системного `flush` | +| Режим | Что делает `flush()` | +|------------------------|-----------------------------------------------------------------------------------------------------| +| `"all"` (по умолчанию) | Сначала сбрасывает буфер записи → низкоуровневый `write`, затем вызывает `io_lib.flush(descriptor)` | +| `"buffer"` | Сбрасывает только буфер записи, без вызова системного `flush` | ### binary **Независимый флаг** (включается через `set_binary_mode(true)` или при создании потока). Определяет, в каком виде методы `read` и `write` принимают и возвращают данные: -| binary = true | binary = false (по умолчанию) | +| binary = true | binary = false (по умолчанию) | |------------------------------------------------------------|----------------------------------------| | Данные — это **байты** (`Bytearray`, таблица чисел 0..255) | Данные — это **текстовые строки** | | `read(n)` → `Bytearray` или `table` | `read()` → одна строка | -| `read("i4 f")` → распаковка через `byteutil.unpack` | `read(n)` → n строк в таблице | +| `read("i4 f")` → распаковка через `byteutil.unpack` | `read(n)` → n строк в таблице | | `write(Bytearray)` → запись байтов | `write("hello")` → строка + `\n` | -| `write("i4", 42)` → `byteutil.pack` | `write({"a","b"})` → две строки с `\n`| +| `write("i4", 42)` → `byteutil.pack` | `write({"a","b"})` → две строки с `\n` | `read_line` / `write_line` — работают как в текстовом режиме @@ -90,17 +90,17 @@ io_stream:set_flush_mode(string) --[[ Читает данные из потока В двоичном режиме: - Если arg - int, то читает из потока arg байт и возвращает ввиде Bytearray или таблицы, если useTable = true + Если arg - int, то читает из потока arg байт и возвращает ввиде Bytearray или таблицы, если use_table = true Если arg - string, то функция интерпретирует arg как шаблон для byteutil. Прочитает кол-во байт, которое определено шаблоном, передаст их в byteutil.unpack и вернёт результат В текстовом режиме: - Если arg - int, то читает нужное кол-во строк с окончанием CRLF/LF из arg и возвращает ввиде таблицы. Также, если trimEmptyLines = true, то удаляет пустые строки с начала и конца из итоговой таблицы + Если arg - int, то читает нужное кол-во строк с окончанием CRLF/LF из arg и возвращает ввиде таблицы. Также, если trim_empty_lines = true, то удаляет пустые строки с начала и конца из итоговой таблицы Если arg не определён, то читает одну строку с окончанием CRLF/LF и возвращает её. --]] io_stream:read( [опционально] arg: int | string, - [опционально] useTable | trimEmptyLines: boolean + [опционально] use_table = false | trim_empty_lines = true: boolean ) -> Bytearray | table | string | table | ... --[[ @@ -128,14 +128,14 @@ io_stream:write_line(string) --[[ В двоичном режиме: - Читает все доступные байты из потока и возвращает ввиде Bytearray или table, если useTable = true + Читает все доступные байты из потока и возвращает ввиде Bytearray или table, если use_table = true В текстовом режиме: - Читает все доступные строки из потока в table если useTable = true, или в одну строку вместе с окончаниями, если нет + Читает все доступные строки из потока в table если use_table = true, или в одну строку вместе с окончаниями, если нет --]] io_stream:read_fully( - [опционально] useTable: boolean + [опционально] use_table: boolean ) -> Bytearray | table | table | string --[[ @@ -203,15 +203,15 @@ io_stream.wrap_bytearray( -- по-умолчанию равен true, поскольку функция из вводных аргументов -- будет использоваться преимущественно для работы с двоичными данными. - [опционально] binaryMode: boolean = true + [опционально] binary_mode: boolean = true ) -> io_stream -- Создаёт новый поток с переданным дескриптором и использующим переданную I/O библиотеку. (Более подробно в core:io_stream.lua) io_stream.new( descriptor: int, - binaryMode: boolean, - ioLib: table, + binary_mode: boolean, + io_lib: table, [опционально] mode: string = "default", - [опционально] flushMode: string = "all" + [опционально] flush_mode: string = "all" ) -> io_stream ``` \ No newline at end of file From 19237b60dce3737cb9aef4bbc5ae8eccd767cd40 Mon Sep 17 00:00:00 2001 From: Onran Date: Fri, 24 Jul 2026 04:01:33 +0900 Subject: [PATCH 18/18] fixes --- res/modules/internal/stream_providers/bytearray.lua | 2 +- res/modules/io_stream.lua | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/res/modules/internal/stream_providers/bytearray.lua b/res/modules/internal/stream_providers/bytearray.lua index e377ee784..a10b11cdf 100644 --- a/res/modules/internal/stream_providers/bytearray.lua +++ b/res/modules/internal/stream_providers/bytearray.lua @@ -54,7 +54,7 @@ function lib.write(descriptor, data) local end_pos = pos + data_length - 1 -- size ensuring - if endPos > buf_length then + if end_pos > buf_length then for i = buf_length + 1, end_pos do buf[i] = 0 end diff --git a/res/modules/io_stream.lua b/res/modules/io_stream.lua index 522e6ecb7..8776ca810 100644 --- a/res/modules/io_stream.lua +++ b/res/modules/io_stream.lua @@ -166,19 +166,19 @@ function io_stream:__read(length, from_read_fully) elseif self.mode == BUFFERED_MODE then local buf_len = #self.read_buffer - if bufLen < length then + if buf_len < length then self.read_buffer:append( self.io_lib.read(self.descriptor, self.max_buffer_size - buf_len) ) end - bufLen = #self.read_buffer + buf_len = #self.read_buffer length = math.min(buf_len, length) local copy = self.read_buffer:slice(1, length) - if bufLen == length then + if buf_len == length then self.read_buffer:clear() else self.read_buffer:remove(1, length) @@ -387,7 +387,7 @@ function io_stream:write(arg, ...) else if arg_type == "string" then self:write_line(arg) - elseif argType == "table" then + elseif arg_type == "table" then for i = 1, #arg do self:write_line(arg[i]) end