gary/debugger/ui.go

217 lines
5.0 KiB
Go

package main
import (
"crypto/rand"
"fmt"
"strings"
"git.sentinel65x.com/dave/gary/debugger/memory"
tea "github.com/charmbracelet/bubbletea"
lip "github.com/charmbracelet/lipgloss"
)
func UI(mem *memory.Memory) error {
initial := debugger{
width: 0,
height: 0,
mem: mem,
statusMsg: "Loading...",
}
initial.hex = NewHexView(mem, initial.commitWrites)
initial.hex.AddrStyle = text
initial.hex.ZeroStyle = faintText
initial.hex.HexStyle = text
p := tea.NewProgram(initial)
if _, err := p.Run(); err != nil {
return err
}
return nil
}
var (
amber = lip.Color("#ffb00")
slate = lip.Color("235")
text = lip.NewStyle().
Foreground(amber).
Background(slate).
BorderForeground(amber).
BorderBackground(slate).
Border(lip.NormalBorder(), false, false, false, false)
faintText = text.Faint(true)
box = lip.NewStyle().
Border(lip.NormalBorder()).
BorderForeground(amber).
BorderBackground(slate).
Padding(1, 2)
)
type msgMemoryChanged struct {
start, count int
}
type msgErr struct {
err error
}
type msgUpdateStatus struct {
status string
}
type debugger struct {
width int
height int
mem *memory.Memory
hex HexView
lastErr error
statusMsg string
}
func (m debugger) Init() tea.Cmd {
loads := m.readFullMemoryCmds()
ret := make([]tea.Cmd, 0, (len(loads)*2)+1)
for i, c := range loads {
ret = append(ret, staticMsg(msgUpdateStatus{fmt.Sprintf("Loading block %d/%d", i+1, len(loads))}), c)
}
ret = append(ret, staticMsg(msgUpdateStatus{"Load complete."}))
return tea.Sequence(ret...)
}
func (m debugger) readFullMemory() tea.Cmd {
return tea.Sequence(m.readFullMemoryCmds()...)
}
func (m debugger) readFullMemoryCmds() []tea.Cmd {
var ret []tea.Cmd
for i := 0; i < m.mem.Len(); i += 32 * 1024 {
ret = append(ret, m.readMemory(i, 32*1024))
}
return ret
}
func (m debugger) readMemory(start, count int) tea.Cmd {
return func() tea.Msg {
if err := m.mem.Refresh(start, count); err != nil {
return msgErr{fmt.Errorf("loading region 0x%x+%x: %w", start, count, err)}
}
return msgMemoryChanged{start, count}
}
}
func staticMsg(msg tea.Msg) tea.Cmd {
return func() tea.Msg {
return msg
}
}
func (m debugger) commitWrites() tea.Cmd {
return tea.Sequence(
staticMsg(msgUpdateStatus{"Writing..."}),
func() tea.Msg {
if err := m.mem.Commit(); err != nil {
return msgUpdateStatus{fmt.Sprintf("Write failed: %v", err)}
}
return msgUpdateStatus{"Writes complete."}
},
m.readFullMemory(),
)
}
func (m debugger) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
switch msg := msg.(type) {
case tea.WindowSizeMsg:
m.width = msg.Width
m.height = msg.Height
var cmd tea.Cmd
m.hex, cmd = m.hex.Update(HexViewSetHeight{m.height - box.GetVerticalFrameSize() - 1})
return m, cmd
case tea.KeyMsg:
switch msg.String() {
case "ctrl+c", "q":
return m, tea.Quit
case "r":
start, end := m.hex.VisibleBytes()
return m, m.readMemory(start, end-start)
case "R":
return m, m.readFullMemory()
case "p":
bs := make([]byte, 19)
rand.Read(bs)
for i, b := range bs {
m.mem.Write(m.hex.SelectedAddr()+i, b)
}
return m, m.commitWrites()
}
case msgErr:
m.lastErr = msg.err
return m, nil
case msgUpdateStatus:
m.statusMsg = msg.status
}
var cmd tea.Cmd
m.hex, cmd = m.hex.Update(msg)
return m, cmd
}
func (m debugger) values(addr int) string {
var out strings.Builder
k := func(k string) {
out.WriteString(text.Bold(true).Render(k) + text.Render(": "))
}
v := func(format string, args ...any) {
val := fmt.Sprintf(format, args...)
out.WriteString(text.Render(val) + "\n")
}
b := m.mem.At(addr)
k(" addr")
v("0x%x", addr)
k("binary")
v("%s", b.Bin())
k(" uint8")
v("0x%s (%s)", b.Hex(), b.Dec())
var w uint16
if m.mem.Decode(addr, &w) {
k("uint16")
v("0x%04x (%d)", w, w)
}
var dw uint32
if m.mem.Decode(addr, &dw) {
k("uint32")
v("0x%08x (%d)", dw, dw)
}
out.WriteByte('\n')
return strings.TrimSpace(out.String())
}
func (m debugger) View() string {
if m.width < 80 || m.height < 20 {
return lip.Place(m.width, m.height, lip.Center, lip.Center, "Please embiggen your terminal")
}
hex := box.Render(m.hex.View())
decoder := box.Width(m.width - lip.Width(hex) - 2).Render(m.values(m.hex.SelectedAddr()))
main := lip.JoinHorizontal(lip.Top, hex, decoder)
barText := text.Reverse(true)
topLeft := barText.Bold(true).PaddingLeft(1).Render("Addr: ")
topLeft += barText.Render(fmt.Sprintf("0x%x (%d)", m.hex.SelectedAddr(), m.hex.SelectedAddr()))
topRight := barText.PaddingRight(1).Render(m.statusMsg)
title := barText.Padding(0, 1).Bold(true).Render("GARY Debugger")
sideWidth := max(lip.Width(topLeft), lip.Width(topRight))
titleWidth := m.width - 2*sideWidth
topLeft = barText.Width(sideWidth).Align(lip.Left).Render(topLeft)
topRight = barText.Width(sideWidth).Align(lip.Right).Render(topRight)
title = barText.Width(titleWidth).Align(lip.Center).Render(title)
status := lip.JoinHorizontal(lip.Top, topLeft, title, topRight)
all := lip.JoinVertical(lip.Center, status, main)
return all
}