Turti installer

local argsSource = { ... }

function splitText(source, letters)
    local parts = {}
    local akt = "";
    local qM1 = 0;
    local qM2 = 0;
    local b1 = 0;
    local b2 = 0;
    local b3 = 0;
    for i = 1, #source do
        local z = string.sub(source, i, i)
        if z == "'" and qM2 == 0 then
            qM1 = 1 - qM1;
        elseif z == "\"" and qM1 == 0 then
            qM2 = 1 - qM2;
        elseif qM1 == 0 and qM2 == 0 then
            if z == "(" then
                b1 = b1 + 1
            elseif z == ")" then
                b1 = b1 - 1
            elseif z == "[" then
                b2 = b2 + 1
            elseif z == "]" then
                b2 = b2 - 1
            elseif z == "{" then
                b3 = b3 + 1
            elseif z == "}" then
                b3 = b3 - 1
            end
        end
        local split = false
        if b1 == 0 and b2 == 0 and b3 == 0 and qM1 == 0 and qM2 == 0 then
            for j = 1, #letters do
                if z == string.sub(letters, j, j) then
                    split = true
                    break
                end
            end
        end
        if split then
            if akt ~= "" then
                table.insert(parts, akt)
                akt = ""
            end
        else
            akt = akt .. z
        end
    end
    if akt ~= "" then
        table.insert(parts, akt)
    end
    return parts
end

local args = {}

local TYPE_DECLARATION = 0
local TYPE_TABLE = 1
local TYPE_TABLE_MAP = 1
local TYPE_TABLE_ARR = 2
local TYPE_VALUE = 2
local TYPE_CONSTANT = 3
local TYPE_PASTEBIN = 4

if peripheral == nil then
    _G.os.reboot = function()
        print("fct: os.reboot()")
    end
    _G.os.setComputerLabel = function(label)
        print("fct: os.setComputerLabel(\"" .. label .. "\")")
    end
end

function getTypeName(t)
    if t == TYPE_DECLARATION then
        return "declaration"
    elseif t == TYPE_TABLE then
        return "table"
    elseif t == TYPE_VALUE then
        return "value"
    elseif t == TYPE_CONSTANT then
        return "constant"
    elseif t == TYPE_PASTEBIN then
        return "pastebin"
    else
        error("unknown type: " .. t)
    end
end

function loadArgData(arg)
    local v = loadVar(arg)
    if v.type ~= TYPE_DECLARATION then
        error("every argument of this program needs to be of type 'declaration'")
    end
    return v
end

function readFileText(file)
    local f = fs.open(file, "r")
    local text = f.readAll()
    f.close()
    return text
end

function tryMatches(var, format, name)
    if not string.match(var, format) == var then
        error("invalid " .. name .. ": '" .. var .. "'")
    end
end

