LyqydOs/env bug report version

--Peripheral modifications.
do
    local oldPeripheralCall = peripheral.call

    function peripheral.call(side, func, ...)
        if peripheral.getType(side) == "modem" then
            if func == "isOpen" then
                local proc = process.id() and process.list[process.id()]
                if not proc then return false end
                if not proc.modem then return false end
                if not proc.modem[side] then return false end
                if proc.modem[side][(...)] then return true end
                return false
            elseif func == "open" then
                local proc = process.list[process.id()]
                if not proc.modem then proc.modem = {} end
                if not proc.modem[side] then proc.modem[side] = {} end
                local channel = (...)
                proc.modem[side][channel] = true
                oldPeripheralCall(side, func, channel)
            elseif func == "close" then
                local proc = process.list[process.id()]
                if not proc.modem then return nil end
                if not proc.modem[side] then return nil end
                local channel = (...)
                if proc.modem[side][channel] then
                    proc.modem[side][channel] = nil
                    local close = true
                    for pID, pInfo in pairs(process.list) do
                        if pInfo and pInfo.modem and pInfo.modem[side] and pInfo.modem[side][channel] then
                            close = false
                            break
                        end
                    end
                    if close then return oldPeripheralCall(side, func, channel) end
                end
            elseif func == "closeAll" then
                local proc = process.list[process.id()]
                if not proc.modem then return nil end
                if not proc.modem[side] then return nil end
                for channel in pairs(proc.modem[side]) do
                    peripheral.call(side, "close", channel)
                end
            else
                return oldPeripheralCall(side, func, ...)
            end
        else
            return oldPeripheralCall(side, func, ...)
        end
    end
end

--Rednet modifications
do
    local validSides = {}
    for k, v in pairs(rs.getSides()) do
        validSides[v] = true
    end

    local function validateSide(side)
        if type(side) ~= "string" then
            error("string expected", 3)
        end
        if not validSides[side] then
            error("Invalid side", 3)
        end
        if peripheral.getType(side) ~= "modem" then
            error("No modem on "..side.." side", 3)
        end
        return true
    end

    function rednet.open(side)
        if validateSide(side) then
            local proc = process.this()
            if not proc.rednet then proc.rednet = {} end
            proc.rednet[side] = true
            peripheral.call(side, "open", os.getComputerID())
            peripheral.call(side, "open", 65535)
        end
    end

    function rednet.close(side)
        if validateSide(side) then
            local proc = process.this()
            if not proc.rednet then return nil end
            proc.rednet[side] = nil
            peripheral.call(side, "close", os.getComputerID())
            peripheral.call(side, "close", 65535)
        end
    end

    function rednet.isOpen(side)
        if side then
            if type(side) ~= "string" then
                error("expected string", 2)
            end
            if peripheral.getType(side) == "modem" then
                local proc = process.this()
                if not proc.modem then return false end
                if not proc.modem[side] then return false end
                return (proc.modem[side][os.getComputerID()] and proc.modem[side][65535]) or false
            end
        else
            for n, side in ipairs(peripheral.getNames()) do
                if rednet.isOpen(side) then
                    return true
                end
            end
        end
    end

    function rednet.send(recipient, message, protocol)
        for _, side in pairs(rs.getSides()) do
            if peripheral.getType(side) == "modem" and rednet.isOpen(side) then
                if term.current then
                    local id = math.random(1, 2147483547)
                    local messTable = {
                        nMessageID = id,
                        nRecipient = recipient,
                        message = message,
                        sProtocol = protocol,
                    }
                    peripheral.call(side, "transmit", recipient, os.getComputerID(), messTable)
                    peripheral.call(side, "transmit", 65533, os.getComputerID(), messTable)
                else
                    peripheral.call(side, "transmit", recipient, os.getComputerID(), message)
                end
                return true
            end
        end
        error("No open sides", 2)
    end

    function rednet.broadcast(message, protocol)
        return rednet.send(65535, message, protocol)
    end

    function rednet.host(protocol, hostname)
        if type(protocol) ~= "string" or type(hostname) ~= "string" then
            error("expected string, string", 2)
        end
        if hostname == "localhost" then
            error("Reserved hostname", 2)
        end
        local proc = process.this()
        if not proc.rednet then proc.rednet = {} end
        if not proc.rednet.hosting then proc.rednet.hosting = {} end
        if rednet.lookup(protocol, hostname) ~= nil then
            error("Hostname in use", 2)
        end
        proc.rednet.hosting[protocol] = hostname
    end

    function rednet.unhost(protocol)
        if type(protocol) ~= "string" then
            error("expected string", 2)
        end
        local proc = process.this()
        if not proc.rednet then return end
        if not proc.rednet.hosting then return end
        proc.rednet.hosting[protocol] = nil
    end

    function rednet.lookup(protocol, hostname)
        if type(protocol) ~= "string" then
            error("expected string", 2)
        end

        local result
        if not hostname then
            result = {}
        end

        for pID, proc in ipairs(process.list) do
            if proc and proc.rednet and proc.rednet.hosting then
                if proc.rednet.hosting[protocol] then
                    if not hostname then
                        table.insert(result, os.getComputerID())
                    elseif hostname == "localhost" or hostname == proc.rednet.hosting[protocol] then
                        return os.getComputerID()
                    end
                end
            end
        end

        if not rednet.isOpen() then
            if result then
                unpack(result)
            end
            return nil
        end

        rednet.broadcast({sType = "lookup", sProtocol = protocol, sHostname = hostname,}, "dns")

        local timer = os.startTimer(2)
        while true do
            local event = {os.pullEvent()}
            if event[1] == "rednet_message" then
                if event[4] == "dns" and event[3].sType == "lookup response" then
                    if event[3].sProtocol == protocol then
                        if not hostname then
                            table.insert(result, event[2])
                        elseif event[3].sHostname == hostname then
                            return event[2]
                        end
                    end
                end
            elseif event[1] == "timer" and event[2] == timer then
                break
            end
        end
        if result then
            return unpack(result)
        end
    end
