StackTracePlus lua debug for SAPP

-- For use with lua scripts.  Add the following to your script(s) then load/run them.
-- If there is an error, it will tell you which script, and which line the error is on in console window.

-- add these 3 lines to each of your lua scripts (and uncomment them by removing "--" :

--function OnError(Message)
    --print(debug.traceback())
--end

-- tables
local _G = _G
local string, io, debug, coroutine = string, io, debug, coroutine

-- functions
local tostring, print, require = tostring, print, require
local next, assert = next, assert
local pcall, type, pairs, ipairs = pcall, type, pairs, ipairs
local error = error

assert(debug, "debug table must be available at this point")

local io_open = io.open
local string_gmatch = string.gmatch
local string_sub = string.sub
local table_concat = table.concat

local _M = {
    max_tb_output_len = 70  -- controls the maximum length of the 'stringified' table before cutting with ' (more...)'
}

-- this tables should be weak so the elements in them won't become uncollectable
local m_known_tables = { [_G] = "_G (global table)" }
local function add_known_module(name, desc)
    local ok, mod = pcall(require, name)
    if ok then
        m_known_tables[mod] = desc
    end
end

add_known_module("string", "string module")
add_known_module("io", "io module")
add_known_module("os", "os module")
add_known_module("table", "table module")
add_known_module("math", "math module")
add_known_module("package", "package module")
add_known_module("debug", "debug module")
add_known_module("coroutine", "coroutine module")

-- lua5.2
add_known_module("bit32", "bit32 module")
-- luajit
add_known_module("bit", "bit module")
add_known_module("jit", "jit module")
-- lua5.3
if _VERSION >= "Lua 5.3" then
    add_known_module("utf8", "utf8 module")
end


local m_user_known_tables = {}

local m_known_functions = {}
for _, name in ipairs{
    -- Lua 5.2, 5.1
    "assert",
    "collectgarbage",
    "dofile",
    "error",
    "getmetatable",
    "ipairs",
    "load",
    "loadfile",
    "next",
    "pairs",
    "pcall",
    "print",
    "rawequal",
    "rawget",
    "rawlen",
    "rawset",
    "require",
    "select",
    "setmetatable",
    "tonumber",
    "tostring",
    "type",
    "xpcall",

    -- Lua 5.1
    "gcinfo",
    "getfenv",
    "loadstring",
    "module",
    "newproxy",
    "setfenv",
    "unpack",
    -- TODO: add table.* etc functions
} do
    if _G[name] then
        m_known_functions[_G[name]] = name
    end
end



local m_user_known_functions = {}

local function safe_tostring (value)
    local ok, err = pcall(tostring, value)
    if ok then return err else return ("<failed to get printable value>: '%s'"):format(err) end
end

-- Private:
-- Parses a line, looking for possible function definitions (in a very na�ve way)
-- Returns '(anonymous)' if no function name was found in the line
local function ParseLine(line)
    assert(type(line) == "string")
    --print(line)
    local match = line:match("^%s*function%s+(%w+)")
    if match then
        --print("+++++++++++++function", match)
        return match
    end
    match = line:match("^%s*local%s+function%s+(%w+)")
    if match then
        --print("++++++++++++local", match)
        return match
    end
    match = line:match("^%s*local%s+(%w+)%s+=%s+function")
    if match then
        --print("++++++++++++local func", match)
        return match
    end
    match = line:match("%s*function%s*%(")  -- this is an anonymous function
    if match then
        --print("+++++++++++++function2", match)
        return "(anonymous)"
    end
    return "(anonymous)"
end

-- Private:
-- Tries to guess a function's name when the debug info structure does not have it.
-- It parses either the file or the string where the function is defined.
-- Returns '?' if the line where the function is defined is not found
local function GuessFunctionName(info)
    --print("guessing function name")
    if type(info.source) == "string" and info.source:sub(1,1) == "@" then
        local file, err = io_open(info.source:sub(2), "r")
        if not file then
            print("file not found: "..tostring(err))    -- whoops!
            return "?"
        end
        local line
        for _ = 1, info.linedefined do
            line = file:read("*l")
        end
        if not line then
            print("line not found") -- whoops!
            return "?"
        end
        return ParseLine(line)
    else
        local line
        local lineNumber = 0
        for l in string_gmatch(info.source, "([^\n]+)\n-") do
            lineNumber = lineNumber + 1
            if lineNumber == info.linedefined then
                line = l
                break
            end
        end
        if not line then
            print("line not found") -- whoops!
            return "?"
        end
        return ParseLine(line)
    end
end

---
-- Dumper instances are used to analyze stacks and collect its information.
--
local Dumper = {}

Dumper.new = function(thread)
    local t = { lines = {} }
    for k,v in pairs(Dumper) do t[k] = v end

    t.dumping_same_thread = (thread == coroutine.running())

    -- if a thread was supplied, bind it to debug.info and debug.get
    -- we also need to skip this additional level we are introducing in the callstack (only if we are running
    -- in the same thread we're inspecting)
    if type(thread) == "thread" then
        t.getinfo = function(level, what)
            if t.dumping_same_thread and type(level) == "number" then
                level = level + 1
            end
            return debug.getinfo(thread, level, what)
        end
        t.getlocal = function(level, loc)
            if t.dumping_same_thread then
                level = level + 1
            end
            return debug.getlocal(thread, level, loc)
        end
    else
        t.getinfo = debug.getinfo
        t.getlocal = debug.getlocal
    end

    return t
end

-- helpers for collecting strings to be used when assembling the final trace
function Dumper:add (text)
    self.lines[#self.lines + 1] = text
end
function Dumper:add_f (fmt, ...)
    self:add(fmt:format(...))
end
function Dumper:concat_lines ()
    return table_concat(self.lines)
end

---
-- Private:
-- Iterates over the local variables of a given function.
--
-- @param level The stack level where the function is.
--
function Dumper:DumpLocals (level)
    local prefix = "\t "
    local i = 1

    if self.dumping_same_thread then
        level = level + 1
    end

    local name, value = self.getlocal(level, i)
    if not name then
        return
    end
    self:add("\tLocal variables:\r\n")
    while name do
        if type(value) == "number" then
            self:add_f("%s%s = number: %g\r\n", prefix, name, value)
        elseif type(value) == "boolean" then
            self:add_f("%s%s = boolean: %s\r\n", prefix, name, tostring(value))
        elseif type(value) == "string" then
            self:add_f("%s%s = string: %q\r\n", prefix, name, value)
        elseif type(value) == "userdata" then
            self:add_f("%s%s = %s\r\n", prefix, name, safe_tostring(value))
        elseif type(value) == "nil" then
            self:add_f("%s%s = nil\r\n", prefix, name)
        elseif type(value) == "table" then
            if m_known_tables[value] then
                self:add_f("%s%s = %s\r\n", prefix, name, m_known_tables[value])
            elseif m_user_known_tables[value] then
                self:add_f("%s%s = %s\r\n", prefix, name, m_user_known_tables[value])
            else
                local txt = "{"
                for k,v in pairs(value) do
                    txt = txt..safe_tostring(k)..":"..safe_tostring(v)
                    if #txt > _M.max_tb_output_len then
                        txt = txt.." (more...)"
                        break
                    end
                    if next(value, k) then txt = txt..", " end
                end
                self:add_f("%s%s = %s  %s\r\n", prefix, name, safe_tostring(value), txt.."}")
            end
        elseif type(value) == "function" then
            local info = self.getinfo(value, "nS")
            local fun_name = info.name or m_known_functions[value] or m_user_known_functions[value]
            if info.what == "C" then
                self:add_f("%s%s = C %s\r\n", prefix, name, (fun_name and ("function: " .. fun_name) or tostring(value)))
            else
                local source = info.short_src
                if source:sub(2,7) == "string" then
                    source = source:sub(9)  -- uno m�s, por el espacio que viene (string "Baragent.Main", por ejemplo)
                end
                --for k,v in pairs(info) do print(k,v) end
                fun_name = fun_name or GuessFunctionName(info)
                self:add_f("%s%s = Lua function '%s' (defined at line %d of chunk %s)\r\n", prefix, name, fun_name, info.linedefined, source)
            end
        elseif type(value) == "thread" then
            self:add_f("%sthread %q = %s\r\n", prefix, name, tostring(value))
        end
        i = i + 1
        name, value = self.getlocal(level, i)
    end
end


---
-- Public:
-- Collects a detailed stack trace, dumping locals, resolving function names when they're not available, etc.
-- This function is suitable to be used as an error handler with pcall or xpcall
--
-- @param thread An optional thread whose stack is to be inspected (defaul is the current thread)
-- @param message An optional error string or object.
-- @param level An optional number telling at which level to start the traceback (default is 1)
--
-- Returns a string with the stack trace and a string with the original error.
--
function _M.stacktrace(thread, message, level)
    if type(thread) ~= "thread" then
        -- shift parameters left
        thread, message, level = nil, thread, message
    end

    thread = thread or coroutine.running()

    level = level or 1

    local dumper = Dumper.new(thread)

    local original_error

    if type(message) == "table" then
        dumper:add("an error object {\r\n")
        local first = true
        for k,v in pairs(message) do
            if first then
                dumper:add("  ")
                first = false
            else
                dumper:add(",\r\n  ")
            end
            dumper:add(safe_tostring(k))
            dumper:add(": ")
            dumper:add(safe_tostring(v))
        end
        dumper:add("\r\n}")
        original_error = dumper:concat_lines()
    elseif type(message) == "string" then
        dumper:add(message)
        original_error = message
    end

    dumper:add("\r\n")
    dumper:add[[
Stack Traceback
===============
]]
    --print(error_message)

    local level_to_show = level
    if dumper.dumping_same_thread then level = level + 1 end

    local info = dumper.getinfo(level, "nSlf")
    while info do
        if info.what == "main" then
            if string_sub(info.source, 1, 1) == "@" then
                dumper:add_f("(%d) main chunk of file '%s' at line %d\r\n", level_to_show, string_sub(info.source, 2), info.currentline)
            else
                dumper:add_f("(%d) main chunk of %s at line %d\r\n", level_to_show, info.short_src, info.currentline)
            end
        elseif info.what == "C" then
            --print(info.namewhat, info.name)
            --for k,v in pairs(info) do print(k,v, type(v)) end
            local function_name = m_user_known_functions[info.func] or m_known_functions[info.func] or info.name or tostring(info.func)
            dumper:add_f("(%d) %s C function '%s'\r\n", level_to_show, info.namewhat, function_name)
            --dumper:add_f("%s%s = C %s\r\n", prefix, name, (m_known_functions[value] and ("function: " .. m_known_functions[value]) or tostring(value)))
        elseif info.what == "tail" then
            --print("tail")
            --for k,v in pairs(info) do print(k,v, type(v)) end--print(info.namewhat, info.name)
            dumper:add_f("(%d) tail call\r\n", level_to_show)
            dumper:DumpLocals(level)
        elseif info.what == "Lua" then
            local source = info.short_src
            local function_name = m_user_known_functions[info.func] or m_known_functions[info.func] or info.name
            if source:sub(2, 7) == "string" then
                source = source:sub(9)
            end
            local was_guessed = false
            if not function_name or function_name == "?" then
                --for k,v in pairs(info) do print(k,v, type(v)) end
                function_name = GuessFunctionName(info)
                was_guessed = true
            end
            -- test if we have a file name
            local function_type = (info.namewhat == "") and "function" or info.namewhat
            if info.source and info.source:sub(1, 1) == "@" then
                dumper:add_f("(%d) Lua %s '%s' at file '%s:%d'%s\r\n", level_to_show, function_type, function_name, info.source:sub(2), info.currentline, was_guessed and " (best guess)" or "")
            elseif info.source and info.source:sub(1,1) == '#' then
                dumper:add_f("(%d) Lua %s '%s' at template '%s:%d'%s\r\n", level_to_show, function_type, function_name, info.source:sub(2), info.currentline, was_guessed and " (best guess)" or "")
            else
                dumper:add_f("(%d) Lua %s '%s' at line %d of chunk '%s'\r\n", level_to_show, function_type, function_name, info.currentline, source)
            end
            dumper:DumpLocals(level)
        else
            dumper:add_f("(%d) unknown frame %s\r\n", level_to_show, info.what)
        end

        level = level + 1
        level_to_show = level_to_show + 1
        info = dumper.getinfo(level, "nSlf")
    end

    return dumper:concat_lines(), original_error
end

--
-- Adds a table to the list of known tables
function _M.add_known_table(tab, description)
    if m_known_tables[tab] then
        error("Cannot override an already known table")
    end
    m_user_known_tables[tab] = description
end

--
-- Adds a function to the list of known functions
function _M.add_known_function(fun, description)
    if m_known_functions[fun] then
        error("Cannot override an already known function")
    end
    m_user_known_functions[fun] = description
end

return _M