function loadVar(source)

    local pts = splitText(source, "=")
    if #pts > 1 then
        if #pts > 2 then
            error("only one '=' in declaration")
        end
        tryMatches(pts[1], "[A-Za-z_][A-Za-z0-9_]*", "dec-name")
        return { type = TYPE_DECLARATION, name = pts[1], value = loadVar(pts[2]) }
    end

    if string.sub(source, 1, 1) == "{" and string.sub(source, #source) == "}" then
        local pts = splitText(string.sub(source, 2, #source - 1), ",")
        local values = {}
        for i, pt in pairs(pts) do
            local v = loadVar(pt)
            if v.type == TYPE_DECLARATION then
                values[v.name] = v.value
            else
                table.insert(values, v)
            end
        end
        return { type = TYPE_TABLE, values = values }
    elseif string.sub(source, 1, 1) == "<" and string.sub(source, #source) == ">" then
        source = string.sub(source, 2, #source - 1)
        local ind = string.find(source, ":")
        local action = string.sub(source, 1, ind - 1)
        tryMatches(action, "[A-Za-z_][A-Za-z0-9_]*", "action-name")
        if action == "pb" then
            local id = string.sub(source, ind + 1)
            tryMatches(id, "[A-Za-z_][A-Za-z0-9_]*", "pastebinId-name")
            return { type = TYPE_PASTEBIN, id = id }
        elseif action == "input" then
            local v = loadVar(string.sub(source, ind + 1))
            if v.type ~= TYPE_VALUE or type(v.value) ~= "string" then
                error("string value expected for function <input:''>")
            end
            io.write("input<" .. v.value .. ">: ")
            local data = io.read()
            return { type = TYPE_VALUE, value = data }
        elseif action == "inputNum" then
            local v = loadVar(string.sub(source, ind + 1))
            if v.type ~= TYPE_VALUE or type(v.value) ~= "string" then
                error("string value expected for function <input:''>")
            end
            io.write("inputNum<" .. v.value .. ">: ")
            local data = tonumber(io.read())
            return { type = TYPE_VALUE, value = data }
        else
            error("unknown action: '" .. action .. "'")
        end
    elseif string.sub(source, 1, 1) == "'" and string.sub(source, #source) == "'" then
        return { type = TYPE_VALUE, value = string.sub(source, 2, #source - 1) }
    elseif string.sub(source, 1, 1) == "$" and string.sub(source, #source) == "$" then
        local name = string.sub(source, 2, #source - 1)
        return { type = TYPE_CONSTANT, name = name }
    elseif source == "true" or source == "false" then
        return { type = TYPE_VALUE, value = source == "true" }
    elseif tonumber(source) ~= nil then
        return { type = TYPE_VALUE, value = tonumber(source) }
    else
        error("invalid source: '" .. source .. "'")
    end
end

function checkType(name, value, t, t2)
    if value.type ~= t then
        error("value '" .. name .. "' needs to be of type '" .. getTypeName(t) .. "' (type '" .. getTypeName(value.type) .. "' given)")
    end
    if t2 ~= nil then
        if value.type == TYPE_TABLE then
            if t2 == TYPE_TABLE_MAP then
                for i, _ in pairs(value.values) do
                    if type(i) == "number" then
                        error("table '" .. name .. "' needs to be a map")
                    end
                end
            elseif t2 == TYPE_TABLE_ARR then
                for i, _ in pairs(value.values) do
                    if type(i) == "string" then
                        error("table '" .. name .. "' needs to be an array")
                    end
                end
            else
                error("unknown type2: '" .. t2 .. "'")
            end
        elseif value.type == TYPE_VALUE then
            if type(value.value) ~= t2 then
                error("value '" .. name .. "' needs to be of type '" .. t2 .. "' (type '" .. type(value.value .. "' given)"))
            end
        end
    end
end

function writeToFile(fileName, data)
    local f = fs.open(fileName, "w")
    f.write(data)
    f.close()
end

local startupBuildData = {
    files = {},
    cmds = {}
}

local reboot = false

local functions = {
    startup = {
        delay = function(data)
            checkType("startup>delay", data, TYPE_VALUE, "number")
            startupBuildData.delay = data.value
        end,
        files = function(data)
            checkType("startup>files", data, TYPE_TABLE, TYPE_TABLE_MAP)
            for fileName, v in pairs(data.values) do
                checkType("startup>files>value", v, TYPE_PASTEBIN)
                table.insert(startupBuildData.files, { name = fileName, id = v.id })
            end
        end,
        cmds = function(data)
            checkType("startup>cmds", data, TYPE_TABLE, TYPE_TABLE_ARR)
            for i, cmd in pairs(data.values) do
                checkType("startup>cmds>cmd", cmd, TYPE_TABLE, TYPE_TABLE_ARR)
                table.insert(startupBuildData.cmds, cmd.values)
            end
        end
    },
    reboot = function(data)
        checkType("reboot", data, TYPE_VALUE, "boolean")
        reboot = data.value
    end,
    label = function(data)
        checkType("label", data, TYPE_VALUE, "string")
        os.setComputerLabel(data.value)
    end
}

for i, v in pairs(argsSource) do
    table.insert(args, loadArgData(v))
end

function printTable(tbl)
    printTableIndex(tbl, "", {})
end

function printTableIndex(tbl, before, alreadyUsed)
    for i, v in pairs(tbl) do
        if type(v) == "table" then
            if tableContainsValue(alreadyUsed, v) then
                print(before .. i .. ":", "alreadyUsed");
            else
                print(before .. i .. ": [");
                table.insert(alreadyUsed, v)
                printTableIndex(v, before .. "\t", alreadyUsed)
                print(before .. "]")
            end
        else
            print(before .. i .. ":", v);
        end
    end
end

function tableContainsValue(table, value)
    for i, v in pairs(table) do
        if v == value then
            return true
        end
    end
    return false
end

function executeFunction(tName, name, data, functions)
    for n, fct in pairs(functions) do
        if name == n then
            if type(fct) == "table" then
                tName = tName .. "[" .. name .. "]"
                checkType(tName .. ".value", data, TYPE_TABLE, TYPE_TABLE_MAP)
                for n1, v in pairs(data.values) do
                    executeFunction(tName, n1, v, fct)
                end
            else
                fct(data)
            end
            return
        end
    end
    error("function-name '" .. name .. "' isn't allowed for '" .. tName .. "'")
end

function writeToFile(fileName, data)
    if fs == nil then
        local f = io.open(fileName, "w")
        io.output(f)
        io.write(data)
        io.close(f)
    else
        local f = fs.open(fileName, "w")
        f.write(data)
        f.close()
    end
end

for i, v in pairs(args) do
    local tName = "level0-argument"
    executeFunction(tName, v.name, v.value, functions)
end

function replaceConstants(v, constants)
    if v.type == TYPE_CONSTANT then
        if constants[v.name] ~= nil then
            return { type = TYPE_VALUE, value = constants[v.name] }
        end
    elseif v.type == TYPE_TABLE then
        for i, v1 in pairs(v.values) do
            v.values[i] = replaceConstants(v1, constants)
        end
    elseif v.type ~= TYPE_VALUE then
        error("unsupported type: '" .. getTypeName(v.type) .. "'")
    end
    return v
end

local txt = "local args={...}\n"

if startupBuildData.delay ~= nil then
    txt = txt .. "sleep(" .. startupBuildData.delay .. ")\n"
end

for i, f in pairs(startupBuildData.files) do
    txt = txt .. "if fs.exists(\"" .. f.name .. "\") then\n"
    txt = txt .. "    shell.run(\"delete\", \"" .. f.name .. "\")\n"
    txt = txt .. "end\n"
    txt = txt .. "first=true\n"
    txt = txt .. "while not fs.exists(\"" .. f.name .. "\") do\n"
    txt = txt .. "    if first then\n first=false\n"
    txt = txt .. "    else\n"
    txt = txt .. "        print(\""..f.id..": retrying in 1s\")\nsleep(1)\n"
    txt = txt .. "    end\n"
    txt = txt .. "    shell.run(\"pastebin\",\"get\", \"" .. f.id .. "\", \"" .. f.name .. "\")\n"
    txt = txt .. "end\n"
end

for i, cmd in pairs(startupBuildData.cmds) do
    cmd = replaceConstants({ type = TYPE_TABLE, values = cmd }, { arg1 = "raw:args[1]", arg2 = "raw:args[2]" }).values
    for i, v in pairs(cmd) do
        checkType("cmds>cmd", v, TYPE_VALUE, "string")
    end
    txt = txt .. "shell.run("
    for i, v in pairs(cmd) do
        if i ~= 1 then
            txt = txt .. ","
        end
        if string.sub(v.value, 1, 4) == "raw:" then
            txt = txt .. string.sub(v.value, 5)
        else
            txt = txt .. "\"" .. v.value .. "\""
        end
    end
    txt = txt .. ")\n"
end

writeToFile("startup", txt)

if reboot then
    os.reboot()
end