300 lines
7.9 KiB
Lua
300 lines
7.9 KiB
Lua
return {
|
|
'mfussenegger/nvim-dap',
|
|
version = false,
|
|
dependencies = {
|
|
{
|
|
'mfussenegger/nvim-dap-python',
|
|
version = false,
|
|
},
|
|
-- 'theHamsta/nvim-dap-virtual-text',
|
|
{
|
|
'rcarriga/nvim-dap-ui',
|
|
version = false,
|
|
dependencies = {
|
|
'nvim-neotest/nvim-nio',
|
|
},
|
|
},
|
|
{
|
|
'LiadOz/nvim-dap-repl-highlights',
|
|
version = false,
|
|
},
|
|
},
|
|
keys = {
|
|
{
|
|
'<F5>',
|
|
function()
|
|
require('dap').continue()
|
|
end,
|
|
desc = 'DAP start or continue',
|
|
},
|
|
{
|
|
'<S-F5>',
|
|
function()
|
|
require('dap').run_last()
|
|
end,
|
|
desc = 'DAP run last',
|
|
},
|
|
{
|
|
'<F6>',
|
|
function()
|
|
loadConfigs()
|
|
end,
|
|
desc = 'DAP configs',
|
|
},
|
|
{
|
|
'<F7>',
|
|
function()
|
|
require('dap').goto_()
|
|
end,
|
|
desc = 'DAP goto',
|
|
},
|
|
{
|
|
'<F8>',
|
|
function()
|
|
require('dap.ui.widgets').hover()
|
|
end,
|
|
desc = 'DAP Hover',
|
|
},
|
|
{
|
|
'<F9>',
|
|
function()
|
|
require('dap').toggle_breakpoint()
|
|
end,
|
|
desc = 'DAP breakpoint',
|
|
},
|
|
{
|
|
'<F10>',
|
|
function()
|
|
require('dap').step_over()
|
|
end,
|
|
desc = 'DAP step_over',
|
|
},
|
|
{
|
|
'<F11>',
|
|
function()
|
|
require('dap').step_into()
|
|
end,
|
|
desc = 'DAP step_into',
|
|
},
|
|
{
|
|
'<S-F11>',
|
|
function()
|
|
require('dap').step_out()
|
|
end,
|
|
desc = 'DAP step_out',
|
|
},
|
|
},
|
|
config = function()
|
|
local dap = require('dap')
|
|
vim.fn.sign_define('DapBreakpoint', { text = '🛑', texthl = '', linehl = '', numhl = '' })
|
|
|
|
-- make sure we can exit the terminal with esc
|
|
vim.api.nvim_create_autocmd({ 'TermOpen' }, {
|
|
pattern = { '*dap-terminal*' },
|
|
callback = function()
|
|
local opts = { noremap = true }
|
|
vim.api.nvim_buf_set_keymap(0, 't', '<esc>', [[<C-\><C-n>]], opts)
|
|
end,
|
|
})
|
|
|
|
-- Hover with K
|
|
local api = vim.api
|
|
local keymap_restore = {}
|
|
dap.listeners.after['event_initialized']['me'] = function()
|
|
for _, buf in pairs(api.nvim_list_bufs()) do
|
|
local keymaps = api.nvim_buf_get_keymap(buf, 'n')
|
|
for _, keymap in pairs(keymaps) do
|
|
if keymap.lhs == 'K' then
|
|
table.insert(keymap_restore, keymap)
|
|
api.nvim_buf_del_keymap(buf, 'n', 'K')
|
|
end
|
|
end
|
|
end
|
|
api.nvim_set_keymap('n', 'K', '<Cmd>lua require("dap.ui.widgets").hover()<CR>', { silent = true })
|
|
end
|
|
|
|
dap.listeners.after['event_terminated']['me'] = function()
|
|
for _, keymap in pairs(keymap_restore) do
|
|
api.nvim_buf_set_keymap(keymap.buffer, keymap.mode, keymap.lhs, keymap.rhs, { silent = keymap.silent == 1 })
|
|
end
|
|
keymap_restore = {}
|
|
end
|
|
|
|
require('dap.ext.vscode').json_decode = require('utils.json_workaround').decode_json
|
|
|
|
local pythonVenv = require('utils.python_venv')
|
|
local snacks = require('snacks')
|
|
local dap = require('dap')
|
|
|
|
local function get_all_dap_configurations()
|
|
require('dap.ext.vscode').load_launchjs()
|
|
local configs = {}
|
|
|
|
for filetype, entries in pairs(dap.configurations or {}) do
|
|
for _, cfg in ipairs(entries) do
|
|
table.insert(configs, {
|
|
label = cfg.name or '[No name]',
|
|
desc = string.format('Type: %s | Filetype: %s', cfg.type, filetype),
|
|
config = cfg, -- store actual config separately
|
|
})
|
|
end
|
|
end
|
|
|
|
return configs
|
|
end
|
|
|
|
local function pick_dap_configuration()
|
|
local items = get_all_dap_configurations()
|
|
|
|
snacks.picker({
|
|
items = items,
|
|
prompt = 'DAP Configurations',
|
|
confirm = function(picker, item)
|
|
picker:close()
|
|
local config = item.config
|
|
if config then
|
|
dap.run(config)
|
|
else
|
|
vim.notify('Invalid DAP config', vim.log.levels.ERROR)
|
|
end
|
|
end,
|
|
})
|
|
end
|
|
|
|
-- Create a Neovim command for convenience
|
|
vim.api.nvim_create_user_command('PickDapConfig', pick_dap_configuration, {})
|
|
function loadConfigs()
|
|
require('dap.ext.vscode').load_launchjs()
|
|
-- Make sure we use the correct python env even for the configs from launch.json
|
|
for _, config in pairs(dap.configurations.python) do
|
|
config.pythonPath = pythonVenv.getPythonEnv()
|
|
config.cwd = vim.fn.getcwd()
|
|
end
|
|
require('fzf-lua').dap_configurations()
|
|
end
|
|
|
|
local masonpath = vim.fn.stdpath('data') .. '/mason'
|
|
|
|
-- PYTHON
|
|
dap.adapters.python = {
|
|
type = 'executable',
|
|
command = 'python',
|
|
args = { '-m', 'debugpy.adapter' },
|
|
options = {
|
|
detached = true,
|
|
},
|
|
}
|
|
|
|
local dapui = require('dapui')
|
|
dapui.setup()
|
|
dap.listeners.before.attach.dapui_config = function()
|
|
dapui.open()
|
|
end
|
|
dap.listeners.before.launch.dapui_config = function()
|
|
dapui.open()
|
|
end
|
|
dap.listeners.before.event_terminated.dapui_config = function()
|
|
dapui.close()
|
|
end
|
|
dap.listeners.before.event_exited.dapui_config = function()
|
|
dapui.close()
|
|
end
|
|
|
|
dap.configurations.python = {
|
|
{
|
|
type = 'python',
|
|
request = 'launch',
|
|
name = 'Launch file with venv',
|
|
justMyCode = false,
|
|
program = '${file}',
|
|
cwd = vim.fn.getcwd(),
|
|
pythonPath = pythonVenv.getPythonEnv,
|
|
},
|
|
}
|
|
|
|
-- require('dap-python').setup('C:\\Users\\oli\\AppData\\Local\\nvim\\venv_debugpy\\Scripts\\python')
|
|
-- table.insert(require('dap').configurations.python, {
|
|
-- -- type = 'python',
|
|
-- -- request = 'launch',
|
|
-- -- name = 'My custom launch configuration',
|
|
-- -- program = '${file}',
|
|
-- justMyCode = false
|
|
-- -- ... more options, see https://github.com/microsoft/debugpy/wiki/Debug-configuration-settings
|
|
-- })
|
|
-- require('dap-python').setup('C:/Users/oli/AppData/Local/nvim-data/mason/packages/debugpy/venv/Scripts/python.exe')
|
|
|
|
-- CPP
|
|
dap.adapters.codelldb = {
|
|
type = 'server',
|
|
port = '${port}',
|
|
executable = {
|
|
command = require('mason-core.path').bin_prefix('codelldb'),
|
|
args = { '--port', '${port}' },
|
|
|
|
-- On windows you may have to uncomment this:
|
|
detached = false,
|
|
},
|
|
}
|
|
|
|
dap.adapters.cppdbg = {
|
|
id = 'cppdbg',
|
|
type = 'executable',
|
|
command = masonpath .. '/bin/OpenDebugAD7',
|
|
}
|
|
|
|
dap.adapters.lldb = {
|
|
type = 'executable',
|
|
command = function()
|
|
if vim.loop.os_uname().sysname == 'Linux' then
|
|
return 'lldb-vscode'
|
|
else
|
|
return os.getenv('SCOOP') .. '/apps/llvm/current/bin/lldb-vscode.exe'
|
|
end
|
|
end,
|
|
name = 'lldb',
|
|
}
|
|
|
|
dap.configurations.cpp = {
|
|
{
|
|
name = 'Launch codelldb',
|
|
type = 'codelldb',
|
|
request = 'launch',
|
|
program = function()
|
|
return vim.fn.input({ 'Path to executable: ', vim.fn.getcwd() .. '/build_nvim/', 'file' })
|
|
end,
|
|
cwd = '${workspaceFolder}',
|
|
stopOnEntry = false,
|
|
},
|
|
{
|
|
name = 'Launch lldb',
|
|
type = 'lldb',
|
|
request = 'launch',
|
|
program = function()
|
|
return vim.fn.input({ 'Path to executable: ', vim.fn.getcwd() .. '/build_nvim', 'file' })
|
|
end,
|
|
cwd = '${workspaceFolder}',
|
|
stopOnEntry = false,
|
|
args = {},
|
|
|
|
-- 💀
|
|
-- if you change `runInTerminal` to true, you might need to change the yama/ptrace_scope setting:
|
|
--
|
|
-- echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope
|
|
--
|
|
-- Otherwise you might get the following error:
|
|
--
|
|
-- Error on launch: Failed to attach to the target process
|
|
--
|
|
-- But you should be aware of the implications:
|
|
-- https://www.kernel.org/doc/html/latest/admin-guide/LSM/Yama.html
|
|
-- runInTerminal = false,
|
|
},
|
|
}
|
|
|
|
-- EXTENSIONS
|
|
|
|
require('nvim-dap-repl-highlights').setup()
|
|
require('nvim-dap-virtual-text').setup({})
|
|
end,
|
|
}
|