Blog ENI : Toute la veille numérique !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. Programmer en COBOL
  3. Première approche
Extrait - Programmer en COBOL Développement et Maintenance de programmes
Extraits du livre
Programmer en COBOL Développement et Maintenance de programmes
5 avis
Revenir à la page d'achat du livre

Première approche

Programmation structurée

[...]Le second, de diviser chacune des difficultés que j’examinerois, en autant de parcelles qu’il se pourroit, et qu’il seroit requis pour les mieux résoudre.

Le troisième, de conduire par ordre mes pensées, en commençant par les objets les plus simples et les plus aisés à connoître, pour monter peu à peu comme par degrés jusques à la connaissance des plus composés, et supposant même de l’ordre entre ceux qui ne se précèdent point naturellement les uns les autres.[...]

DISCOURS DE LA MÉTHODE, Descartes, 1637.

Dans certaines entreprises il peut exister des normes de développement pour faciliter l’écriture, la lecture et la compréhension des programmes et, surtout, assurer une certaine homogénéité dans leur formalisme pour une prise en main rapide. Lorsqu’elles existent ces normes sont à suivre en priorité. Leur bien-fondé n’est cependant pas toujours évident de prime abord : nous allons approfondir certains aspects de COBOL qui ont largement contribué à la mise en place de ces différentes normes afin de mieux en apprécier la légitimité.

Théoriquement avant de commencer l’écriture d’un programme, il faut connaître les données en entrée et en sortie. En réalité, la prise de contact avec COBOL se fait le plus souvent au travers de maintenances à effectuer sur des programmes déjà existants et maintes fois modifiés. Mettons-nous en situation réelle : à la fin de ce chapitre vous devriez être en mesure d’appréhender rapidement la structure de tout programme COBOL sans vous laisser induire en erreur par d’éventuelles fautes de code.

Les traitements d’un programme COBOL se trouvent dans la division PROCEDURE : c’est là que se trouve théoriquement l’algorithme principal qui permet de comprendre le traitement.

Le mot clé à rechercher est "PROCEDURE".

       PROCEDURE DIVISION.
      *
       MD01-MODULE-DIRECTEUR SECTION.
      *------------------------------
      *
       MD01-MODULE-DIRECTEUR-01.
      *=========================
           PERFORM                     MD10-INIT-TRT.

      *--> Première lecture
           PERFORM                     MD20-LECTURE-FONCTIONS.

           PERFORM MD30-TRAITEMENT...

Traitement itératif

L’instruction PERFORM permet donc d’effectuer la totalité des débranchements nécessaires dans un programme. Il faut également disposer d’instructions permettant de faire des traitements itératifs. C’est également l’instruction PERFORM qui offre cette possibilité.

1. PERFORM UNTIL : boucle jusqu’à

Cette boucle est celle qui apparaît le plus souvent directement dans le module directeur. La boucle PERFORM UNTIL est une boucle "jusqu’à" qui remplit exactement les mêmes fonctions que la boucle "tant que", usuellement utilisée en algorithmique, à condition de la coder dans le bon sens.

Exemple :

       PROCEDURE DIVISION.
      *
       MD01-MODULE-DIRECTEUR SECTION.
      *------------------------------
      *
       MD01-MODULE-DIRECTEUR-01.
      *=========================
           PERFORM                     MD10-INIT-TRT.

      *--> Première lecture
           PERFORM                     MD20-LECTURE-FONCTIONS.

           PERFORM MD30-TRAITEMENT     UNTIL WS-FIN-TRT.

           PERFORM                     MD40-FIN-TRT.
      *
       MD01-MODULE-DIRECTEUR-09.
      *=========================
           EXIT. 

Pour la traduire en algorithmique, il faut dire "Tant que... la condition n’est PAS remplie". Attention à cette négation : c’est ce qui fait qu’il ne s’agit pas d’une réelle boucle "tant que".

02CBL08.png

La condition indiquée par la clause UNTIL est similaire, par la forme et les possibilités qu’elle offre, à une condition exprimée avec l’instruction IF. Les possibilités et les règles à respecter sont expliquées en détail un peu plus loin dans ce chapitre.

Syntaxe du PERFORM UNTIL :

----+----1----+----2----+----3----+----4----+----5----+----6----+
           PERFORM   Nom-module UNTIL  Condition 
La condition est une condition de FIN d’itération.

Le module est appelé autant de fois que la condition n’est pas remplie, et si la condition est remplie au départ, le module n’est jamais appelé.

Exemple :

       PERFORM  MD10 UNTIL  J = 10
           [...]
       MD10.
           ADD    1      TO J
           DISPLAY "J = " J
           . 

La condition de fin de boucle est J = 10. Si, à l’arrivée sur cette instruction, la variable J vaut :

  • 0 : il y a 10 messages avec J allant de 1 à 10,

  • 1 : il y a 9 messages avec J allant de 2 à 10,

  • ...,

  • 10 : il n’y a aucun message,

  • 11 ou plus : le programme boucle indéfiniment...

