Débogage des programmes

Débogage

Pour déboguer un programme COBOL, vous devez d’abord exécuter une tâche de compilation avec les options de débogage appropriées. Une fois que cela est fait, vous pouvez lancer le programme compilé dans une session de débogage.

Vous pouvez en savoir plus sur les tâches de compilation de SuperBOL dans le chapitre Compilation des programmes.

Note

Nous recommandons qu’une version de GnuCOBOL au moins aussi récente que la version 3.2 soit disponible sur le système exécutant VSCode. Les fonctions de débogage et de couverture supposent respectivement que gdb et gcov sont installés.

Sur les systèmes Windows, les utilisateurs peuvent utiliser des installateurs dédiés qui sont disponibles ici. Les utilisateurs de Linux peuvent se fier à leur gestionnaire de paquets préféré et installer gnucobol.

Lancement du programme compilé pour le débogage

Si nécessaire, vous pouvez placer un point d’arrêt sur les instructions (ou les titres de paragraphes dans la PROCEDURE DIVISION) en cliquant sur le point rouge qui apparaît lorsque vous passez le curseur sur la marge de gauche (ou avec F9). Cliquez sur le point rouge ou appuyez à nouveau sur F9 pour supprimer un point d’arrêt. Ensuite, pour lancer le programme en mode débogage, sélectionnez Exécuter > Démarrer le débogage (F5). Cela exécutera votre programme jusqu’à ce qu’un premier point d’arrêt soit atteint, ou jusqu’à la fin.

Démarrer le débogage

Démarrer le débogage

Une fois arrêté sur un point d’arrêt, vous pouvez examiner les valeurs des données du programme en utilisant le panneau “VARIABLES” sur la gauche.

Appuyez sur F10 pour passer à l’instruction suivante, ou F5 à nouveau pour continuer jusqu’au prochain point d’arrêt ou jusqu’à la fin de l’instruction.

Configurations de débogage SuperBOL

SuperBOL peut gérer plusieurs scénarios de débogage, tels que le lancement d’un programme pour le déboguer, l’attachement à un processus en cours d’exécution ou même l’attachement à un processus distant pour le déboguer.

Afin de sélectionner le scénario que SuperBOL doit exécuter, vous devez fournir une liste de configurations stockées dans le fichier .vscode/launch.json. Ce fichier peut être généré en suivant les étapes suivantes :

  1. Ouvrez le panneau Run and Debug (Exécuter et Déboguer) (Ctrl+Maj+D)

Exécution et déboguer

Exécution et déboguer

  1. Cliquez sur le lien créer un fichier launch.json. Si vous n’avez pas ce visuel, cela signifie que vous avez déjà un tel fichier, vous devriez être en mesure de l’ouvrir maintenant et de sauter le reste de ces étapes.

  2. Une liste de configurations prédéfinies vous sera présentée, vous devriez sélectionner l’option SuperBOL Debugger for GnuCOBOL.

  3. Le .vscode/launch.json sera généré avec des configurations prédéfinies fournies par superbol :

    {
   // Utilisez IntelliSense pour en savoir plus sur les attributs possibles.
   // Pointez pour afficher la description des attributs existants.
   // Pour plus d'informations, visitez : https://go.microsoft.com/fwlink/?linkid=830387
   "version" : "0.2.0",
   "configurations": [
       {
           "name": "SuperBOL : debug (launch)",
           "type": "superbol-gdb",
           "request": "launch",
           "preLaunchTask": "SuperBOL : build (debug)",
           "target": "${file}",
           "arguments": ""
       },
       {
           "name": "SuperBOL : debug (attach local)",
           "type": "superbol-gdb",
           "request": "attach",
           "pid": "${input:pid}",
           "target": "${file}"
       },
       {
           "name": "SuperBOL : debug (attach remote)",
           "type": "superbol-gdb",
           "request": "attach",
           "remoteDebugger": "${input:remoteDebugger}",
           "target": "${file}"
       }
   ]
}

Grâce à ces préréglages, vous pouvez gérer les différents scénarios présentés plus tôt :

  • "SuperBOL : debug (launch)" essaiera de compiler le programme ouvert et d’exécuter gdb sur le programme compilé.

  • SuperBOL : debug (attach local)" vous demandera un pid pour attacher le débogueur gdb, et utilisera le fichier COBOL ouvert actuellement comme code source du processus attaché.

  • "SuperBOL : debug (attach remote)" vous demandera une adresse et un port pour se connecter à un débogueur distant, avec gdbserver, et utilisera le fichier COBOL actuellement ouvert comme code source du processus distant.

Note

Dans tous les scénarios présentés, vous devez avoir la source COBOL sur votre système local, et avoir le programme que vous souhaitez déboguer ouvert dans votre éditeur.

Pour la configuration SuperBOL : debug (attach remote), le serveur doit avoir gdbserver installé et disponible.

Pour choisir la configuration à utiliser pour déboguer votre programme, vous devez :

  1. Ouvrez le panneau Exécuter et déboguer (Ctrl+Maj+D)

  2. Sélectionnez la configuration dans le menu déroulant en haut du panneau.

Pour lancer le débogage, vous pouvez ensuite appuyer sur la touche F5. La configuration que vous avez sélectionnée devrait être exécutée par défaut.

Les deux configurations remote ont besoin d’une entrée pour être lancées avec succès, ce qui nécessite une configuration manuelle, qui est expliquée dans la section suivante.

Gestion des entrées de configuration

Comme vous l’avez peut-être remarqué, certains champs des configurations SuperBOL ont un paramètre ${input:<identifiant>}. Cela signifie que vous devez fournir une entrée lors du lancement de la configuration.

