# debugger-hs
A Haskell library for creating/metaprogramming GDB scripts.
## Why?
GDB has Python integration, and while it is powerful, it has some problems:
- Python code can end up interleaved in the GDB code, making it complicated
really quickly.
- Accessing variables between GDB and Python can get complicated too.
Besides that, also some things in GDB don't work as expected, such as commands
that behave differently inside a user-defined command ("define"), which can lead
to unexpected and buggy results.
If we use Haskell however, we get the following nice things:
- A typesystem,
- Can use full Haskell ecosystem for metaprogramming,
- The generated output will be 100% GDB script only:
- easier to use afterwards,
- inspectable,
- no need for this package once the script has been generated.
## How?
Partial evaluation/staged programming. You write a Haskell file that makes use
of the DSL this package provides, and render it to a script that can be
passed in to GDB like you would normally.
Here's an example of how you can use this library to generate a GDB script:
```haskell
module Main where
import qualified Debugger.Builder as D
import qualified Debugger.Render as D
import qualified Debugger.Statement as D
-- First we build up a Haskell value that represents our GDB scripts.
script :: D.Builder ()
script = do
bp <- D.break (D.Function "main")
D.command bp $ do
D.print "42"
D.continue
-- And then we can render the GDB script to a file:
main :: IO ()
main = do
let gdbScript = D.runBuilder script
D.renderIO gdbScript "./script.gdb"
```
This will render the following GDB scripts:
```gdb
break main
set $var0 = $bpnum
command $var0
print "42"
continue
end
```
```bash
# Replace $PROGRAM with the program you want to debug.
$ gdb $PROGRAM <<< $(< /path/to/stack-script)
# or if your shell doesn't support the previous command:
$ /path/to/stack-script > ./script.gdb
$ gdb $PROGRAM -ex "source ./script.gdb"
```
## TODO
- [x] Create core AST datatype
- [x] Create builder monad for easily constructing GDB scripts using Haskell do-syntax.
- [x] Write function for compiling AST -> GDB script
- [ ] Create CLI application (stack/nix?) that takes the DSL and outputs GDB to stdout.
- [ ] Add helper functions for easily adding breakpoints (using tools like grep)
- [ ] Extend core AST datatype to support more functionality
- [ ] Add LLDB support also?
- [ ] DSL (to support GDB and LLDB at same time)?