Instructions de tests

Les chapitres précédents ont permis d’étudier :

  • les débranchements,

  • les itérations,

et d’avoir un aperçu de la notion de condition avec la boucle PERFORM UNTIL.

Exemple :

           PERFORM MD30-TRAITEMENT     UNTIL WS-FIN-TRT. 

qui aurait également pu être codé :

           PERFORM MD30-TRAITEMENT     UNTIL WS-TRT = "FIN" 

Plusieurs instructions COBOL permettent d’effectuer des tests de conditions.

Nous n’allons cependant étudier, dans ce chapitre, que les différentes possibilités d’emploi des instructions de tests sans entrer plus avant dans les conditions elles-mêmes : pour cela il faudra que nous ayons étudié la déclaration des données, dans le prochain chapitre.

1. IF THEN ELSE : la condition simple

Comme pour d’autres langages de programmation, l’instruction IF ... THEN... ELSE permet d’effectuer un test de condition simple. Elle est enrichie de son scope terminator END-IF. Commençant au minimum en 12e position, seul le mot clé IF est obligatoire.

Syntaxe :

----+----1----+----2----+----3----+----4----+----5----+----6----+
           IF Condition ou Nom-Condition
           THEN                          
              [...]
           ELSE                          
              [...]
           END-IF                         

THEN et ELSE sont optionnels :

           IF RETURN-CODE NOT = 3999
             [...]
           END-IF 

ainsi que END-IF :

           IF  PAGE-COURANTE   > NBMAX-PAGE
               MOVE NBMAX-PAGE TO PAGE-COURANTE. 

a. Point vs SCOPE TERMINATOR

C’est au niveau de cette instruction qu’il faut tout particulièrement prendre garde à l’emploi du point (ou PERIOD).

Avant la version 85 du COBOL, coder des tests imbriqués pouvait s’avérer particulièrement complexe et amenait une modularisation extrême parfois un peu lourde.

Ceux qui ont programmé dans cette version se souviennent des difficultés rencontrées pour coder correctement des instructions de condition imbriquées, et surtout pour les finir correctement. En effet le COBOL est dérivé du FLOW-MATIC dans lequel chaque instruction commence par un verbe et se termine par un point. Le point est la marque de fin :

  • de l’instruction,

  • du groupe d’instructions placé derrière une instruction conditionnelle.

Avec le seul usage de ce point pour terminer les séquences d’instructions, il est impossible de terminer une instruction conditionnelle imbriquée dans une autre instruction...

Cas pratique

Ce premier cas pratique est un extrait d’un programme récent (écrit en 2009), et plus précisément de l’un de ses modules principaux. C’est un code opérationnel. Seuls les noms des personnages ont été remplacés. Ce paragraphe va permettre de mettre en pratique les quelques règles de programmation structurée qui viennent d’être étudiées.

1. MOVE : manipulation des données

Avant cela il faut faire une rapide présentation de l’instruction MOVE...TO. C’est LA principale instruction de manipulation de données.

Syntaxe :

----+----1----+----2----+----3----+----4----+----5----+----6---...
           MOVE    donnée origine         TO variable 

Comme ce n’est pas une instruction de structure, elle commence en 12e position minimum.

Contrairement à ce que pourrait laisser croire une simple traduction littérale du verbe, il ne s’agit pas d’un déplacement de donnée, mais d’une affectation. C’est l’équivalent de l’opérateur = dans la plupart des autres langages : la donnée origine n’est pas modifiée par cette instruction, c’est la variable destinataire qui l’est.

La donnée origine peut être :

  • contenue dans une zone, variable ou constante :

----+----1----+----2----+----3----+----4----+----5----+---6---...
           MOVE ws-indice-max               TO ws-destination  

La donnée contenue dans la zone ws-indice-max est affectée à la variable ws-destination. La zone ws-indice-max reste inchangée.

  • un littéral :

----+----1----+----2----+----3----+----4----+----5----+---6---...
           MOVE "la porte de Tannhaüser"    TO WS-DESTINATION 

Le littéral "la porte de Tannhaüser" est affecté à la variable WS-DESTINATION.

ou

----+----1----+----2----+----3----+----4----+----5----+---6---...
           MOVE 2                           TO WS-DESTINATION 

La valeur 2 est affectée à WS-DESTINATION.

  • une constante figurative :

----+----1----+----2----+----3----+----4----+----5----+---6---...
           Move SPACE                       TO ws-destination 

La constante figurative SPACE est affectée à la zone ws-destination (elle est mise à blancs). Les constantes figuratives sont expliquées dans le chapitre suivant Déclarer et manipuler les données.

Le résultat d’un MOVE dépend...