Déboguez-vous du code C ++ dans Vim? Comment?

La question est à vous tous, qui utilisez Vim pour développer des applications C ++.

Il y a eu une période dans ma vie, qui peut être décrite comme "Je déteste Vim !!!" .. "Vim est gentil!"

Cependant, ayant grandi principalement sur les IDE de développement Microsoft, je me suis habitué à ceux-ci F5- les F11raccourcis lors du débogage du code, la fenêtre de surveillance, la pile d'appels et le code principal - tous visibles sans avoir besoin de taper de commandes GDB.

Alors, voici la question:

Utilisez-vous également Vim pour le débogage? Ou passez-vous à un IDE à cette fin? Laquelle?

Pour ceux qui utilisent Vim pour déboguer le code: existe-t-il des plugins pour définir des points d'arrêt dans l'éditeur, mettre en évidence la ligne que nous débogage actuellement, navigation automatique pendant l'étape, entrer, sortir?

S'il vous plaît, ne me dites pas que vous utilisez GDB comme ligne de commande, ne voyez qu'une seule ligne qui est déboguée, etc.

Contrairement aux autres réponses, il existe au moins trois options qui font exactement ce dont vous avez besoin: clewn , pyclewn et vimgdb .

Les trois projets sont liés. vimgdb est un patch contre Vim et nécessite que Vim soit recompilé. clewn est un programme autonome qui communique avec Vim via l'interface de socket Netbeans. Cela nécessite que Vim soit construit avec le+netbeans option (c'est le cas dans les distributions Linux récentes donc cela ne devrait pas être un problème).

Pour citer le site Web de clewn:

Clewn implémente le support complet de gdb dans l'éditeur vim: points d'arrêt, variables de surveillance, achèvement de la commande gdb, fenêtres d'assemblage, etc.

Je pense que vous devriez absolument essayer.

La page d'accueil du site Web de pyclewn montre une comparaison entre les trois projets.

Il y a quelques mois, j'ai essayé pyclewn. C'était un peu difficile à mettre en place, mais ça a l'air bien et prometteur. Je viens de faire quelques tests et vous pouvez définir des signets, etc., ce que vous attendez d'un débogueur graphique. J'ai fini par ne pas l'utiliser pour des raisons contingentes, mais je suis impatient de lui donner un autre essai.

Vim a ajouté un débogueur intégré officiellement dans la version 8.1, publiée en mai 2018. La fonctionnalité était également présente dans certaines des versions de la version 8.0, dès août 2017.

Les commandes vim suivantes chargent le plugin et démarrent le débogueur.

:packadd termdebug
:Termdebug

Cette dernière commande prend un programme comme argument optionnel, ou bien un programme peut être chargé depuis la gdbfenêtre avec la filecommande.

Avec le plugin chargé, gdbpeut être utilisé de manière interactive dans la fenêtre correspondante. Par exemple, des points d'arrêt peuvent être définis, le code peut être parcouru et les variables peuvent être inspectées.

Des commandes Vim peuvent être émises pour interagir avec gdb. Certaines commandes pertinentes comprennent :Step, :Over, :Finish, :Continue, :Stop, :Break, :Clearet :Evaluate.

De plus, il existe des boutons cliquables en haut de la fenêtre de l'éditeur pour interagir avec gdb.

La fenêtre de l'éditeur est mise à jour pour refléter l'état du débogage. Les >>points d' arrêt sont indiqués par et la ligne actuelle est mise en surbrillance.

La page d'aide intégrée comprend une documentation complète.

:help terminal-debug

J'ai récemment écrit un article de blog qui parcourt une session d'exemple.

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

Vim est un bon éditeur, mais pour faire le débogage, j'utilise un débogueur (comme GDB).

Mais vous n'avez pas besoin d'utiliser GDB en mode texte; vous pouvez utiliser une interface graphique comme KDbg , DDD ou Insight .

Il existe des moyens d'obtenir GDB dans Vim (mais vous obtenez un débogage basé sur du texte).

editCommande GDB

Ouvre un éditeur sur la ligne courante à l'aide de la commande:

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

La valeur par défaut editorest ex, mais vimcomprend également le +<current-line>format.

Lorsque vous quittez l'éditeur, vous revenez dans gdb.

Cela vous permet de parcourir librement la source et est particulièrement puissant si vous avez une ctagsintégration.

C'est une intégration intégrée de gdb à vim d'un pauvre homme: la principale chose manquante est de définir des points d'arrêt à partir de Vim.

edit et centre

edit ne centre pas Vim par défaut autour de la source, j'ai donc créé un script Python qui le fait: Comment ouvrir le fichier actuel à la ligne courante dans un éditeur de texte de GDB?

