df/tree/.config/nvim/lua/debugger.lua

local dap = require('dap')

local codelldb_bin = "/usr/bin/codelldb"

-- Rust, C++, C
dap.adapters.codelldb = {
  type = 'server',
  port = "${port}",
  executable = {
    command = codelldb_bin,
    args = {"--port", "${port}"},
  }
}

local function get_default_rust_program_path()
  local workspace = vim.fn.getcwd()
  local program_name = vim.fn.fnamemodify(workspace, ":t")
  return workspace .. '/target/debug/' .. program_name
end

dap.configurations.cpp = {
    {
        port = 1234,
        host = '127.0.0.1',
        name = "Attach to name",
        type = "codelldb",
        request = "attach",
        pid = function()
            -- Lets user enter the name of a running process instead of looking up the pid themselves
            local name = vim.fn.input('Enter pidof name: ')
            local handle = io.popen("pidof " .. name)
            local pid = handle:read("*a")
            handle:close()

            -- Trim the result
            pid = pid:match( "^%s*(.-)%s*$" )
            return pid
        end,
        stopOnEntry = true,
    },
    {
        port = 1234,
        host = '127.0.0.1',
        name = "Attach to PID",
        type = "codelldb",
        request = "attach",
        pid = function()
            return tonumber(vim.fn.input('Enter PID: '))
        end,
        stopOnEntry = true,
    },
    {
        port = 1234,
        host = '127.0.0.1',
        name = "Manually launch file",
        type = "codelldb",
        request = "launch",
        program = function()
            return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/', 'file')
        end,
        cwd = '${workspaceFolder}',
        stopOnEntry = true,
    },
    {
        -- To debug programs that need to run as root you can run a remote lldb-server as root
        -- sudo lldb-server platform --server --listen '*:1234'
        name = "Remote attach to name",
        type = "codelldb",
        request = "attach",
        pid = function()
            -- Lets user enter the name of a running process instead of looking up the pid themselves
            local name = vim.fn.input('Enter pidof name: ')
            local handle = io.popen("pidof " .. name)
            local pid = handle:read("*a")
            handle:close()

            -- Trim the result
            pid = pid:match( "^%s*(.-)%s*$" )
            return pid
        end,
        initCommands = {
            "platform select remote-linux",
            "platform connect connect://127.0.0.1:1234",
            "settings set target.inherit-env false",
        },
    },
    {
        -- To debug programs that need to run as root you can run a remote lldb-server as root
        -- sudo lldb-server platform --server --listen '*:1234'
        name = "Remote launch",
        type = "codelldb",
        request = "launch",
        program = function()
            return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/', 'file')
        end,
        initCommands = {
            "platform select remote-linux",
            "platform connect connect://127.0.0.1:1234",
            "settings set target.inherit-env false",
        },
    },
}
dap.configurations.c = dap.configurations.cpp
dap.configurations.rust = dap.configurations.cpp

-- Insert this config as a rust specific one before the C++ configs
table.insert(dap.configurations.rust, 1, {
  port = 1234,
  host = '127.0.0.1',
  name = "Launch Default Rust Program",
  type = "codelldb",
  request = "launch",
  program = get_default_rust_program_path,
  cwd = '${workspaceFolder}',
  stopOnEntry = true,
})

-- Python
--dap.adapters.python = function(cb, config)
--  if config.request == 'attach' then
--    ---@diagnostic disable-next-line: undefined-field
--    local port = (config.connect or config).port
--    ---@diagnostic disable-next-line: undefined-field
--    local host = (config.connect or config).host or '127.0.0.1'
--    cb({
--      type = 'server',
--      port = assert(port, '`connect.port` is required for a python `attach` configuration'),
--      host = host,
--      options = {
--        source_filetype = 'python',
--      },
--    })
--  else
--    local home = os.getenv("HOME")
--    cb({
--      type = 'executable',
--      -- You need to install debugpy in $HOME/.virtualenvs/
--      -- Like this:
--      -- $ mkdir .virtualenvs
--      -- $ cd .virtualenvs
--      -- $ python -m venv debugpy
--      -- $ debugpy/bin/python -m pip install debugpy
--      command = home .. '/.virtualenvs/debugpy/bin/python',
--      args = { '-m', 'debugpy.adapter' },
--      options = {
--        source_filetype = 'python',
--      },
--    })
--  end
--end

--dap.configurations.python = {
--  {
--    -- The first three options are required by nvim-dap
--    type = 'python'; -- the type here established the link to the adapter definition: `dap.adapters.python`
--    request = 'launch';
--    name = "Launch file";
--
--    -- Options below are for debugpy, see https://github.com/microsoft/debugpy/wiki/Debug-configuration-settings for supported options
--
--    program = "${file}"; -- This configuration will launch the current file if used.
--    pythonPath = function()
--      -- debugpy supports launching an application with a different interpreter then the one used to launch debugpy itself.
--      -- The code below looks for a `venv` or `.venv` folder in the current directly and uses the python within.
--      -- You could adapt this - to for example use the `VIRTUAL_ENV` environment variable.
--      local cwd = vim.fn.getcwd()
--      if vim.fn.executable(cwd .. '/venv/bin/python') == 1 then
--        return cwd .. '/venv/bin/python'
--      elseif vim.fn.executable(cwd .. '/.venv/bin/python') == 1 then
--        return cwd .. '/.venv/bin/python'
--      else
--        return '/usr/bin/python'
--      end
--    end;
--  },
--}