Você depura código C ++ no Vim? Quão?

A questão é para todas as pessoas que usam o Vim para desenvolver aplicativos C ++.

Houve um período em minha vida, que pode ser descrito como 'Eu odeio Vim !!!' .. 'Vim é legal!'

No entanto, tendo crescido principalmente nos IDEs de desenvolvimento da Microsoft, eu me acostumei a esses F5- F11atalhos ao depurar código, janela de observação, pilha de chamadas e código principal - todos visíveis sem a necessidade de digitar nenhum comando GDB.

Então aqui está a questão:

Você usa o Vim também para depuração? Ou você muda para algum IDE para esse fim? Qual?

Para aqueles que usam o Vim para depurar código: existem plugins para definir pontos de interrupção no editor, realce a linha que estamos depurando atualmente, navegação automática durante a etapa, passo a passo, passo a passo?

Por favor, não me diga que você usa o GDB como linha de comando, veja apenas uma linha que está depurada, etc.

Em contraste com as outras respostas, há pelo menos três opções que fazem exatamente o que você precisa: clewn , pyclewn e vimgdb .

Todos os três projetos estão relacionados. O vimgdb é um patch contra o Vim e requer que o Vim seja recompilado. O clewn é um programa independente que se comunica com o Vim por meio da interface de soquete do Netbeans. Isso requer que o Vim seja construído com a +netbeansopção (este é o caso nas distribuições recentes do Linux, portanto não deve ser um problema).

Para citar o site do clewn:

O Clewn implementa suporte completo a gdb no editor vim: pontos de interrupção, variáveis ​​de observação, conclusão de comandos gdb, janelas de montagem etc.

Eu acho que você definitivamente deveria tentar.

A página inicial do site da pyclewn mostra uma comparação entre os três projetos.

Alguns meses atrás eu tentei pyclewn. Foi um pouco difícil de configurar, mas parece bem promissor. Acabei de fazer alguns testes e você pode definir marcadores, etc., as coisas comuns que você esperaria de um depurador gráfico. Acabei por não usá-lo por motivos contingentes, mas estou ansioso para tentar novamente.

O Vim adicionou um depurador embutido oficialmente na versão 8.1, lançada em maio de 2018. O recurso também estava presente em alguns dos lançamentos da versão 8.0, já em agosto de 2017.

Os seguintes comandos vim carregam o plug-in e iniciam o depurador.

:packadd termdebug
:Termdebug

O último comando aceita um programa como argumento opcional ou, alternativamente, um programa pode ser carregado da gdbjanela com o filecomando

Com o plugin carregado, gdbpode ser usado interativamente na janela correspondente. Por exemplo, pontos de interrupção podem ser definidos, código pode ser percorrido e variáveis ​​podem ser inspecionadas.

Os comandos do Vim podem ser emitidos para interagir com gdb. Alguns comandos relevantes incluem :Step, :Over, :Finish, :Continue, :Stop, :Break, :Clear, e :Evaluate.

Além disso, existem botões clicáveis ​​na parte superior da janela do editor para interagir gdb.

A janela do editor é atualizada para refletir o estado da depuração. Os pontos de interrupção são indicados com >>e a linha atual é destacada.

A página de ajuda interna inclui documentação completa.

:help terminal-debug

Recentemente, escrevi uma postagem no blog que mostra uma sessão de exemplo.

https://www.dannyadam.com/blog/2019/05/debugging-in-vim/

O Vim é um bom editor, mas para depurar eu uso um depurador (como o GDB).

Mas você não precisa usar o GDB no modo de texto; você pode usar um front-end gráfico como KDbg , DDD ou Insight .

Existem maneiras de obter o GDB no Vim (mas você obtém a depuração baseada em texto).

editComando GDB

Abre um editor na linha atual usando o comando:

$EDITOR +<current-line> <current-file>

O padrão editoré ex, mas vimtambém entende o +<current-line>formato.

Ao sair do editor, você volta ao gdb.

Isso permite que você navegue livremente na fonte e é especialmente poderoso se você tiver ctagsintegração.

Essa é a integração do gdb para o vim de um pobre homem: a principal coisa que falta é definir pontos de interrupção no Vim.

edit e centro

editpor padrão, não centraliza o Vim em torno da fonte, por isso criei um script Python que faz isso: Como abrir o arquivo atual na linha atual em um editor de texto do GDB?

Comando do ponto de interrupção para o auxiliar da área de transferência

Este comando vim copia um especificador de ponto de interrupção do tipo:

b <file-path>:<line-number>

para a área de transferência:

command! Xg :let @+ = 'b ' . expand('%:p') . ':' . line('.')

Então você pode simplesmente colar isso gdb.

Essa é a integração do vim com o gdb para facilitar a definição de pontos de interrupção.

Painel GDB

https://github.com/cyrus-and/gdb-dashboard

Isso não tem nada a ver com o Vim, mas é uma solução leve que alcança muito e pode se adequar a outros Vimmers por aí.

Outros mencionaram o GDB TUI, mas eu o achei muito quebrado e não poderoso o suficiente para ser suportável.

Então, mudei para soluções baseadas em API Python, como o GDB Dashboard.

Descrevi usado e justificativa com mais detalhes em: exibição dividida gdb com código