Commande de point d'arrêt vers l'aide du presse-papiers

Cette commande vim copie un spécificateur de point d'arrêt de type:

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

dans le presse-papiers:

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

Ensuite, vous pouvez simplement coller cela dans gdb .

Il s'agit d'une intégration vim vers gdb d'un pauvre homme pour faciliter la définition des points d'arrêt.

Tableau de bord GDB

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

Cela n'a rien à voir avec Vim, mais c'est une solution légère qui accomplit beaucoup et pourrait convenir à d'autres Vimmers.

D'autres ont mentionné GDB TUI, mais je l'ai trouvé trop cassé et pas assez puissant pour être supportable.

Je suis donc passé à des solutions basées sur l'API Python telles que GDB Dashboard.

J'ai décrit plus en détail l'utilisation et la justification à l' adresse : gdb split view with code

Voici une capture d'écran de ce que cela vous donne:

Voir aussi: /vi/2046/how-can-i-integrate-gdb-with-vim

Abandonnez et utilisez un véritable IDE

Cela dit, c'est la meilleure solution pour la plupart des gens, moi y compris. La plupart des gens gagneront juste des tonnes de temps s'ils sont capables de parcourir les définitions d'une manière compatible avec la classe C ++ sans sélectionner et installer eux-mêmes plusieurs plugins différents, et cela inclut tout le débogage. En 2020, le moins pire pour moi était Eclipse: https://www.slant.co/topics/1411/~best-ides-for-c-on-linux

L'utilisation d'un débogueur de niveau source n'est que l'une des nombreuses façons de diagnostiquer un comportement défectueux d'un programme, et je me retrouve rarement à en lancer un - malgré le fait que c'est très facile à faire.

Donc, pour moi, il n'y a tout simplement aucun avantage inhérent à l'utilisation d'un éditeur de texte qui se trouve être également un débogueur . Au lieu de cela, j'utilise l'éditeur de texte que je préfère - indépendamment du débogueur que je choisis d'utiliser. Pour le moment, j'utilise principalement gedit et kdbg à ces fins, mais ces choix évoluent indépendamment au fil du temps.

Mise à jour 2020: il existe un nouveau plugin vimspector utilisant le protocole d'adaptateur de débogage

1. Installez le plugin https://github.com/puremourning/vimspector#installation

2. Configurer (écrire .vimspector.json)

3. Compiler avec le symbole de débogage g++ cpp.cpp -ggdb -o cpp

4. Appuyez F4pour démarrer le débogage

• Notez mon .vimspector.jsondans mon répertoire personnel (donc travaillez dans n'importe quel sous-répertoire)

{
"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"
    }
  }
} }

Ayant récemment travaillé sur une application pendant une longue période qui nécessitait la mise en place d'un tas de choses sur la boîte qu'elle exécutait (configuration de l'appliance), j'ai écrit du code en vim, j'avais des scripts qui automatisaient la construction, le poussaient vers un serveur , qui avait un script là pour remarquer le fichier sentinel poussé avec les binaires. Cela redémarrerait alors les services appropriés sur la boîte, et dans une autre fenêtre ssh, j'avais untail -f exécution sur mon fichier journal.

Pour faire court, je n'ai pas du tout utilisé de débogueur. Si quelque chose venait à mourir de manière inattendue, je ferais simplement augmenter les niveaux de journalisation, le refaire et voir quelle était la dernière chose enregistrée avant sa mort, puis l'analyser et résoudre le problème.

La bonne chose était que lorsque quelque chose avait des problèmes dans un environnement client, je demandais simplement un journal au niveau du débogage et pouvais identifier le problème sans même avoir besoin d'accéder à leur serveur.

... mais oui, il y a eu des moments où il aurait été bien d'avoir un débogueur.

Juste pour ajouter à ci-dessus:

IMO vim a tendance à être un éditeur assez léger et le débogage a tendance à ajouter du poids. Il existe des moyens de le faire, c'est-à-dire en utilisant vim7.4 + avec

:terminal

et exécutez l'un des débogueurs de ligne de commande (curses) suivants. Quelques-uns sont utilisés par défaut pour les IDE que vous ne connaissiez pas. c'est-à-dire lldb = xcode.

• (c / c ++ / objective c) gdb (débogueur gnu) - https://www.gnu.org/software/gdb/
• (c / c ++ / objective c / python etc) remake - http://bashdb.sourceforge.net/remake/
• (java) débogueur oracle Java - https://docs.oracle.com/javase/7/docs/technotes/tools/windows/jdb.html
• (c / c ++ / objectif c) lldb - https://lldb.llvm.org/

évidemment, il y en a plus basés sur le cli; @all n'hésitez pas à suggérer et à ajouter à la liste. Merci!