Vos premiers pas

Nous allons découvrir toutes les notions essentielles de ce langage. À la fin du chapitre vous serez capable de créer un programme qui gère de manière simple les entrées clavier d’un utilisateur.

Structure générale

Avant d’attaquer la structure classique d’un programme, j’aimerais vous faire faire un petit tour d’horizon de la syntaxe générale.

Principe global

Cobol est un langage de programmation très structuré, vous ne pouvez pas noter ce que vous voulez où ça vous chante. Il y a une section consacrée à la déclaration de toutes vos variables, une autre pour noter ce que vous allez afficher et/ou pour récupérer les saisies de l’utilisateur, etc.

En gros, cela se décompose en divisions qui contiennent plusieurs sections et qui elles-mêmes sont formées de paragraphes. Et comme dans la langue française un paragraphe est composé d’une étiquette et de phrases ! Et cette fois-ci, comme en français, chaque phrase finit par un point.

Voici un schéma qui vous récapitule cela de manière très simpliste :

Notez bien les points à la fin de chaque phrase.

Ok, des étiquettes, des phrases… Mais c’est quoi ?!

C’est tout bête, l’étiquette va permettre de hiérarchiser vos phrases. Celle-ci se distingue par un nombre entier, la première valeur étant 1, jusqu’à XX.
Et les phrases sont simplement des instructions pour ceux qui ont fait de la programmation. Et pour ceux qui n’en ont jamais fait, les instructions sont des directives que l’on donne à notre programme pour lui dire ce qu’il doit faire.

Re-voyons le petit schéma de tout à l’heure de manière un peu plus concrète :

Vous avez sûrement remarqué un petit quelque chose, on a imbriqué une étiquette et phrase dans une autre : sachez que c’est possible et régulièrement utilisé. Nous nous pencherons plus en détail là-dessus en temps voulu.

Encore une fois je vous avertis, ça n’a l’air de rien comme ça mais croyez-moi, l’oubli du point à la fin des phrases est assez fréquent !

Les divisions

Un programme en Cobol est toujours composé de plusieurs divisions, je vais vous présenter les plus courantes mais nous en verrons d’autres d’ici la fin du cours.

En tête du programme

L’en-tête n’est pas obligatoire pour passer la compilation, mais elle est quand même utile pour avoir un minimum d’informations sur le programme qui se trouve sous vos yeux, car quand c’est frais dans votre tête ça passe, mais dans plusieurs mois ça ne sera plus forcement le cas…

Il est temps de voir vos premières (ou pas) lignes de code :

      IDENTIFICATION DIVISION.
      PROGRAM-ID. Votre-programme.

Je pense qu’il n’y a pas grand chose à expliquer ici, car il n’y a rien à comprendre. Ici IDENTIFICATION DIVISION est le nom de la division qui permet de créer l’en-tête, et PROGRAM-ID. est suivi du nom de votre programme et d’un point.

Partie déclarations

C’est là que nous allons stocker toutes les variables que l’on va utiliser dans notre programme, ici et jamais ailleurs !

      DATA DIVISION.
      WORKING-STORAGE SECTION.
         77 nomVariable PIC type.

      SCREEN SECTION.
         1 instruction.

Observons ce code d’un peu plus près. Pour les deux premières lignes, il n’y a pas vraiment de questions à se poser, c’est comme ça que l’on déclare la zone où nos données seront stockées (comme le terme DATA DIVISION nous le laisse d’ailleurs penser).

Jetons un œil du côté de ce bout de code maintenant :

      WORKING-STORAGE SECTION.
         77 nomVariable PIC type.

WORKING-STORAGE SECTION est la section dans laquelle on va déclarer toutes les variables du programme. Les détails sur la syntaxe et les mots clés seront dévoilés un peu plus bas dans cette page, le but étant ici de vous expliquer comment est construit le code en Cobol.

Passons à SCREEN SECTION :

      SCREEN SECTION.
         1 instruction

C’est ici que va se trouver le code qui sera chargé de gérer les entrées et sorties. Ou autrement dit, c’est ici que l’on mettra tout ce qui est affichage et entrées au clavier.

Partie instructions

Et là, on trouvera… les instructions ! (Non ce n’est pas une blague ! :-° )

      PROCEDURE DIVISION.
      instructions une.
      instructions deux.

C’est dans PROCEDURE DIVISION que votre programme va trouver ce qu’il est censé faire, on y placera nos boucles, conditions, etc.

