Compilation des programmes

SuperBOL Studio vous permet de compiler directement vos programmes COBOL avec GnuCOBOL.

Note

Nous recommandons qu’une version de GnuCOBOL qui soit au moins aussi récente que la version 3.2 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.

Toutes les actions décrites ci-dessous doivent commencer dans un fichier COBOL ouvert, afin que VSCode sache que vos configurations sont faites pour le langage COBOL, avec l’extension SuperBOL.

Compilation simple

Si vous souhaitez compiler vos programmes COBOL avec les options par défaut de cobc :

appuyez sur Ctrl+Maj+B, ou cliquez sur l’option de menu Terminal > Exécuter la tâche de build....
plusieurs options de compilation par défaut vous seront présentées, sélectionnez celle que vous souhaitez exécuter :

Options de compilation par défaut

Ces options ont les effets suivants, en supposant que vous ayez ouvert PROG.cob :

SuperBOL : build : cette option compile votre programme en tant qu’exécutable, sans informations de débogage, et exécute la commande cobc suivante:
```
cobc -x -fformat=auto -std=default -ext cpy -ext cbl -ext cob PROG.cob -I .
```
SuperBOL : build (debug) : cette option compile votre programme comme exécutable, avec des informations de débogage, il exécutera la commande cob suivante:
```
cobc -x -ftraceall -g -fformat=auto -std=default -ext cpy -ext cbl -ext cob PROG.cob -I .
```
SuperBOL : build (module) : cette option construira votre programme comme un module, sans informations de débogage, il exécutera la commande cobc suivante:
```
cobc -m -fformat=auto -std=default -ext cpy -ext cbl -ext cob PROG.cob -I .
```

Paramètres ayant une influence sur les tâches de compilation

Certains paramètres de l’Utilisateur ou de l’Espace de travail ont une influence sur les commandes exécutées par les tâches de compilation. Vous pouvez consulter la liste des options disponibles pour en savoir plus à leur sujet.

Les options qui ont un effet sur les tâches de compilation sont les suivantes :

superbol.cobol.dialect : définit l’option -std de cobc
superbol.cobol.sourceFormat : définit l’option -fsource-format de cobc.
superbol.cobol.copybooks : ajoute les indicateurs -I à cobc, un pour chaque valeur du tableau.
superbol.cobcPath : définit le chemin cobc qui sera exécuté pour compiler vos programmes.

Configuration d’une tâche de compilation

Si vous souhaitez effectuer des tâches de compilation plus complexes, vous pouvez créer votre propre tâche de compilation à partir de n’importe quelle tâche de compilation fournie par SuperBOL.

Pour ce faire, vous pouvez:

ouvrir la palette de commandes VSCode avec Ctrl+Maj+P
sélectionner l’option Tâches : Configurer une tâche :
la liste des tâches de compilation par défaut de SuperBOL devrait alors s’afficher :
à partir de cette liste, vous pouvez sélectionner n’importe laquelle de ces tâches, mais pour réduire le nombre d’options à éditer, vous pouvez choisir celle qui correspond le mieux aux actions de compilation que vous souhaitez exécuter. Si vous n’êtes pas sûr, vous pouvez sélectionner SuperBOL : build.

VSCode créera alors automatiquement un fichier .vscode/tasks.json, rempli avec la tâche que vous avez sélectionnée. Si le fichier existe déjà, la tâche que vous avez sélectionnée sera alors ajoutée à la liste des tâches.

En supposant que vous ayez sélectionné la tâche SuperBOL : build (debug) plus tôt, vous devriez voir apparaître contenu suivant :

{
    "version": "2.0.0",
    "tasks": [
        {
            "type": "superbol",
            "forDebug": true,
            "forCoverage": false,
            "executable": true,
            "extraArgs": [],
            "problemMatcher": [
                "$gnucobol",
                "$gnucobol-warning",
                "$gnucobol-error",
                "$gnucobol-note"
            ],
            "group": "build",
            "label": "SuperBOL: build (debug)"
        }
    ]
}

Les différents champs disponibles dans cette configuration de tâche de compilation sont également disponibles dans les autres configurations de compilation fournies par SuperBOL, mais avec des valeurs différentes. Voici une description de la signification de tous les champs dans cette configuration :