VSCode ne fournit pas de moyen de configurer automatiquement ces entrées, vous devez donc écrire vous-même certaines configurations. Pour configurer ces entrées, vous devez :

  1. Ouvrez le fichier .vscode/launch.json.

  2. Ajoutez un tableau inputs dans le fichier :

    {
    "version": "2.0.0",
    "configurations": [
        ...
    ],
    "inputs": []
}

  3. Dans ce tableau, ajoutez chaque entrée nécessaire aux configurations de débogage, dans notre cas, il s’agit de "pid" et "remoteDebugger" (vous pouvez n’ajouter qu’un seul des deux si vous n’avez pas l’intention de les utiliser tous les deux). Votre tableau d’entrées devrait ressembler à ceci :

    {
   "inputs" : [
       {
           "id" : "pid",
           "type" : "promptString",
           "description" : "PID du processus auquel s'attacher".
       },
       {
           "id" : "remoteDebugger",
           "type" : "promptString",
           "description" : "Adresse du débogueur distant".
       }
   ]
}

    Dans ce tableau, chaque objet a les mêmes champs, avec des valeurs différentes:

    • "id" : L’identifiant de l’entrée, doit être le même que l’identifiant à droite de ${input:<identifiant>} dans votre configuration.

    • "type" : Le type d’entrée à fournir, ici "promptString" signifie qu’il vous sera demandé d’entrer une chaîne de caractères avant que la configuration ne soit lancée.

    • "description" : Une petite description de l’entrée à fournir.

Maintenant, lorsque vous utilisez la configuration "attach", VSCode vous demandera l’entrée correspondante.

Personnaliser les configurations de débogage

Les configurations prédéfinies peuvent ne pas être adaptées à votre cas d’utilisation, mais vous pouvez les personnaliser pour répondre à vos besoins.

Pour personnaliser votre configuration de débogage, vous pouvez soit éditer les préconfigurations, soit en ajouter un nouveau dans le fichier .vscode/launch.json. Voici les champs que vous pouvez ajouter ou éditer dans les configurations :

  • "name" (requis) : Le nom de la configuration, vous pouvez lui donner le nom que vous souhaitez.

  • "type" (requis) : C’est le seul champ constant, qui doit toujours avoir la valeur "superbol-gdb".

  • "request" (requis) : Cela devrait être soit :

    • "launch" : cela signifie que le débogueur s’exécutera sur une cible qu’il lance

    • "attach" : cela signifie que le débogueur s’attachera à un processus déjà en cours d’exécution

  • "preLaunchTask" : Ce champ indique quelle tâche doit être exécutée avant une requête "launch". Il doit correspondre au label de la tâche de compilation qui doit être exécutée avant le lancement. Vous pouvez consulter Configurer une tâche de compilation pour plus d’informations sur ces tâches.

  • "target" : Chemin vers le programme à déboguer. Vous pouvez le définir avec la valeur "${file}" pour déboguer le programme qui est ouvert dans votre éditeur

  • "arguments" : Un tableau d’arguments à passer au programme débogué. Dans une requête "attach", ces arguments ne seront transmis qu’au redémarrage du programme.

  • "cwd" : Le répertoire à partir duquel le débogueur doit être lancé.

  • "env" : Un objet contenant des variables d’environnement, par exemple :

    {
    "COB_LIBRARY_PATH" : "/usr/lib/cobol/modules"
}

  • "useCobcrun" : Utilise un chargeur de modules COBOL, vous pouvez spécifier le chargeur à utiliser dans "cobcrunPath".

  • "cobcrunPath" : Chemin d’accès au chargeur de modules cobol, "cobcrun" par défaut.

  • "sourceDirs" : Un tableau de chemins pour spécifier où chercher le code source. Si ce tableau n’est pas fourni, seul le répertoire courant est pris en compte.

Certaines options sont spécifiques à un type de "request" :

  • dans les requêtes "launch" vous pouvez définir :
    • "gdbtty" : Ce champ vous permet d’utiliser un terminal différent pour les l’entrée et la sortie COBOL. Il peut être mis à false pour utiliser le terminal de débogage intégré, true pour utiliser un terminal externe, qui peut être choisi parmi xterm, gnome-terminal, xfce4-terminal, ou konsole. Vous pouvez également définir le champ avec l’une des valeurs suivantes:
      • "vscode" : Utilise le terminal de VSCode.
      • "xterm", "gnome-terminal", xfce4-terminal", "konsole" : Utilise le terminal spécifié par la chaîne.
      • "external" : Utilise l’un des terminaux listés précédemment, le premier qui est disponible pour être exécuté sera utilisé.
  • Dans les requêtes "attach" vous pouvez définir :
    • "pid" : Le PID du programme à attacher. Vous devez utiliser une variable ${input:<identifiant>} si le PID du programme n’est pas constant.
    • "remoteDebugger" : Adresse de gdbserver, au format "hôte:port".

Exemples de configurations de débogage

Ces différents examples se trouvent dans le tableau "configurations" du fichier .vscode/launch.json.

Déboguer un module GnuCOBOL, avec un chemin cobcrun personnalisé

{
    // Nom personnalisé pour la configuration
    "name": "SuperBOL: debug (module)",

    "type": "superbol-gdb",

    // Le débogueur exécutera la programme à déboguer
    "request": "launch",

    // Utlisation d'une tâche de compilation personnalisée
    "preLaunchTask": "SuperBOL: build (module + debug)",
    "target": "${file}",

    // Utilsation d'un chargeur de module GnuCOBOL
    "useCobcrun": true,

    // Utilisation d'un `cobcrun` spécifique, donné avec son chemin
    "cobcrunPath": "/opt/gnucobol/bin/cobcrun"
}