Synthèse et fin de programme

Voilà pour le principe général, si on rassemble tout ce qu’on a vu jusqu’à présent nous obtenons ceci :

      IDENTIFICATION DIVISION.
      PROGRAM-ID. Votre-programme.

      DATA DIVISION.
      WORKING-STORAGE SECTION.
         77 nomVariable PIC type.

      SCREEN SECTION.
         1 instruction.

      PROCEDURE DIVISION.
      instruction1.
      instruction2.
      etc.
 
      STOP RUN.

Remarquez qu’à la ligne 16 j’ai noté une nouvelle instruction, STOP RUN. Cette ligne permet simplement de signaler la fin de votre programme.

Les commentaires

Les commentaires sont un point essentiel en programmation et j’aimerai aborder ce dernier point avec vous.

Pour un petit programme de quelques lignes ce n’est pas très utile, mais quand il y en a des centaines, c’est indispensable pour vous y retrouver ou pour l’éventuelle personne qui relira votre code ! Évidemment les commentaires ne sont pas interprétés par le compilateur, c’est uniquement destiné aux yeux des développeurs ! ;)

NetExpress

Les commentaires se signalent dans la marge avec une étoile (*), comme ceci :

Les variables

Comme dit précédemment, les déclarations de nos variables se font dans DATA DIVISION, et plus précisément dans WORKING-STORAGE SECTION.

Revoyons le petit bout de code de tout à l’heure :

      WORKING-STORAGE SECTION.
         77 variable PIC 9.

Décomposons un peu cette bizarrerie…

  • On retrouve l’étiquette, ici : 77

Je vous entends déjà hurler en me demandant "Mais pourquoi 77 ?!", et bien sachez que c’est tout simplement une convention de nommage pour les variables en COBOL. Autant vous habituer tout de suite puisque dans tous ce cours nos variables seront déclarées avec l’étiquette 77. ;)

  • Ensuite on retrouve le nom de notre variable, sachant que son nom doit être composé seulement de caractère alphanumérique.

  • Passons à : PIC 9
    PIC est un mot clé qui permet de décrire la forme qu’aura votre variable. Et le chiffre 9 sert à indiquer le type de donnée que la variable va contenir. Ici 9 correspond à un chiffre entier (de 0 à 9).
    Pour en revenir à la forme, elle correspond à la manière de représenter la variable. Par exemple si la variable vaut 457.24 (nombre au pif) la forme sera 999v99. Ici v marque la présence d’une virgule.

Je vous propose une tableau pour synthétiser la déclaration des types de manière simple :

En COBOL

Correspondance

9

Nombre à 1 chiffre

9(5)

Nombre à 5 chiffres

a(10)

Chaîne de 10 caractères alphabétiques

x(25)

Chaîne de 25 caractères alphanumériques

9v9

Nombre à 1 chiffre et 1 décimale

9(3)v9(2)

Nombre à 3 chiffres à 2 décimales

s9(3)

Nombre à 3 chiffres signé (+) ou (-)

Un mot sur les structures

Vous pouvez également créer des structures de données avec vos variables, comme ceci :

      1 personne.
         2 nom PIC x(30).
         2 prenom PIC x(30).
         2 adresse.
            3 numero PIC 9(3).
            3 rue PIC x (40).
            3 code postal PIC x(5).
            3 ville PIC x(20).

Je ne vous en dis pas plus pour l’instant nous verrons cela plus tard en détail mais sachez juste que ça existe.

Les plages

Les plages sont une notion indispensable dans un programme (pas de panique, c’est très simple), sans elles votre application n’aurait aucun dialogue avec l’utilisateur ; or de nos jours, c’est primordial ne serait-ce que pour informer du bon ou mauvais déroulement du programme.

Les plages permettent de gérer les entrées et sorties de l’ordinateur, l’entrée étant le clavier (ce que l’utilisateur va taper) et la sortie étant l’affichage à l’écran. On va pouvoir observer 2 types de plage pour l’instant, les plages dîtes d'affichage, et celles de saisie.

Plage d’affichage

Regardez attentivement ce code :

      SCREEN SECTION.

      1 a-plg-titre.
          2 BLANK SCREEN.
          2 LINE 3 COL 15 VALUE 'Hello world !'.

La gestion des entrées/sorties se fait dans SCREEN SECTION, donc on déclare ligne 1 ce que l’on va faire.

