How can i use an external terminal with lldb-vscode (for rust & cpp)

[bresilla]

Hi, i thought is better to ask a question here rather open an issue. ( I assume the whole idea of discussions is for those things to not open too many issues every time someone ignorant like me can't figure out something with the code) :P :P

I checked all issued (open and closed) before writing this, so i don't duplicate the same question. I really like his plugin, and actually for the first time in years i don't want to use println or cout in my code but use a proper debugger. I am very pumped where this project goes.

I am setting up a rust (and cpp) projects, but i need to figure out how to use an external terminal for the debugger:

local dap = require 'dap'

dap.adapters.cpp = {
  type = 'executable',
  attach = {
    pidProperty = "pid",
    pidSelect = "ask"
  },
  command = 'lldb-vscode', -- my binary was called 'lldb-vscode-11'
  env = {
    LLDB_LAUNCH_FLAG_LAUNCH_IN_TTY = "YES"
  },
  name = "lldb"
}
dap.configurations.cpp = {
  {
    name = "lldb",
    type = "cpp",
    request = "launch",
    program = function()
      return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/')
    end,
    cwd = '${workspaceFolder}',
    env = function()
      local variables = {}
      for k, v in pairs(vim.fn.environ()) do
        table.insert(variables, string.format("%s=%s", k, v))
      end
      return variables
    end,
    console = "externalTerminal",
    externalTerminal = true,
    stopOnEntry = false,
    args = {}
  },
}

dap.defaults.cpp.external_terminal = {
    command = '/usr/bin/alacritty';
    args = {'-e'};
}

function rebugger (args)
    local dap = require "dap"
    local last_gdb_config = {
        type = "cpp",
        name = args[1],
        request = "launch",
        program = table.remove(args, 1),
        args = args,
        cwd = vim.fn.getcwd(),
        env = {"NO_COLOR=1"},
        console = "externalTerminal",
        externalTerminal = true,
        externalConsole = true,
    }
    dap.run(last_gdb_config)
    dap.repl.open()
end

vimp.nnoremap('<M-r>',      [[<cmd>lua rebugger({"target/debug/fol"})<CR>]])
vimp.nnoremap('<M-c>',      [[<cmd>lua require'dap'.continue()<CR>]])
vimp.nnoremap('<M-b>',      [[<cmd>lua require'dap'.toggle_breakpoint()<CR>]])

vim.fn.sign_define('DapBreakpoint', {text='', texthl='DapBreakpointSign', linehl='', numhl=''})
vim.fn.sign_define('DapStopped', {text='', texthl='DapBreakpointSign', linehl='', numhl=''})

As seen form code, i am trying both ways: with a configurations.cpp and setting up a special function rebugger but none seems to activate the external terminal specified by dap.defaults.cpp.external_terminal. I am using all possibel forms in settings like:

        console = "externalTerminal",
        externalTerminal = true,
        externalConsole = true,

Again, sorry for asking an ignorant question. And believe me, i already spend more than 6 hours trying anything i can come up with, so after this, i decided to seek for help. Thanks to anyone who can give me some pointers. Cheers.

[theHamsta]

LLDB_LAUNCH_FLAG_LAUNCH_IN_TTY = "YES"

I guess deleting this or setting to "no" could maybe work to launch in a separate Neovim terminal. I don't know whether it supports external terminals. It does not really have a documentation. But you can usually find how to configure it by looking at it's main.cpp in the lock code base. There should be one big config struct.

[mfussenegger]

I think the lldb-vscode debug adapter currently does not support launching in an external console.
The supported configuration options are listed here

There's also vadimcn/vscode-lldb which lists a terminal option in the configuration, maybe that would work?

Btw in your configuration:

program = function()
      return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/')
    end,

You could add the file paramter for input to get file path completion in the commandline:

program = function()
  return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/', 'file')
end,

[mfussenegger]

I got curious and tried a workaround: Launching the process implicitly via a adapter function and then using the pid/attach functionality:

dap.adapters.lldb = function(cb, config)
  local adapter = dap.adapters.cpp
  if config.request == 'attach' and config.program then
    local terminal = dap.defaults[config.type].external_terminal
    local full_args = {}
    vim.list_extend(full_args, terminal.args or {})
    table.insert(full_args, config.program)
    vim.list_extend(full_args, config.args or {})
    local opts = {
      args = full_args,
      detached = true
    }
    local handle
    local pid_or_err
    handle, pid_or_err = vim.loop.spawn(terminal.command, opts, function(code)
      handle:close()
      if code ~= 0 then
        print('Terminal process exited', code, 'running', terminal.command, vim.inspect(full_args))
      end
    end)
    if not handle then
      print('Could not launch process', terminal.command)
    else
      print('Launched external terminal', pid_or_err)
      while not config.pid  -- Adding a timeout or something might make sense
      do
        config.pid = tonumber(vim.fn.system({'pgrep', '-P', pid_or_err}))
      end
      print('Launched', config.program, 'within terminal with PID', config.pid)
      config.program = nil
    end
  end
  cb(adapter)
end

dap.adapters.cpp = {
  type = 'executable',
  command = 'lldb-vscode',
  name = "lldb"
}

dap.configurations.cpp = {
  {
    name = "Launch",
    type = "lldb",
    request = "attach",
    program = function()
      return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/', 'file')
    end,
    args = {}
  },
}

It does launch the terminal and the application within it, but in my tests I then got a failed to attach to a process error from the adapter. Not sure why.

In any case. It looks like there's ongoing work on the runInTerminal functionality.

Update:: Added a config.program = nil after setting config.pid, so that lldb doesn't try to attach to a program with the same name. Now the error is Operation not permitted.

[mfussenegger]

Attach by pid didn't work because I had YAMA enabled. After disabling it with echo 0 > /proc/sys/kernel/yama/ptrace_scope the snippet in the previous reply works kind of. (Though the config.pid loop really would need a timeout to avoid it from blocking endlessly if the program can't be started)

[bresilla]

Wow. Amazing.
Thanks for all your work man. :)

I might sound ignorant (cos probably i am in this regard), but then, to call the debugger from vim i would use: :lua dap.run(lldb) or what argument should i use to call the :lua dap.run() to start it?

[mfussenegger]

to call the debugger from vim i would use: :lua dap.run(lldb) or what argument should i use to call the :lua dap.run() to start it?

:lua require('dap').continue() can be used to start it.

See :help dap.continue()

[bresilla]

Thanks :)

I had problems with it, because i was trying to debug a rust program, so i just chaged dap.configurations.cpp to dap.configurations.rust because i realized that the plugin detects the file type than it runs for that specific type.