"type" : Ce champ indique à VSCode que cette configuration doit être utilisée avec l’extension SuperBOL.
"forDebug" : si ce champ vaut true, le programme sera compilé avec des informations de de débogage, sinon le programme sera compilé comme un programme prêt à la production.
"forCoverage" : si la valeur est true, alors le programme sera compilé avec des informations de couverture, sinon le programme sera compilé comme un programme normal.
"executable" : si la valeur est true, alors le programme sera exécutable, sinon le programme sera compilé comme un module à exécuter avec un lanceur COBOL (habituellement cobcrun pour les modules GnuCOBOL).
"extraArgs" : vous pouvez ajouter des options à ce tableau qui seront passées au compilateur GnuCOBOL pour être utilisées lors de la compilation de votre programme.
"problemMatcher" : ce champ ne doit pas être édité, il permet à VSCode de mettre en évidence les sources d’une erreur de compilation.
"group" : ce champ ne doit pas non plus être édité, il informe VSCode que cette tâche est utilisée pour compiler un programme.
"label" : ce champ contient le nom de la tâche de compilation, il peut être utilisé dans d’autres fichiers de configurations de VSCode, vous pouvez donc lui donner le nom qui vous convient le mieux.
"cobcPath" : ce champ est caché par défaut, mais vous pouvez mettre le chemin vers votre compilateur cobc si celui-ci n’est pas directement disponible dans votre PATH système.

Avec tous ces champs, vous devriez être en mesure de configurer votre tâche de compilation pour qu’elle réponde au mieux à vos besoins.

Compiler avec une configuration personnalisée

Une fois que vous avez configuré votre tâche de compilation, vous pouvez l’utiliser pour compiler vos programmes COBOL.

Supposons par exemple que vous ayez défini la tâche suivante, qui compile un module GnuCOBOL avec les informations de débogage :

{
    "version": "2.0.0",
    "tasks": [
        {
            "type": "superbol",
            "forDebug": true,
            "forCoverage": false,
            "executable": false,
            "extraArgs": [],
            "problemMatcher": [
                "$gnucobol",
                "$gnucobol-warning",
                "$gnucobol-error",
                "$gnucobol-note"
            ],
            "group": "build",
            "label": "SuperBOL: build (module + debug)"
        }
    ]
}

Pour utiliser votre tâche de compilation personnalisée :

ouvrez le programme COBOL que vous souhaitez compiler
appuyez sur Ctrl+Maj+B
sélectionnez l’étiquette de votre tâche de compilation personnalisée (SuperBOL : build (module + debug) dans notre exemple) :

Sélection d’une tâche de compilation par défaut

Si vous avez une tâche que vous souhaitez voir exécutée comme tâche de compilation par défaut :

appuyez sur Ctrl+Maj+P
sélectionnez Tâches : Configurer la tâche de génération par défaut
sélectionnez la tâche que vous souhaitez exécuter en tant que tâche de compilation par défaut
ouvrez les sources de votre programme COBOL
appuyez sur Ctrl+Maj+B
VSCode exécutera automatiquement la tâche que vous avez sélectionnée par défaut.

Débogage de vos programmes

Une fois vos programmes créés, vous pouvez consulter Débogage de programmes pour savoir comment vous pouvez déboguer vos programmes COBOL.

Exemples de configurations personnalisées

Voici quelques exemples de configurations que vous pourriez vouloir mettre en place, dans votre fichier .vscode/tasks.json, vous devez les ajouter au tableau "tasks".

Compilation d’un module GnuCOBOL avec les informations de débogage

{
    "type": "superbol",
    "forDebug": true, // génère les informations de debug
    "forCoverage": false,
    "executable": false, // compile un module
    "extraArgs": [],
    "problemMatcher": [
        "$gnucobol",
        "$gnucobol-warning",
        "$gnucobol-error",
        "$gnucobol-note"
    ],
    "group": "build",
    "label": "SuperBOL: build (module + debug)"
}

Compilation d’un exécutable GnuCOBOL pour vérifier la couverture

{
    "type": "superbol",
    "forDebug": false,
    "forCoverage": true, // génère les informations de couverture
    "executable": true, // compile un exécutable
    "extraArgs": [],
    "problemMatcher": [
        "$gnucobol",
        "$gnucobol-warning",
        "$gnucobol-error",
        "$gnucobol-note"
    ],
    "group": "build",
    "label": "SuperBOL: build (coverage)"
}

Envoi d’options supplémentaires à `cobc`

{
    "type": "superbol",
    "forDebug": false,
    "forCoverage": false,
    "executable": true,
    "extraArgs": [
        "-fec=all" // pass `-fec=all` to `cobc`
    ],
    "problemMatcher": [
        "$gnucobol",
        "$gnucobol-warning",
        "$gnucobol-error",
        "$gnucobol-note"
    ],
    "group": "build",
    "label": "SuperBOL: build (all exceptions)"
}