Ensuite, comme je vous l’ai dit tout à l’heure on doit mettre des étiquettes avant chaque instruction. Et ici nous sommes à la racine de la hiérarchie, donc l’étiquette logique sera 1.

J’emploie le terme "logique" car évidemment vous pouvez mettre n’importe quel chiffre. Mais mieux vaut se plier aux bonnes pratiques directement.

Ce qui suit l’étiquette n’est rien d’autre que le nom de notre paragraphe, ici a-plg-titre, autrement dit affichage-plage-titre. C’est ce nom qui sera utilisé pour appeler l’affichage.

Ligne 4 nous descendons d’un niveau dans la hiérarchie, donc l’étiquette est 2. Si on avait besoin de descendre plus bas, ça serait 3, puis 4, puis 5, etc. BLANK SCREEN permet d’effacer ce qui est affiché à l’écran.

Ligne 5, nous sommes toujours au même niveau que la ligne 4, donc l’étiquette sera encore une fois égale à 2. C’est là que ça devient intéressent ! LINE en anglais veut dire ligne, cela signifie donc qu’on se positionne à la ligne 3, et COL pour colonne. Donc on commencera à afficher notre texte à la ligne 3, colonne 15.

Selon votre compilateur, le mot COL est interprété comme étant une erreur. Dans ce cas vous devez remplacer COL par COLUM.

Le positionnement de votre texte est obligatoire, ce n’est pas très commun dans un langage de programmation de le faire de cette manière, mais… c’est du Cobol ! :D

Passons à VALUE, qui signifie valeur. Ce qui suit ce mot-clé sera donc ce qui sera affiché dans la console. Il suffit donc d’écrire notre texte entre des guillemets simples comme ceci : 'Hello world !' sans oublier notre point !

Plage de saisie

Toujours dans SCREEN SECTION, on place nos plages de saisie :

      1 s-plg-nom.
         2 LINE 5 COL 8 VALUE 'Quel est votre nom : '.
         2 PIC x(25) TO nom REQUIRED.

Rien de plus compliqué qu’avant pour l’instant aux lignes 1 et 2, s-plg-nom, pour saisie-plage-nom, nous placerons le texte indicatif à la 5e ligne, 8e colonne.

C’est ici qu’il y a des nouveautés, pour rappel voici ce que je vous ai dit à propos du mot-clé PIC :

PIC est un mot-clé qui permet de décrire la forme qu’aura votre variable.

Mais indiquer la forme de la variable au début, ça ne suffit pas ? :-°

Eh bien… Non ! Ici, donner la forme de la variable n’influera pas sur la variable en elle-même mais sur la manière dont la saisie va être affichée. Et c’est aussi valable pour les plages d’affichage lorsque l’on voudra afficher la valeur d’une variable !

Voici une capture d’écran qui devrait vous aider à comprendre le fonctionnement des formes :

Quand vous avez plusieurs champs à remplir avec des entrées clavier, vous pouvez utiliser la touche TAB pour passer au champ suivant, sinon utilisez les flèches.

Ensuite, x(25) va permette d’entrer une chaine de 25 caractères qui sera récupérée dans nom via le mot-clé TO. Il y a également autre chose de nouveau, le mot REQUIRED permet de rendre obligatoire la saisie du nom pour continuer le programme.

Résumons, vous voulez bien ?

Voici ce à quoi devrait ressembler le code dans sa globalité :

      IDENTIFICATION DIVISION.
      PROGRAM-ID. HelloWorld.
           
      DATA DIVISION.
      WORKING-STORAGE SECTION.
      77 nom PIC x(25).


      SCREEN SECTION.
      1 a-plg-titre.
          2 BLANK SCREEN.
          2 LINE 6 COL 10 VALUE 'Hey !'.

      1 s-plg-nom.
          2 LINE 8 COL 8 VALUE 'Quel est ton nom ? '.
          2 PIC x(25) TO nom REQUIRED.

      1 a-plg-nom.
          2 LINE 10 COL 8 VALUE 'Salut'.
          2 COL 15 PIC x(25) FROM nom.

Je vais profiter du résumé pour introduire une nouvelle fois un mot clé… :-°

Vous avez très certainement vu que j’ai ajouté une plage, regardez la ligne surlignée, j’ai créé une nouvelle plage qui va nous permettre d’afficher le nom que l’utilisateur a entré. Le mot-clé FROM permet simplement de récupérer la valeur que contient la variable nom.