Aqui está uma captura de tela do que ele oferece:

Consulte também: /vi/2046/how-can-i-integrate-gdb-with-vim

Desista e use um IDE real

Com tudo isso dito, esta é a melhor solução para a maioria das pessoas, inclusive eu. A maioria das pessoas ganhará muito tempo se puder pular as definições de maneira ciente da classe C ++ sem selecionar e instalar vários plugins diferentes, e isso inclui etapas de depuração. Em 2020, o pior para mim foi o Eclipse: https://www.slant.co/topics/1411/~best-ides-for-c-on-linux

O uso de um depurador no nível da fonte é apenas uma das muitas maneiras de diagnosticar o comportamento defeituoso do programa, e raramente me vejo iniciando um - apesar do fato de ser muito fácil de fazer.

Portanto, para mim, simplesmente não há vantagem inerente ao uso de um editor de texto que também é um depurador . Em vez disso, eu uso o editor de texto que eu prefiro - independentemente do depurador que eu escolher usar. No momento, uso principalmente o gedit e o kdbg para esses fins, mas essas opções evoluem de forma independente ao longo do tempo.

Atualização 2020: Há um novo plugin vimspector usando o Debug Adapter Protocol

1. Instale o plug-in https://github.com/puremourning/vimspector#installation

2. Configurar (gravar .vimspector.json)

3. Compilar com o símbolo de depuração g++ cpp.cpp -ggdb -o cpp

4. Pressione F4para iniciar a depuração

• Observe meu .vimspector.jsonno meu diretório pessoal (então trabalhe em qualquer subdiretório)

{
"configurations": {
  "Python - Launch": {
    "adapter": "vscode-python",
    "configuration": {
      "name": "Python: Launch current file",
      "type": "python",
      "request": "launch",
      "stopOnEntry": true,
      "stopAtEntry": true,
      "console": "externalTerminal",
      "debugOptions": [],
      "cwd": "${cwd}",
      "program": "${file}"
    }
  },
  "Perl - Launch": {
    "adapter": "vscode-perl-debug",
    "configuration": {
      "name": "Perl: Launch current file",
      "type": "perl",
      "request": "launch",
      "exec": "/usr/bin/env perl",
      "execArgs": [],
      "stopOnEntry": true,
      "stopAtEntry": true,
      "console": "externalTerminal",
      "sessions": "single",
      "debugOptions": [],
      "cwd": "${cwd}",
      "program": "${file}"
    }
  },
  "C - Launch": {
    "adapter": "vscode-cpptools",
    "configuration": {
      "name": "Cpp: Launch current file",
      "type": "cppdbg",
      "request": "launch",
      "externalConsole": true,
      "logging": {
        "engineLogging": true
      },
      "stopOnEntry": true,
      "stopAtEntry": true,
      "debugOptions": [],
      "MIMode": "gdb",
      "cwd": "${cwd}",
      "program": "${fileDirname}/${fileBasenameNoExtension}"
    }
  },
  "Java - Launch": {
    "adapter": "vscode-java",
    "configuration": {
      "name": "Java: Launch current file",
      "request": "launch",
      "mainClass": "com.vimspector.test.TestApplication",
      "sourcePaths": [ "${workspaceRoot}/src/main/java" ],
      "classPaths": [ "${workspaceRoot}/target/classes" ],
      "args": "hello world!",
      "stopOnEntry": true,
      "console": "integratedTerminal"
    }
  }
} }

Tendo trabalhado recentemente em um aplicativo por um longo tempo que exigia um monte de coisas para serem instaladas na caixa em que estava sendo executado (configuração do dispositivo), escrevi código no vim, tinha scripts que automatizavam a construção, enviando-o para um servidor , que tinha um script para observar o arquivo sentinela enviado juntamente com os binários. Isso reiniciaria os serviços apropriados na caixa e, em outra janela ssh, eu tail -fcorria no meu arquivo de log.

Para encurtar a história, eu não usei um depurador. Se algo tivesse morrido inesperadamente, eu aumentaria os níveis de registro, refizê-lo e veria qual foi a última coisa registrada antes que ele morresse, depois analise e corrija o problema.

O bom era que, quando algo apresentava problemas no ambiente do cliente, eu apenas solicitava um log no nível de Depuração e podia identificar o problema sem precisar sequer acessar o servidor.

... mas sim, houve momentos em que seria bom ter um depurador.

Apenas para adicionar acima:

O IMO vim tende a ser um editor bastante leve e a depuração tende a aumentar o peso. Existem maneiras de fazer isso, ou seja, usando o vim7.4 + com

:terminal

e executando um dos seguintes depuradores da linha de comando (maldições). Alguns são usados ​​por padrão para IDEs que você nunca conheceu. ou seja, lldb = xcode.

• (c / c ++ / objetivo c) gdb (depurador gnu) - https://www.gnu.org/software/gdb/
• (c / c ++ / objetivo c / python etc) remake - http://bashdb.sourceforge.net/remake/
• (java) oracle java debugger - https://docs.oracle.com/javase/7/docs/technotes/tools/windows/jdb.html
• (c / c ++ / objetivo c) lldb - https://lldb.llvm.org/

Obviamente, existem mais cli; @all sinta-se livre para sugerir e adicionar à lista. obrigado!