trace

local args = {...}

if not args[1] then
    print("Usage:")
    print(shell.getRunningProgram() .. " <program> [program arguments, ...]")
    return
end

local path = shell.resolveProgram(args[1]) or shell.resolve(args[1])

-- here be dragons
local function buildStackTrace(rootErr)
    local trace = {}
    local i, hitEnd, _, e = 4, false

    repeat
        _, e = pcall(function() error("<tracemarker>", i) end)
        i = i + 1
        if e == "xpcall: <tracemarker>" or e == "pcall: <tracemarker>" then
            hitEnd = true
            break
        end
        table.insert(trace, e)
    until i > 10

    table.remove(trace)
    table.remove(trace, 1)

    if rootErr:match("^" .. trace[1]:match("^(.-:%d+)")) then table.remove(trace, 1) end

    local out = {}

    table.insert(out, rootErr)

    for i, v in ipairs(trace) do
        table.insert(out, "  at " .. v:match("^(.-:%d+)"))
    end

    if not hitEnd then
        table.insert(out, "  ...")
    end

    return table.concat(out, "\n")
end

if fs.exists(path) then
    local eshell = setmetatable({getRunningProgram=function() return path end}, {__index = shell})
    local env = setmetatable({shell=eshell}, {__index=_ENV})

    env.pcall = function(f, ...)
        local args = { ... }
        return xpcall(function() f(unpack(args)) end, buildStackTrace)
    end

    env.xpcall = function(f, e)
        return xpcall(function() f() end, function(err) e(buildStackTrace(err)) end)
    end

    local f = fs.open(path, "r")
    local d = f.readAll()
    f.close()

    local func, e = load(d, fs.getName(path), nil, env)
    if not func then
        printError("Syntax error:")
        printError("  " .. e)
    else
        table.remove(args, 1)
        xpcall(function() func(unpack(args)) end, function(err)
            local stack = buildStackTrace(err)
            printError("\nProgram has crashed! Stack trace:")
            printError(stack)
        end)
    end
else
    printError("program not found")
end