Si on synthétise, on a donc :

  • TO pour attribuer une valeur à notre variable ;
  • FROM pour récupérer la valeur d’une variable.

Les procédures

C’est dans les procédures que va se situer le cœur de notre programme ! C’est ici que l’on va écrire toutes les instructions du programme.

On va continuer sur l’exemple de tout à l’heure, on va demander à notre utilisateur d’entrer son nom et ensuite nous lui dirons bonjour. Vous verrez, c’est facile !

Je change les conventions de nommage de mes plages afin de vous habituer aux différentes possibilités, ici pla : plage d’affichage et pls : plage de saisie.

      PROCEDURE DIVISION.

      * On affiche le nom de notre programme
      DISPLAY pla-titre. 

      * Ensuite on affiche le formulaire de saisie
      DISPLAY pls-nom. 
      ACCEPT pls-nom.  
      DISPLAY pla-nom. 

      STOP RUN.

Examinons cela

Quelques nouveautés sont à expliquer ici. Je pense que pour la première ligne ça devrait aller, on a juste déclaré qu’on allait écrire nos instructions.

      DISPLAY pla-titre.
      DISPLAY pls-nom.
      ACCEPT pls-nom.
      DISPLAY pla-nom.

On retrouve plusieurs fois le mot clé DISPLAY, ce qui signifie "Afficher". En gros, on lui dit "affiche moi cette plage" ! Donc sur les lignes 1, 2 et 4 on affiche enfin les plages que nous avons créées tout à l’heure.

Regardez ensuite la ligne 3, elle contient une instruction très importante ! Celle-ci permet en effet d’accepter les valeurs entrées et de les mettre en mémoire.

Et à la fin on a l’instruction STOP RUN qui arrête le programme tout bêtement.

Bonus : Les étiquettes

Voyons ensemble un dernier exemple !

Je vais vous donner un code complet, essayez de comprendre ce que j’ai modifié par rapport à la manière que je vous ai décrite tout à l’heure :

      IDENTIFICATION DIVISION.
      PROGRAM-ID. ExempleEtiquette.

      DATA DIVISION.
      WORKING-STORAGE SECTION.
      77 a PIC 9(15).


      SCREEN SECTION.
      1 pls-exemple.
          2 BLANK SCREEN.
          2 LINE 6 COL 10 VALUE 'Saisir une valeur : '.
          2 saisie PIC z(15) TO a REQUIRED.

      1 pla-exemple.
          2 LINE 8 COL 10 VALUE 'Resultat : '.
          2 COL 30 PIC z(15) FROM saisie.

      PROCEDURE DIVISION.

      DISPLAY pls-exemple.
      ACCEPT saisie.
      DISPLAY pla-exemple.

      STOP RUN.

Vous avez vu ? J’ai ajouté quelque chose ligne 13, cette chose s’appelle une étiquette, ici j’ai décidé de l’appeler saisie mais c’est bien-entendu au choix. Elle vous permet d’accéder à la valeur de a sous un autre nom tout simplement. Le résultat sera donc :

Saisir une valeur : 42
Résultat : 42

Manipulations

Nous allons voir comment faire certaines manipulations sur nos variables. Cobol propose des outils très simples pour cela et on va en voir quelques uns.

Voilà le code que l’on va poser afin de poursuivre notre apprentissage : 

      IDENTIFICATION DIVISION.
      PROGRAM-ID. Manipulation.

      DATA DIVISION.
      WORKING-STORAGE SECTION.
      77 a PIC 99.
      77 b PIC 99.
      77 c PIC 99.

      SCREEN SECTION.
      * On créera nos plages ici

      PROCEDURE DIVISION.
      * Idem pour les procédures

      STOP RUN.

MOVE

Celui-ci permet d’attribuer une valeur à une variable, comme ceci :

      IDENTIFICATION DIVISION.
      PROGRAM-ID. Manipulation.

      DATA DIVISION.
      WORKING-STORAGE SECTION.
      77 a PIC 99.
      77 b PIC 99.
      77 c PIC 99.


      SCREEN SECTION.

      1 pla-res.
          2 BLANK SCREEN.
          2 LINE 5 COL 10 'C vaut : '.
          2 PIC 99 FROM c.

      PROCEDURE DIVISION.

      MOVE 37 TO c.

      DISPLAY pla-res.

      STOP RUN.

Résultat :

C vaut : 37