end

--FS modifications.
do
    local oldfs = {}
    for k, v in pairs(fs) do
        if type(k) == "string" and type(v) == "function" then
            oldfs[k] = v
        end
    end

    LyqydOS.fs = {}
    LyqydOS.fs.raw = oldfs
    LyqydOS.fs.mounts = {}

    LyqydOS.fs.canMountToPath = function(path)
        if string.sub(path, 1, 1) ~= "/" then
            path = "/"..path
        end
        for i, mount in ipairs(LyqydOS.fs.mounts) do
            if mount and mount.path == path then
                return false
            end
        end
        if LyqydOS.fs.raw.exists(path) and LyqydOS.fs.raw.isDir(path) then
            local list = LyqydOS.fs.raw.list(path)
            if #list == 0 then
                return true
            end
        end
        return false
    end

    local function getMountID(path)
        if string.sub(path, 1, 1) ~= "/" then
            path = "/"..path
        end
        local matchLen, matchID = 0, false
        for i, mnt in ipairs(LyqydOS.fs.mounts) do
            local match = string.match(path, "^("..mnt.path..")")
            if match and #match > matchLen then
                matchLen = #match
                matchID = i
            end
        end
        if matchID then
            return matchID
        end
    end

    local function getMount(path)
        local id = getMountID(path)
        if id then
            return LyqydOS.fs.mounts[id]
        end
    end

    local function getRelativePath(path, mount)
        if string.sub(path, 1, 1) ~= "/" then
            path = "/"..path
        end
        return string.match(path, "^"..mount.path.."(.*)")
    end

    local function yield()
        local key = tostring({})
        os.queueEvent("vfs_yield", key)
        local event, val
        repeat
            event, val = os.pullEvent()
        until event == "vfs_yield" and val == key
    end

    local fsTransformTable = {
        "list",
        "exists",
        "isDir",
        "isReadOnly",
        "getSize",
        "getFreeSpace",
        "makeDir",
        "delete",
        "find",
    }

    for i, name in ipairs(fsTransformTable) do
        fs[name] = function(path)
            local mnt = getMount(path)
            if mnt then
                return mnt.mount[name](getRelativePath(path, mnt))
            else
                return oldfs[name](path)
            end
        end
    end

    fs.getDrive = function(path)
        local id = getMountID(path)
        if id then
            return "lyq_vfs_"..tostring(id)
        else
            return oldfs.getDrive(path)
        end
    end

    fs.move = function(origin, destination)
        local omnt = getMount(origin)
        local dmnt = getMount(destination)
        if omnt == dmnt and omnt then
            --both file paths are within the same mount point
            omnt.mount.move(getRelativePath(origin, omnt), getRelativePath(destination, omnt))
        elseif omnt then
            --the origin file has a mount point.
            local data = omnt.mount.get(getRelativePath(origin, omnt))
            if dmnt then
                dmnt.mount.put(getRelativePath(destination, dmnt), data)
            else
                local handle = oldfs.open(destination, "wb")
                if handle then
                    for i = 1, #data do
                        handle.write(data[i])
                        if i % 1000 == 0 then yield() end
                    end
                    handle.close()
                end
            end
            omnt.mount.delete(getRelativePath(origin, omnt))
        elseif dmnt then
            --the origin file does not have a mount point, but the destination does.
            local handle = oldfs.open(origin, "rb")
            if handle then
                local data = {}
                local num = handle.read()
                while num do
                    table.insert(data, num)
                    num = handle.read()
                    if #data % 1000 == 0 then yield() end
                end
                dmnt.mount.put(getRelativePath(destination, dmnt), data)
                handle.close()
            end
            oldfs.delete(origin)
        else
            oldfs.move(origin, destination)
        end
    end

    fs.copy = function(origin, destination)
        local omnt = getMount(origin)
        local dmnt = getMount(destination)
        if omnt == dmnt and omnt then
            --both file paths are within the same mount point
            omnt.mount.copy(getRelativePath(origin, omnt), getRelativePath(destination, omnt))
        elseif omnt then
            --the origin file has a mount point.
            local data = omnt.mount.get(getRelativePath(origin, omnt))
            if dmnt then
                dmnt.mount.put(getRelativePath(destination, dmnt), data)
            else
                local handle = oldfs.open(destination, "wb")
                if handle then
                    for i = 1, #data do
                        handle.write(data[i])
                        if i % 1000 == 0 then yield() end
                    end
                    handle.close()
                end
            end
        elseif dmnt then
            --the origin file does not have a mount point, but the destination does.
            local handle = oldfs.open(origin, "rb")
            if handle then
                local data = {}
                local num = handle.read()
                while num do
                    table.insert(data, num)
                    num = handle.read()
                    if #data % 1000 == 0 then yield() end
                end
                dmnt.mount.put(getRelativePath(destination, dmnt), data)
                handle.close()
            end
        else
            oldfs.copy(origin, destination)
        end
    end

    fs.open = function(path, mode)
        local mount = getMount(path)
        if mount then
            if mode == "r" then
                local data = string.char(unpack(mount.mount.get(getRelativePath(path, mount))))
                local seek = 0
                local handle = {
                    readLine = function()
                        if seek < #data then
                            local line
                            line, seek = string.match(data, "([^\n]*)\r?\n-()", seek + 1)
                            return line
                        end
                    end,
                    readAll = function()
                        if seek <= #data then
                            local line
                            line, seek = string.match(data, "(.*)()", seek)
                            return line
                        end
                    end,
                    close = function()
                        seek = #data + 1
                    end,
                }
                return handle
            elseif mode == "rb" then
                local data = mount.mount.get(getRelativePath(path, mount))
                local seek = 0
                local handle = {
                    read = function()
                        if seek < #data then
                            seek = seek + 1
                            return data[seek]
                        end
                    end,
                    close = function()
                        seek = #data
                    end
                }
                return handle
            elseif mode == "w" or mode == "a" then
                local data = ""
                if mode == "a" then
                    data = string.char(unpack(mount.mount.get(getRelativePath(path, mount))))
                end
                local open = true
                local handle = {
                    writeLine = function(str)
                        if open then
                            data = data..str.."\n"
                        end
                    end,
                    write = function(str)
                        if open then
                            data = data..str
                        end
                    end,
                    flush = function()
                        if open then
                            mount.mount.put(getRelativePath(path, mount), {string.byte(data, 1, -1)})
                        end
                    end,
                    close = function()
                        if open then
                            mount.mount.put(getRelativePath(path, mount), {string.byte(data, 1, -1)})
                            open = false
                        end
                    end,
                }
                return handle
            elseif mode == "wb" or mode == "ab" then
                local data = {}
                if mode == "ab" then
                    data = mount.mount.get(getRelativePath(path, mount))
                end
                local open = true
                local handle = {
                    write = function(num)
                        if open then
                            data[#data + 1] = num
                        end
                    end,
                    flush = function()
                        if open then
                            mount.mount.put(getRelativePath(path, mount), data)
                        end
                    end,
                    close = function()
                        if open then
                            mount.mount.put(getRelativePath(path, mount), data)
                            open = false
                        end
                    end,
                }
                return handle
            end
        else
            return oldfs.open(path, mode)
        end
    end
end

--Disk modifications.
do
    local oldGetMountPath = disk.getMountPath

    disk.getMountPath = function(side)
        local drive, num = string.match(side, "(.-)_(%d+)$")
        if drive == "lyq_vfs" then
            return LyqydOS.fs.mounts[tonumber(num)].path
        else
            return oldGetMountPath(side)
        end
    end
end

--Redstone modifications.
do
    local oldrs = {}
    for k, v in pairs(rs) do
        if type(k) == "string" and type(v) == "function" then
            oldrs[k] = v
        end
    end

    local validSides = {}
    for k, v in pairs(rs.getSides()) do
        validSides[v] = true
    end

    local function validate(side, value, exType)
        if type(side) ~= "string" or type(value) ~= exType then
            error("Expected string, "..exType)
        end
        if not validSides[side] then
            error("Invalid side")
        end
        return true
    end

    local function getCurrentValue(side)
        local value = 0
        for pID, pInfo in pairs(process.list) do
            if pInfo and pInfo.redstone and pInfo.redstone[side] and pID ~= process.id() then
                value = math.max(value, pInfo.redstone[side].value)
            end
        end
        return value
    end

    local function getCurrentBundled(side)
        local value = 0
        for pID, pInfo in pairs(process.list) do
            if pInfo and pInfo.redstone and pInfo.redstone[side] and pID ~= process.id() then
                value = bit.bor(value, pInfo.redstone[side].bundled)
            end
        end
        return value
    end

    redstone.setAnalogOutput = function(side, value)
        if validate(side, value, "number") then
            local current = getCurrentValue(side)
            local proc = process.list[process.id()]
            if not proc.redstone then proc.redstone = {} end
            if not proc.redstone[side] then proc.redstone[side] = {} end
            proc.redstone[side].value = value
            value = math.max(value, current)
            oldrs.setAnalogOutput(side, value)
        end
    end

    redstone.setOutput = function(side, value)
        if validate(side, value, "boolean") then
            redstone.setAnalogOutput(side, value == true and 15 or 0)
        end
    end

    redstone.setBundledOutput = function(side, value)
        if validate(side, value, number) then
            local current = getCurrentBundled(side)
            local proc = process.list[process.id()]
            if not proc.redstone then proc.redstone = {} end
            if not proc.redstone[side] then proc.redstone[side] = {} end
            proc.redstone[side].bundled = value
            value = bit.bor(value, current)
            oldrs.setBundledOutput(side, value)
        end
    end
end

--shell and multishell modifications
do
    LyqydOS.shell.multishell.getTitle = function(n)
        if process.list[n] then
            return process.list[n].name
        end
    end

    LyqydOS.shell.multishell.setTitle = function(n, title)
        if process.list[n] then
            process.list[n].name = title
        end
    end

    LyqydOS.shell.multishell.getCount = function()
        return #process.list
    end

    LyqydOS.shell.multishell.launch = function(env, path, ...)
        local args = {...}
        if path then
            local pid = #process.list + 1
            local redirect, bufNum = process.compositor:newBuffer(pid)
            process.new(function() os.run(env, shell.resolveProgram("lsh"), path, unpack(args)) end, shell.resolveProgram("lsh"), redirect)
            process.compositor:toBack(bufNum)
            return pid
        else
            return false
        end
    end

    LyqydOS.shell.multishell.getCurrent = function()
        return process.id()
    end

    LyqydOS.shell.multishell.getFocus = function()
        return process.focus
    end

    LyqydOS.shell.multishell.setFocus = function(n)
        if process.list[n] then
            local proc = process.list[n]
            process.focus = n
            --bring the buffer to the top
            local buf = proc.firstRedirect.buffer
            for i, layer in ipairs(process.compositor.bufferStack) do
                if layer == buf then
                    process.compositor:toFront(i)
                    break
                end
            end
        end
    end

    LyqydOS.shell.shell.openTab = function(...)
        local env = {shell = LyqydOS.shell.shell, multishell = LyqydOS.shell.multishell}
        local command = table.concat({...}, " ")
        local args = {}
        for match in string.gmatch(command, "[^ \t]+") do
            table.insert(args, match)
        end
        local path = table.remove(args, 1)
        return LyqydOS.shell.multishell.launch(env, path, unpack(args))
    end

    LyqydOS.shell.shell.switchTab = function(n)
        LyqydOS.shell.multishell.setFocus(n)
    end
end