235 lines
7.5 KiB
Lua
235 lines
7.5 KiB
Lua
local curses = require "curses"
|
|
local REGULAR, INVERTED, HIGHLIGHTED, RED
|
|
local run_debugger, cursey
|
|
|
|
-- Return the callstack index of the code that actually caused an error and the max index
|
|
local function callstack_range()
|
|
local min, max = 0, -1
|
|
for i=1,999 do
|
|
if debug.getinfo(i,'f').func == run_debugger then
|
|
min = i+2
|
|
break
|
|
end
|
|
end
|
|
for i=min,999 do
|
|
if debug.getinfo(i,'f').func == cursey then
|
|
max = i-3
|
|
break
|
|
end
|
|
end
|
|
return min, max
|
|
end
|
|
|
|
local Pad = setmetatable({
|
|
select = function(self, i)
|
|
if i == self.selected then return end
|
|
if i then
|
|
i = math.max(1, math.min(#self.lines, i))
|
|
end
|
|
if self.selected then
|
|
local j = self.selected
|
|
local attr = j % 2 == 0 and INVERTED or REGULAR
|
|
self.chstrs[j]:set_str(0, self.lines[j], attr)
|
|
self.chstrs[j]:set_str(#self.lines[j], ' ', attr, self.chstrs[j]:len()-#self.lines[j])
|
|
self._pad:mvaddchstr(j-1+1,0+1,self.chstrs[j])
|
|
end
|
|
|
|
if i then
|
|
self.chstrs[i]:set_str(0, self.lines[i], HIGHLIGHTED)
|
|
self.chstrs[i]:set_str(#self.lines[i], ' ', HIGHLIGHTED, self.chstrs[i]:len()-#self.lines[i])
|
|
self._pad:mvaddchstr(i-1+1,0+1,self.chstrs[i])
|
|
end
|
|
|
|
self.selected = i
|
|
|
|
if self.selected then
|
|
if self.offset + self.height-5 < self.selected then
|
|
self.offset = math.min(self.selected - (self.height-5), #self.lines-self.height)
|
|
elseif self.offset + 5 > self.selected then
|
|
self.offset = self.selected - 5
|
|
end
|
|
end
|
|
self:refresh()
|
|
if self.on_select then self:on_select(self.selected) end
|
|
end,
|
|
refresh = function(self)
|
|
self._pad:border(curses.ACS_VLINE, curses.ACS_VLINE,
|
|
curses.ACS_HLINE, curses.ACS_HLINE,
|
|
curses.ACS_ULCORNER, curses.ACS_URCORNER,
|
|
curses.ACS_LLCORNER, curses.ACS_LRCORNER)
|
|
self._pad:pnoutrefresh(self.offset,0,self.y,self.x,self.height+self.y,self.width+self.x)
|
|
end,
|
|
add_line = function(self, line, attr)
|
|
self.height = self.height + 1
|
|
self._pad:resize(self.height, self.width)
|
|
table.insert(self.lines, line)
|
|
local i = #self.lines
|
|
local chstr = curses.new_chstr(self.width-2)
|
|
attr = attr or (i % 2 == 0 and INVERTED or REGULAR)
|
|
self.chstrs[i] = chstr
|
|
chstr:set_str(0, line, attr)
|
|
chstr:set_str(#line+0, ' ', attr, chstr:len()-#line)
|
|
self._pad:mvaddchstr(i-1+1,0+1,chstr)
|
|
end,
|
|
add_lines = function(self, lines)
|
|
for i,line in ipairs(lines) do
|
|
self:add_line(line)
|
|
end
|
|
end,
|
|
clear = function(self)
|
|
self._pad:erase()
|
|
self._pad:pnoutrefresh(self.offset,0,self.y,self.x,self.height+self.y,self.width+self.x)
|
|
self.lines = {}
|
|
self.chstrs = {}
|
|
self.height = 2
|
|
self.selected = nil
|
|
self.offset = 0
|
|
self._pad:resize(self.height, self.width)
|
|
self:refresh()
|
|
end,
|
|
scroll = function(self, delta)
|
|
self:select(self.selected + delta)
|
|
end,
|
|
}, {
|
|
__call = function(Pad, y, x, height, width)
|
|
local pad = setmetatable({
|
|
x = x, y = y, width = width, height = height, offset = 0, selected = nil,
|
|
chstrs = {}, lines = {},
|
|
}, Pad)
|
|
|
|
pad._pad = curses.newpad(pad.height, pad.width)
|
|
pad._pad:scrollok(true)
|
|
return pad
|
|
end,
|
|
})
|
|
Pad.__index = Pad
|
|
|
|
local function make_pad(y,x,lines)
|
|
local width = 0
|
|
for _, v in ipairs(lines) do width = math.max(width, #v) end
|
|
local pad = setmetatable({
|
|
x = x, y = y, width = width + 2, height = 2, offset = 0, selected = nil,
|
|
chstrs = {}, lines = {},
|
|
}, {__index=pad_methods})
|
|
|
|
pad._pad = curses.newpad(pad.height, pad.width)
|
|
pad._pad:scrollok(true)
|
|
for i, line in ipairs(lines) do
|
|
pad:add_line(line)
|
|
end
|
|
return pad
|
|
end
|
|
|
|
run_debugger = function(err_msg)
|
|
local stdscr = curses.initscr()
|
|
local SCREEN_H, SCREEN_W = stdscr:getmaxyx()
|
|
|
|
curses.cbreak()
|
|
curses.echo(false) -- not noecho !
|
|
curses.nl(false) -- not nonl !
|
|
curses.curs_set(0)
|
|
curses.start_color()
|
|
curses.use_default_colors()
|
|
|
|
local _
|
|
_, REGULAR = curses.init_pair(1, -1, -1), curses.color_pair(1)
|
|
_, INVERTED = curses.init_pair(2, -1, curses.COLOR_BLACK), curses.color_pair(2)
|
|
_, HIGHLIGHTED = curses.init_pair(3, curses.COLOR_BLACK, curses.COLOR_YELLOW), curses.color_pair(3)
|
|
_, RED = curses.init_pair(4, curses.COLOR_RED, -1), curses.color_pair(4) | curses.A_BOLD
|
|
|
|
stdscr:clear()
|
|
stdscr:refresh()
|
|
stdscr:keypad(true)
|
|
|
|
local stack_names = {}
|
|
local stack_locations = {}
|
|
local max_filename = 0
|
|
local stack_min, stack_max = callstack_range()
|
|
for i=stack_min,stack_max do
|
|
local info = debug.getinfo(i)
|
|
if not info then break end
|
|
table.insert(stack_names, info.name or "???")
|
|
local filename = info.short_src..":"..info.currentline
|
|
table.insert(stack_locations, filename)
|
|
max_filename = math.max(max_filename, #filename)
|
|
end
|
|
local callstack = {}
|
|
for i=1,#stack_names do
|
|
callstack[i] = stack_locations[i]..(" "):rep(max_filename-#stack_locations[i]).." | "..stack_names[i].." "
|
|
end
|
|
|
|
local err_pad = Pad(0,0,2,SCREEN_W)
|
|
err_pad._pad:attrset(RED)
|
|
for line in err_msg:gmatch("[^\n]*") do
|
|
local buff = ""
|
|
for word in line:gmatch("%S%S*%s*") do
|
|
if #buff + #word > SCREEN_W - 4 then
|
|
err_pad:add_line(" "..buff, RED)
|
|
buff = word
|
|
else
|
|
buff = buff .. word
|
|
end
|
|
end
|
|
err_pad:add_line(" "..buff, RED)
|
|
end
|
|
err_pad:refresh()
|
|
|
|
local stack_pad = Pad(err_pad.height,0,2,50)
|
|
stack_pad:add_lines(callstack)
|
|
local var_names = Pad(err_pad.height,stack_pad.x+stack_pad.width,2,25)
|
|
local var_values = Pad(err_pad.height,var_names.x+var_names.width,2,SCREEN_W-(var_names.x+var_names.width))
|
|
|
|
function stack_pad:on_select(i)
|
|
var_names:clear()
|
|
var_values:clear()
|
|
local callstack_min, _ = callstack_range()
|
|
for loc=1,999 do
|
|
local name, value = debug.getlocal(callstack_min+i-1, loc)
|
|
if value == nil then break end
|
|
var_names:add_line(tostring(name))
|
|
var_values:add_line(tostring(value))
|
|
end
|
|
var_names:refresh()
|
|
var_values:refresh()
|
|
end
|
|
stack_pad:select(1)
|
|
|
|
while true do
|
|
curses.doupdate()
|
|
local c = stdscr:getch()
|
|
if c < 256 then c = string.char(c) end
|
|
local old_index = index
|
|
if ({[curses.KEY_DOWN]=1, [curses.KEY_SF]=1, j=1})[c] then
|
|
stack_pad:scroll(1)
|
|
elseif ({[curses.KEY_UP]=1, [curses.KEY_SR]=1, k=1})[c] then
|
|
stack_pad:scroll(-1)
|
|
elseif c == 'J' then
|
|
stack_pad:scroll(10)
|
|
elseif c == 'K' then
|
|
stack_pad:scroll(-10)
|
|
end
|
|
|
|
if c == 'q' or c == "Q" then
|
|
break
|
|
end
|
|
end
|
|
curses.endwin()
|
|
end
|
|
|
|
cursey = function(fn, ...)
|
|
-- To display Lua errors, we must close curses to return to
|
|
-- normal terminal mode, and then write the error to stdout.
|
|
local function err(err)
|
|
curses.endwin()
|
|
print "Caught an error:"
|
|
print(debug.traceback(err, 2))
|
|
os.exit(2)
|
|
end
|
|
|
|
return xpcall(fn, function(err_msg)
|
|
xpcall(run_debugger, err, err_msg)
|
|
end, ...)
|
|
end
|
|
|
|
return cursey
|