Vous pouvez également importer une valeur dans plusieurs variables : MOVE 5 TO a b c.

COMPUTE

Permet simplement d’effectuer des calculs sur une ou plusieurs variables.

      IDENTIFICATION DIVISION.
      PROGRAM-ID. Manipulation.

      DATA DIVISION.
      WORKING-STORAGE SECTION.
      77 a PIC 99.
      77 b PIC 99.
      77 c PIC 99.

      SCREEN SECTION.

      1 pla-res.
         2 BLANK SCREEN.
         2 LINE 5 COL 10.
         2 PIC 99 FROM a.
         2 COL 12 ' + '.
         2 PIC 99 FROM b.
         2 COL 18 ' = '.
         2 PIC 99 FROM c.

      PROCEDURE DIVISION.

      MOVE 5 TO a.
      MOVE 15 TO b.
      COMPUTE c = a + b.

      DISPLAY pla-res.

      STOP RUN.

Résultat :

05 + 15 = 20

Bien sur ici j’ai pris l’exemple de l’addition, mais toutes les opérations de base fonctionnent, j’aurais très bien pu faire COMPUTE c = 3 - a / (2 * b) + 1. ;)

ADD

ADD va nous permettre par exemple d’incrémenter une variable qui a déjà été initialisée. Voyons ça :

      IDENTIFICATION DIVISION.
      PROGRAM-ID. Manipulation.

      DATA DIVISION.
      WORKING-STORAGE SECTION.
      77 a PIC 99.

      SCREEN SECTION.

      1 pla-res.
          2 LINE a COL 10 'Valeur de a : '.
          2 PIC 99 FROM a.

      PROCEDURE DIVISION.

      MOVE 5 TO a.
      DISPLAY pla-res.
      ADD 2 TO a.
      DISPLAY pla-res.

      STOP RUN.

Résultat :

Valeur de a : 5

Valeur de a : 7

Voilà c’est tout simple ! J’attire également votre attention sur la ligne 11, il y a là un p’tit quelque chose dont je ne vous ai pas encore parlé, mais l’occasion s’est présentée avec ADD. :)

Vous avez dû le comprendre si vous avez bien fait attention au code que je vous ai donné, mais quand vous indiquez les lignes et les colonnes de votre affichage, vous pouvez le faire via des nombres entiers comme nous l’avons fait jusqu’à présent, et vous pouvez également passer par des variables qui contiennent un entier !

INITIALIZE

Cette fonction permet d’initialiser une variable à la valeur dite "null" qui correspond au type de la variable sur laquelle on utilise cette fonction.

Voilà un exemple sans INITIALIZE :

      IDENTIFICATION DIVISION.
      PROGRAM-ID. Manipulation.

      DATA DIVISION.
      WORKING-STORAGE SECTION.
      77 a PIC 99.

      SCREEN SECTION.

      1 pla-ini.
          2 BLANK SCREEN.
          2 LINE 5 COL 10 'Pour a : '.
          2 PIC 99 FROM a.

      PROCEDURE DIVISION.

      DISPLAY pla-ini.

      STOP RUN.

Essayez de compiler et d’exécuter… Et là ! Un beau message d’erreur apparaît :

Ré-essayons avec INITIALIZE : 

      * ...
      PROCEDURE DIVISION.

      INITIALIZE a.
      DISPLAY pla-ini.

      STOP RUN.

Et là ça marche ! Voilà le résultat :

Pour a : 00

Attention… Interro surprise !

Pour vous entrainer je vous invite à essayer de faire un programme qui demande 2 chiffres à l’utilisateur et ensuite qui calcule le produit des 2 chiffres. Je ne vous donnerai pas la solution, c’est très simple et vous avez tout le nécessaire dans ce chapitre, si jamais vous avez du mal ! ;)

Pour vos premiers pas avec COBOL, vous avez réalisé un programme simple qui récupère une valeur saisie et qui vous l’affiche à l’écran. C’est déjà pas mal, et ça doit vous changer si vous connaissez déjà d’autres langages ! :-°

Ce chapitre est un peu dense, alors n’hésitez pas à y revenir en cas d’oubli.

Pour vous aider, voici un rappel sur les erreurs à éviter :

  • Faites bien attention aux points, qui sont un oubli très fréquent !
  • Si vous voulez afficher ou effectuer certaines opérations sur une variable, initialisez-la au préalable.

Dans le prochain chapitre, nous allons aborder les conditions.