Vous êtes sur la page 1sur 43

ESAT-DI [LRE] page 11-37

Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]


ANS85/m-soft 11/10/2009 -
11/10/2009

D) La modularisation («statique» ) avec


PERFORM

D1 Généralités-concepts

D11 les différents types de PERFORM

Le verbe PERFORM a plusieurs formats possibles qui permettent de traduire les différentes boucles dans un
programme écrit en «structuré» telles que :

début programme. début programme. début programme.


POUR variable variant de i à j (pas de
k)
FAIRE tant que condition REPETER FAIRE

bloc bloc bloc


d’instructions d’instructions d’instructions

Fin FAIRE JUSQU’A condition FIN FAIRE


arrêt du programme. arrêt du programme arrêt du programme.

Les schémas ci-dessus montrent des blocs d’instructions répétés (0 , 1 ou n fois) qui se traduisent en
cobol à l’aide de PERFORM dits «en ligne» ; c’est-à-dire que le bloc d’instructions sur lequel on
boucle , se trouve physiquement dans le programme à l ’endroit prévu par le pseudo-code de l’algorithme
pensé en «structuré» , l’ensemble étant délimité par la clause END-PERFORM (traduction du FIN FAIRE).

D12 le lien avec les sous-programmes

Néanmoins , ces blocs d’instructions ,[à répéter 0 , 1 ou n fois] , peuvent être placés après l’arrêt du
programme (STOP RUN ).

le nom du bloc d’instructions dépend de sa nature

nature du bloc nom du bloc en cobol


un paragraphe nom de paragraphe
(= nom procédure)

ensemble de nom de paragraphe-1


paragaphes THRU
nom de paragphe-n

une section nom de section

un ensemble de nom section-1


sections THRU
nom de section-2

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 37


ESAT-DI [LRE] page 11-38
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

FAIRE «nom du bloc d’instructions» tant que ..

FIN FAIRE
arrêt du programme.

nom du bloc d’instructions

bloc
d’instructions

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 38


ESAT-DI [LRE] page 11-39
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

Bien que la majorité des formats du verbe PERFORM servent à gérer les boucles , on peut constater que si
on «boucle une seule fois» sur un ensemble d’instructions rangées en un lieu particulier (après STOP RUN),
il s’agit d’un appel d’une séquence suivi d’un retour .

D’autres parts , il est possible de recommencer cette opération depuis n’importe quel endroit du programme
autant de fois qu’on le souhaite.

➯ Avec ce procédé , le bloc d’instructions qui est en fait une partie du programme (ou MODULE)
constitue un sous-programme qui présente des propriétés analogues à celles des sous-programmes
appelés par CALL :

un PERFORM (une fois) d’un ensemble d’instructions placé après STOP RUN
est ⇔ (strictement équivalent à)

un CALL d’un sous-programme interne qui n’utiliserait que des variables globales

Comparaison avec les S/P appelés par « CALL »

◆ Le bloc d’instructions peut être appelé (par PERFORM au lieu de CALL ) autant de
fois qu’on le souhaite mais uniquement par le programme maître qui le contient.

◆ Il réalise une action (relativement simple ) qui peut être réutilisée plusieurs
fois ( uniquement par le programme maître ).
[Il peut être réutilisé dans d’autres applications en utilisant l’ordre COPY ou
le fameux «copier-coller».]

◆ On ne lui passe aucune donnée car , faisant partie du programme , il a accès a


toutes les données de la data division du programme maître : il est strictement
équivalent à un vrai sous-programme(=> appelé par CALL ) interne qui
n’utiliserait que des données globales.

◆ Ce n’est pas un programme à part entière : il ne possède pas les divisions :


identification , procédure , ..data ,.. mais une partie du programme maître
constituée d’un ou plusieurs paragraphes ou d’une ou plusieurs sections.

◆ Il fait partie du source du programme appelant ( => un seul fichier.cbl , un seul


objet .obj , un seul executable .exe ) => on parle de modularisation statique
(comme pour les sous-programmes internes).

◆ Comme pour le CALL ...+...EXIT PROGRAMM , lorsque l’exécution du module est


terminée , l’exécution du programme appelant se poursuit à partir de
l’instruction qui suit le verbe PERFORM.
Le point qui termine la dernière instruction du dernier paragraphe de la dernière
section , joue le rôle de L’EXIT PROGRAM.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 39


ESAT-DI [LRE] page 11-40
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

D13 pourquoi et quand modulariser avec PERFORM ? [ avantages -


inconvénients ]

La modularisation dynamique qui consiste à découper une application en sous-programmes


externes ( qui réalisent une action précise à partir de données fournies en entrée et

NB ➳ qui retournent des résultats) est essentielle pour l’ellaboration de logiciels


performants.

Quant-à découper un de ces sous-programmes en petits modules appelés par PERFORM ou


CALL S/P interne ( modularisation statique ), je suis plus réservé et invite le
lecteur à suivre les conseils énumérés ci-dessous.

On peut utiliser cette technique dans les cas suivants :

❶ pour simplifier le code du programme maître et pour sérier les difficultés [cf parag. A12 ] :

Dans ce cas , le bloc d’instructions ne fait qu’une [ou un ensemble] action relativement simple ;
il comprend un ou des algorithmes limités en taille et en difficulté.

Le code écrit peut être réutilisé dans d’autres applications en le copiant dans le nouveau source;
néanmoins , si le but est la «réutilisabilité» , il est préférable de réaliser un vrai sous-
programme externe auquel on passe éventuellement les paramètres voulus.

[à ce sujet , on pourrait reprendre le conseil de la page 11-8 concernant les variables globales]

❷ pour simplifier la conception :

 faute de méthode , certains programmeurs ne savent pas appréhender un problème dans sa globalité :
ils résolvent séparément des parties du programme et les relient par des PERFORM «sauvages» (ou
autres GO TO ..) en ayant l’impression d’avoir réalisé un chef d’oeuvre structuré et modulaire.

il faut toujours avoir à l’esprit , qu’il ne faut pas «modulariser pour


modulariser» et qu’un appel par PERFORM (ou par CALL) provoque à chaque
fois l’exécution d’instructions de branchement puis de débranchement
ainsi que des sauvegardes d’informations (contexte) et qu’en abuser rend
le programme moins performant.

=> Il ne faut (éventuellement) avoir recours à la modularisation que si


NB ➳ l’ensemble d’instructions considéré doit être appelé au moins 2 fois.
(ce qui se détecte dès l’analyse du problème si on travaille avec une
méthode )

[NB : lors de l’écriture d’un programme , il arrive qu’on ait à écrire certaines lignes
plusieurs fois à différents endroits sans que cela ne soit prévisible au moment de la
conception du pseudo-code de l’algorithme : on peut en faire un module appelé par PERFORM ,
mais cela n’a pour seul avantage que d’alléger la saisie de l’utilisateur au détriment de
la performance.]

 inversement , certaines méthodes de développement peuvent nous amené à «modulariser» (souvent à


outrance ) les programmes : par exemple la programmation par l’arbre programmatique ou la méthode
PSP programmation sans panne.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 40


ESAT-DI [LRE] page 11-41
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

Dans le cas de cette dernière , la méthodologie est excellente pour analyser et décomposer
le problème en une suite de petits algorithmes simples mais au niveau du développement on
obtient peut obtenir (çà dépend du programmeur ) une multitude d’appels (par PERFORM) plus
inutiles les uns que les autres et d’autant plus inefficaces qu’ils ne contiennent qu’un
petit nombre d’instructions ne constituant même pas un algorithme.

EXEMPLE :

on trouve des inepties telles que celle-ci , au lieu de faire :

.
. .
PERFORM OUVERTURE .
. OPEN INPUT FCLIENT
. .
. .
STOP RUN. .
OUVERTURE. STOP RUN.
OPEN INPUT FCLIENT.

❸ pour faciliter la maintenance et la lisibilité :

C’est l’argument majeur avancé par les inconditionnels souvent à tort car , bien que les
modules soient plus petits et plus simples à étudier , en trop grand nombre (comme dans l’exemple
«hyper-gigan-modularisé» ci-dessus) ils engendrent rapidement l’effet inverse.

❹ conclusion :

Les appels de sous-programmes par PERFORM ne concernent que la modularisation


statique (à l’intérieur d’un programme et non d’une application ) , je pense qu’il
faut en «user» à bon escient uniquement :

lorsque la séquence d’instructions doit être réutilisée plusieurs fois

ou lorsqu’elle gère une action particulière [ => vraiment spécifique et


formant une entité logique ] qui placée dans le programme maître augmenterait
considérablement la complexité de celui-ci.

Ce cours sur le PERFORM a été placé dans ce chapître car ce verbe permet d’appeler
des sous-programmes ( ou petit morceaux plutôt appelés « modules » ) néanmoins ,
il est surtout utilisé ( à 95% ) pour traduire les boucles lorsqu’on travaille
« en structuré ».
Ce paragraphe D traite les deux aspects du verbe PERFORM.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 41


ESAT-DI [LRE] page 11-42
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

D2 LES FORMATS

D21 le format n° 1 [ utilisé surtout pour l’appel de sous-programme ]

[ ]
THRU
PERFORM [
nom-procédure-1
THROUGH
]
nom-procédure-2

[ bloc d’instructions [ END-PERFORM ] ]

 C’est le perform de base qui sert à appeler un sous-programme ou module qu’on range généralement
après STOP RUN.

 Si nom-procédure-1 n’est pas mentionné,le bloc d’instructions et le END-PERFORM sont obligatoires


=> il s’agit du PERFORM « en ligne »

 Si le bloc d’instructions est placé « hors ligne » après la fin du programme (stop RUN) , le
retour au programme appelant se fait lorsqu’on passe sur le dernier point de la dernière
instruction du dernier paragraphe de la dernière section composant le bloc considéré.
[NB : on peut également utiliser le verbe EXIT - cf format dans les pages suivantes de D2 ]

 Avec ce format , la procédure concernée n’est exécutée qu’une fois.

 THRU et THROUGH sont équivalents.

 les modules procédure-1 et procédure-2 sont totalement indépendants (d’ailleurs l’un peut appeler
l’autre par PERFORM) mais ils doivent être consécutifs et dans cet ordre.

 cas des appels imbriqués :


En ce qui concerne les appels de sous-programmes , si on travaille avec méthode , on rencontre
rarement (sinon jamais ) de modules imbriqués les uns dans les autres ou qui se chevauchent ; si
vous aboutissez à cette situation , revoyez votre analyse.

Néanmoins , le compilateur prend en compte cette possibilité en imposant les règles suivantes :

Si un bloc d’instructions appelé par PERFORM contient lui-même un PERFORM d’une autre
séquence , celle-ci doit être soit totalement incluse dans le premier bloc , soit totalement
exclue.

Un PERFORM exécuté au cours d’un autre PERFORM ne doit pas passer par l’instruction de fin
ou de l’EXIT du premier PERFORM.

De même , plusieurs PERFORM actifs simultanément ne doivent pas avoir de point de sortie
commun.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 42


ESAT-DI [LRE] page 11-43
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

[CF les schémas page suivante ]

debut.

perform prime

stop run.
suite.
correct
perform tva thru ecriture

.
prime.

.
impot.

.
tva.

.
ecriture.

debut.
perform suite thru impot

stop run.
suite.

perform prime thru ecriture


.
prime.
incorrect
[-CF exemple .
impot. D32]

.
tva.

.
ecriture.

debut.
perform suite thru fin correct
stop run.
suite.

perform prime thru fin


.
prime.

.
impot.

.
fin.
EXIT.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 43


ESAT-DI [LRE] page 11-44
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

debut.

perform suite thru ecriture

stop run.
suite.

perform prime thru impot


correct
.
prime.

.
impot.

.
tva.

.
ecriture.

debut.

perform suite thru impot

go to ecriture.
suite.

car passe par la fin du premier


une fois qu’il a été exécuté
.
prime.

.
impot.

.
tva.

.
ecriture.

perform prime thru tva


stop run. correct
mais => «programmation
sauvage»

debut.
perform suite thru impot incorrect
stop run.
suite.

perform prime thru impot


.
prime.

.
impot.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 44


ESAT-DI [LRE] page 11-45
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

 Exemple simple d’utilisation du PERFORM n° 1

IDENTIFICATION DIVISION.
PROGRAM-ID. format1.
AUTHOR. IC LAFARGUE.

DATA DIVISION.
working-storage section.
77 wtaxe pic 99 value 10.
77 wprime pic 99 value 50.
77 wbuffer pic 999.

1 wzone-a-lire.
3 taxe-et-prime-1 pic 999 value 100.
3 taxe-et-prime-2 pic 999 value 200.
3 prime-et-taxe-1 pic 999 value 300.
3 taxe-seule-1 pic 999 value 500.
3 prime-seule-1 pic 999 value 600.
1 wzone-pour-manipuler redefines wzone-a-lire.
3 a pic 999.
3 b pic 999.
3 c pic 999.
3 d pic 999.
3 e pic 999.

PROCEDURE DIVISION.
debut.

move a to wbuffer
perform taxe thru prime
move wbuffer to a

move b to wbuffer
perform taxe
perform prime équivalent à
move wbuffer to b

move c to wbuffer
perform prime
perform taxe
move wbuffer to c

move d to wbuffer
perform taxe
move wbuffer to d

move e to wbuffer
perform prime
move wbuffer to e

display "a= " a ",b=" b ",c=" c ",d=" d ",e=" e


stop run.

taxe.
compute wbuffer = wbuffer - wbuffer * wtaxe / 100.

prime.
compute wbuffer = wbuffer + wbuffer * wprime / 100.

résultat du programme ==>


a=135,b=270,c=405,d=450,e=900

[ CF l’exemple complet D31 ]

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 45


ESAT-DI [LRE] page 11-46
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

D22 le format n° 2 [relativement peu utilisé]

[ ]
THRU
PERFORM [ {
nom-procédure-1
THROUGH
} ]
nom-procédure-2

identificateur-1
TIMES
entier-1

[ bloc d’instructions [ END-PERFORM ] ]

 Les règles générales énoncées pour la format n° 1 sont valables pour tous les autres formats.

C’est le même format que le n° 1 avec la possibilité de répéter la séquence d’instructions un


 nombre fixé (identificateur-1 ou entier-1) de fois.

Il est relativement peu utilisé car , si on travaille « en structuré » (ou autre méthode) ,
 toutes les boucles se traduisent par des PERFORM UNTIL.
Un problème traité avec un « PERFORM ...n TIMES .. » (format n° 2) peut toujours être résolu avec
un « PERFORM ...UNTIL... » .

 identificateur-1 doit être une zone numérique [pic 9( )].

 Pendant l’exécution du PERFORM , une modification de identificateur-1 n’a aucun effet.

 Par contre si avant l’exécution , identificateur-1 est à zéro , les n boucles ne sont pas
réalisées : le programme passe directement au END-PERFORM ou à l’instruction qui suit le PERFORM.

 Exemple simple d’utilisation du PERFORM n° 2 : « dessin de losanges »

résultat sujet de l’exercice


-------------------
à obtenir

Dans une table de taille fixée (par exemple de 19 lignes de 19 caractères)


initialisée avec des « - » on veut dessiner des losanges.

Le dessin d’un losange doit être géré par un sous-programme auquel on


« passe » la hauteur du losange (en nbre de lignes) et le caractère de
remplissage.

Le résultat à obtenir ci-joint vous montre le dessin d’un premier losange


d’une hauteur de 17 lignes remplies avec des « * ». sur lequel on a
redessiné un deuxième losange d’une hauteur de 11 lignes remplies avec des
espaces.

Tous les dessins se font en mémoire ; on n’édite la table qu’à la fin du


programme.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 46


ESAT-DI [LRE] page 11-47
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

---------*---------
--------***--------
-------*****-------
------*** ***------
-----*** ***-----
----*** ***----
---*** ***---
--*** ***--
-*** ***-
--*** ***--
---*** ***---
----*** ***----
-----*** ***-----
------*** ***------
-------*****-------
--------***--------
---------*---------
-------------------

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 47


ESAT-DI [LRE] page 11-48
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

IDENTIFICATION DIVISION.
PROGRAM-ID. LOSANGE.
AUTHOR. IC LAFARGUE.

DATA DIVISION.
WORKING-STORAGE SECTION.

77 L PIC S99 VALUE 0.


77 C PIC S99 VALUE 0.
77 LMAX PIC S99 VALUE 19.
77 CMAX PIC S99 VALUE 19.
77 WQ PIC 99 VALUE 0.
77 I PIC S99 VALUE 0.
77 J PIC S99 VALUE 0.
77 H PIC S99 VALUE 0.
77 N PIC S99 VALUE 0.
77 K PIC S99 VALUE 0.
77 R PIC X VALUE "*".
77 centre pic 99 value 0.

1 WTABLE VALUE ALL "-".


3 WLI OCCURS 19.
5 WCO PIC X OCCURS 19.

PROCEDURE DIVISION.
DEBUT.

MOVE 17 TO H choix hauteur = 17 (toujours impair et maxi = 19)


MOVE "*" TO R et caractère de remplissage = « * »
PERFORM DESSIN + appel du SP pour dessiner le premier losange

MOVE 11 TO H choix hauteur = 11


MOVE " " TO R et caractère de remplissage = « »
PERFORM DESSIN + appel du SP pour dessiner le deuxième losange

MOVE 0 TO L
PERFORM 19 times affichage des
ADD 1 TO L 19 lignes du tableau
DISPLAY WLI(L)
END-PERFORM

STOP RUN.

DESSIN.
COMPUTE CENTRE = CMAX / 2
ADD 1 TO CENTRE
COMPUTE WQ = H / 2
ADD 1 TO WQ
MOVE 0 TO N
* INITIALISATION EVEC LES COORDONNEES DU SOMMET
COMPUTE L = (LMAX - H) / 2
* NOMBRE DE LIGNES A TRAITER = (H/2) + 1
PERFORM WQ TIMES
ADD 1 TON L
MOVE 0 TO C
PERFORM N TIMES
ADD 1 TO C
COMPUTE I = CENTRE - 1 + c
COMPUTE J = centre + 1 - c
COMPUTE K = lmax + 1 - l
MOVE R TO WCO(L I) WCO(L J) WCO(K I) WCO(K J)
END-PERFORM
END-PERFORM.

Pour montrer les diverses possibilités du PERFORM (n° 2 ) on vous a donné à la page suivante le même
exemple avec un nombre de modules excessif et inutile.

Une autre version de cet exercice vous est donnée avec le format n° 3 ; en effet , l’analyse de ce
problème ayant été réalisée « en structuré » , la solution « naturelle » ne comporte en fait que des
« faire tant que ....fin faire » qui se traduisent en cobol par le PERFORM UNTIL .

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 48


ESAT-DI [LRE] page 11-49
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

PROCEDURE DIVISION.
DEBUT.

MOVE 17 TO H
MOVE "*" TO R
PERFORM DESSIN

MOVE 11 TO H
MOVE " " TO R
PERFORM DESSIN

perform affichage

STOP RUN.

DESSIN.
COMPUTE CENTRE = CMAX / 2
ADD 1 TO CENTRE
COMPUTE WQ = H / 2
ADD 1 TO WQ
MOVE 0 TO N
COMPUTE L = (LMAX - H) / 2
PERFORM ligne-losange WQ TIMES.

affichage.
MOVE 0 TO L
PERFORM affiche-ligne 19 times.

affiche-ligne.
ADD 1 TO L
DISPLAY WLI(L).

ligne-losange.
ADD 1 TO N L
MOVE 0 TO C
PERFORM colonne-losange N TIMES.

colonne-losange.
ADD 1 TO C
COMPUTE I = CENTRE - 1 + c
COMPUTE J = centre + 1 - c
COMPUTE K = lmax + 1 - l
MOVE R TO WCO(L I) WCO(L J) WCO(K I) WCO(K J).

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 49


ESAT-DI [LRE] page 11-50
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

D23 le format n° 3 [ surtout utilisé pour traduire les


boucles ]

[ ]
THRU
PERFORM [ {
nom-procédure-1
THROUGH
} ]
nom-procédure-2

BEFORE
WITH TEST
AFTER

UNTIL condition-1

[ bloc d’instructions [ END-PERFORM ] ]


 Les règles générales énoncées pour la format n° 1 sont valables pour tous les autres formats.

C’est le format le plus utilisé en cobol puisqu’il permet de traduire les boucles : « faire tant
 que ...fin-faire » et « répéter ....jusqu’à ».
Mais le fait qu’il contienne comme les autres «nom-procédure-1 THRU nom-procédure-2 » lui permet
également d’appliquer les boucles sur des sous-programmes (hors ligne).

 Principe fondamental du ‘FAIRE TANT QUE condition FIN-FAIRE »

si la condition est vraie

bloc
d’instructions

tant que la condition est vraie

 Le « faire tant que .. » commence par tester la condition avant de rentrer dans la boucle :

- si elle est fausse dès le départ , on n’entre pas dans la structure répétitive.

- si elle est vraie , on exécute le bloc d’instruction tant qu’elle reste vraie.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 50


ESAT-DI [LRE] page 11-51
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

 Il est utilisé pour traiter les boucles de 0 à n fois.

Le fait que pour un « faire tant que .. » il y ait un test avant correspond à l’option implicite
du format n° 3 : WITH TEST BEFORE.

La difficulté en cobol vient du fait que toutes les boucles se traduisent par UNTIL qui signifie
➱ jusqu’à.

si on veut traduire le pseudo-code suivant en cobol : faire tant que condition-1


bloc
d’instructions
fin-faire


il faut écrire faire jusqu’à non-condition-1
bloc
d’instructions
fin-faire

EXEMPLE :

si on veut écrire faire tant que (a < 12 ou k = 3) et i > j

la condition inverse donne faire jusqu’à (a >= 12 et k ¹ 3) ou i <= j

en cobol la traduction sera PERFORM UNTIL (a >= 12 and k not = 3) or i <= j

 Principe fondamental du «REPETER.....JUSQU’A condition»

bloc
d’instructions

tant que la condition est fausse

la condition
est vraie
=> on continue

 le bloc d’instructions est exécuté au moins une fois , puis on recommence jusqu’à ce que la
condition soit vraie (ou tant qu’elle est fausse )


il est utilisé pour les boucles de 1 à n fois

 Pour écrire le « répéter....jusqu’à » en cobol , il faut mettre l’option WITH TEST AFTER

 NB : En général , le « répéter ..jusqu’à » et « le faire tant que ... » ne sont pas équivalents :
avec le premier , on fait un test de moins ce qui dans un algorithme comprenant des millions de
boucles peut s’avérer beaucoup plus performant.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 51


ESAT-DI [LRE] page 11-52
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

Néanmoins , il ne s’applique que si on est sûr d’avoir à exécuter au moins une fois la séquence
d’instructions ; ce qui ne représente pas la majorité des cas.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 52


ESAT-DI [LRE] page 11-53
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

 Exemple simple d’utilisation du PERFORM n° 3 : « exercice sur les nombres premiers»

sujet de l’exercice

On dispose de 10 nombres (quelconques) [ entiers sur 3 caractères => pic 9(3) ] placés dans un
tableau à 10 postes.

On souhaite afficher les nombres premiers qui encadrent chacun de ces 10 éléments.

exemple à obtenir

à partir du tableau (ou table , vecteur,..) contenant les nombres :

154 , 015 , 839 , 000 , 456 , 912 , 317 , 999 , 329 , 452

on a obtenu les résultats suivants :

nb premier nb étudié nb premier

résultat obtenu
avec le programme
fourni page 51

logique du problème et pseudo-code

Cet exercice a été choisi pour illustrer le PERFORM n° 3 car il contient à la fois des «faire tant que..»
et des « répéter...jusqu’à » ; en effet , étant donné qu’on a 10 nombres à traiter , on est sûr qu’il y en
a au moins 1 => on va pouvoir utiliser cette dernière structure.
[nb : comme le nombre d’éléments est fixé à 10 , on aurait pu également utiliser le PERFORM n TIMES ]

principe de la solution

Avec l’algorithme d’Erastosthène , on commence par remplir la table qui donne tous les nombres premiers
inférieurs à 999.
On obtient donc un tableau dont les indices des postes contenant la valeur « 1 » sont premiers.

1 1 1 0 1 0 1 0 0 0 1 0 1 0
1 2 3 4 5 6 7 8 9 10 11 12 13 14

3 , 5 , 7 , 11 ...sont premiers

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 53


ESAT-DI [LRE] page 11-54
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

Ensuite , on se positionne dans ce tableau sur la case correspondant au nombre étudié et on cherche vers
la droite et vers la gauche le premier poste contenant « 1 ».

par exemple si on travaille sur le nombre 10 :

1 1 1 0 1 0 1 0 0 0 1 0 1 0
1 2 3 4 5 6 7 8 9 10 11 12 13 14

on trouve que celui-ci est encadré par les nombres premiers 7 et 11

pseudo-code (très général) du programme


principal

début programme
appel du sous-programme qui remplit la table d’Erastosthène (avec l’algorithme du même nom)
affichage de la ligne en-tête
n ← 0
répeter
n = n + 1
mise à l’état initial des zones d’affichage
mise en zone de sortie du nombre étudié
au cas ou
le nombre étudié = zéro
mise en zone de sortie de « limite inf »
appeler le sous-programme de balayage à droite
le nombre étudié = 999
mise en zone de sortie de « limite sup »
appeler le sous-programme de balayage à gauche
le nombre étudié = autre valeur
si le nombre étudié est premier
alors
mise en zone de sortie « =nb premier »
fin-si
appeler le sous-programme de balayage à gauche
appeler le sous-programme de balayage à droite
fin au cas ou
affichage de la ligne pour le nombre traité
jusqu’à ce qu’il n’y ait plus de nombres à traiter
arrêt du programme

pseudo-code de l’algorithme d’Erastosthène

début programme reation-table-eratosthene.


k ¬ 0
initialiser le tableau avec des « 1 »
répéter
k = k + 1
si le poste du tableau(k) = 1
calculer i = (k ** 2) - k
faire tant que i < 1000
i = i + k
poste du tableau(i) ← 0
fin faire
fin-si
jusqu’à ce que k >= 1000
arrêt du programme.

pseudo-code des sous-programmes : balayage à gauche et à


droite

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 54


ESAT-DI [LRE] page 11-55
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

début balayage-a-droite.
calculer k = nombre étudié + 1
faire tant que k < 999 et poste (k) = 0
k = k + 1
fin-faire
mise en zone de sortie de k (à droite)
arrêt du programme

début balayage-a-gauche.
calculer k = nombre étudié - 1
faire tant que k > 1 et poste (k) = 0
k = k - 1
fin-faire
mise en zone de sortie de k (à gauche)
arrêt du programme

programmation en cobol

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 55


ESAT-DI [LRE] page 11-56
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

les sous-programmes
appelés
par PERFORM

creation-table-eratosthene.
perform with test after until k >= 1000
add 1 to k
if wt(k) = 1
compute i = (k ** 2) - k
perform until i >= 1000
add k to i
move 0 to wt(i)
end-perform
end-if
end-perform.

balayage-a-gauche.
compute k = wnb(n) - 1
perform until k <= 1 or wt(k) not = zero
subtract 1 from k
end-perform
move k to ngauche.

balayage-a-droite.
compute k = wnb(n) + 1
perform until k >= 999 or wt(k) not = 0
add 1 to k
end-perform
move k to ndroite.

IDENTIFICATION DIVISION.
PROGRAM-ID. repfaire.
author. IC LAFARGUE.
ENVIRONMENT DIVISION.
data division.
WORKING-STORAGE SECTION.
1 wtable-des-10-nombres
value "154 015 839 852 456 912 317 117 329 452 00".
3 occurs 10.
5 wnb pic 999.
5 pic x.
3 n pic 99.

1 wtable-eratosthene value all "1".


3 wt pic 9 occurs 2000.
1 windices.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 56


ESAT-DI [LRE] page 11-57
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

5 k pic 9999 value 1.


5 i pic 9999 value 0.
1 wligne-resultat.
3 wnum pic zz value zero.
3 pic x value space.
3 wgauche value "nb premier".
5 pic x(7).
5 ngauche pic zz9.
3 pic xxx value " <".
3 wmilieu value "nb étudié".
5 nmilieu pic zz9.
5 pic x(8).
3 pic xxx value " <".
3 wdroite value "nb premier".
5 ndroite pic zz9.
5 pic x(7).
procedure division.
debut.
perform creation-table-eratosthene
display wligne-resultat
display " "
perform with test after until n >= 10
add 1 to n
move n to wnum
move spaces to wdroite wgauche wmilieu
move wnb(n) to nmilieu
evaluate wnb(n)
when zero
move "limite inf" to wgauche
perform balayage-a-droite
when 999
move "limite sup" to wdroite
perform balayage-a-gauche
when other
move wnb(n) to i
if wt(i) = 1
then
move "=premier" to wmilieu(4:8)
end-if
perform balayage-a-droite
perform balayage-a-gauche
end-evaluate
display wligne-resultat
end-perform
stop run.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 57


ESAT-DI [LRE] page 11-58
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

 Autre exemple : exercice « dessin de losanges » déjà traité page 44 (cf sujet)
Tous les algorithmes peuvent se résoudre uniquement avec des « faire tant que ... » (ou des « répéter
..jusqu’à .. ») : cet exemple montre l’exercice de la page 44 où on a remplacé les répétitions
« PERFORM ..n TIMES » par « PERFORM .. UNTIL ... ».

000500 IDENTIFICATION DIVISION.


000600 PROGRAM-ID. LOSANGE.
000700 AUTHOR. IC LAFARGUE.
000800 DATA DIVISION.
000900 WORKING-STORAGE SECTION.
001000 77 L PIC S99 VALUE 0.
001100 77 C PIC S99 VALUE 0.
001200 77 LMAX PIC S99 VALUE 19.
001300 77 CMAX PIC S99 VALUE 19.
001400 77 WQ PIC 99 VALUE 0.
001500 77 I PIC S99 VALUE 0.
001600 77 J PIC S99 VALUE 0.
001700 77 H PIC S99 VALUE 0.
001800 77 N PIC S99 VALUE 0.
001900 77 K PIC S99 VALUE 0.
002000 77 R PIC X VALUE "*".
002100 77 centre pic 99 value 0.
002200 1 WTABLE VALUE ALL "-".
002300 3 WLI OCCURS 19.
002400 5 WCO PIC X OCCURS 19.
002500 PROCEDURE DIVISION.
002600 DEBUT.
002700*
002800* LOSANGE 1 : CHOIX HAUTEUR H ET REMPLISSAGE R
002900* ----------------------------------------------
003000* (H TOUJOURS IMPAIR,H MAXI = 19)
003100 MOVE 17 TO H
003200 MOVE "*" TO R
003300 PERFORM DESSIN
003400*
003500* LOSANGE 2 : CHOIX H ET R
003600* -------------------------
003700 MOVE 11 TO H
003800 MOVE " " TO R
003900 PERFORM DESSIN
004000*
004100* AFFICHAGE
004200* ---------
004300 MOVE 0 TO L
004400 PERFORM UNTIL L >= 19
004500 ADD 1 TO L
004600 DISPLAY WLI(L)
004700 END-PERFORM
004800 STOP RUN.
004900*
005000 DESSIN.
005100 COMPUTE CENTRE = CMAX / 2
005200 ADD 1 TO CENTRE
005300 COMPUTE WQ = H / 2
005400 ADD 1 TO WQ
005500 MOVE 0 TO N
005600* INITIALISATION EVEC LES COORDONNEES DU SOMMET
005700 COMPUTE L = (LMAX - H) / 2
005800* NOMBRE DE LIGNES A TRAITER = (H/2) + 1
005900 PERFORM UNTIL N >= WQ
006000 ADD 1 TO N L
006100 MOVE 0 TO C
006200 PERFORM UNTIL C >= N
006300 ADD 1 TO C
006400 COMPUTE I = CENTRE - 1 + c
006500 COMPUTE J = centre + 1 - c
006600 COMPUTE K = lmax + 1 - l
006700 MOVE R TO WCO(L I) WCO(L J) WCO(K I) WCO(K J)
006800 END-PERFORM
006900 END-PERFORM.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 58


ESAT-DI [LRE] page 11-59
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

D24 le format n° 4

[ ]
THRU
PERFORM [ {
nom-procédure-1
THROUGH
} ]
nom-procédure-2

BEFORE
WITH TEST
AFTER

identificateur-2 identificateur-3
VARYING FROM nom-index-2
nom-index-1 littéral-1

identificateur-4
BY UNTIL condition-1
littéral-2

identificateur-5 identificateur-6
AFTER FROM nom-index-4
nom-index-3 littéral-3
. . .

identificateur-7
BY UNTIL condition-2
littéral-4

[ bloc d’instructions [ END-PERFORM ] ]


 Les règles générales énoncées pour le format n° 1 sont valables pour tous les autres formats.

 C’est le format le plus compliqué et le moins utilisé : il permet toutefois de gérer avec sa
clause VARYING les boucles « POUR variable VARIANT DE I à J AVEC UN PAS DE k FAIRE ....FIN
FAIRE ».
Les autres options (les phrases AFTER) permettent de prendre en compte avec un seul et même verbe
PERFORM plusieurs boucles complexes imbriquées qu’on peut traiter dans la majorité des cas avec
de simples « faire tant que .. ».

 Ce format permet d’exécuter des procédures itératives dont le nombre dépend du nombre de phrases
AFTER mentionnées :

❶ si aucune phrase AFTER n’apparaît dans l’écriture du PERFORM , il n’y a qu’une boucle « POUR
variable ....FIN-FAIRE ».

❷ si on a une phrase AFTER , il y aura une boucle (interne) supplémentaire (2 en tout).

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 59


ESAT-DI [LRE] page 11-60
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

❸ si on a n phrases AFTER => il y aura exécution de n+1 procédures itératives.

[les cas ❶ et ❷ sont étudiés de manière détaillée ; le n° ❸ n’étant que la généralisation des
2 premiers ]

NB : Le nombre de phrases AFTER autorisées varie selon les différents compilateurs : (limite
absolue = 15 ; 2 en cobol-74, 6 en cobol-ANS85 ; 6 dans d’autres cas ,..=> à vérifier avec
votre logiciel )

 • règles générales de syntaxe.

Tous les identificateurs (1 à n) sont des nom-données qui représentent une zone élémentaire
numérique décrite en data division.

Chaque littéral doit être numérique.

Si un nom d’index (CF rappel sur les index ci-dessous) est utilisé dans les phrases VARYING ou
AFTER :
le nom-donnée utilisé avec FROM et BY doit être entier.
le littéral utilisé avec FROM doit être un entier positif.
le littéral utilisé avec BY doit être un entier non nul.

Si un nom d’index est utilisé avec FROM :


le nom-donnée utilisé avec VARYING ou AFTER doit être entier.
le nom-donnée ou le littéral utilisé avec BY doit être entier.

Le littéral de la phrase BY ne doit pas être nul.

Non-donnée-4 et 7 ne doivent pas être nuls.

Si un nom d’index est spécifié avec VARYING ou AFTER et qu’un nom-donnée est spécifié avec le
FROM associé , le nom-donnée doit être positif.

 rappel sur l’utilisation des index.

un index est essentiellement utilisé avec des tables ou organisations similaires : le contenu
d’un index contient toujours un nombre d’occurrences ou l’équivalent d’un indice.

un index est géré par le système (description ,incrémentation,..) , seule l’initialisation est à
la charge du programmeur qui utilise pour ce faire le verbe SET ( nom-index TO valeur ).

En principe on ne décrit pas les index en data division ; c’est toutefois possible (si on veut
conserver et manipuler la valeur d’un index ) avec la clause USAGE IS INDEX.
La taille de la zone déclarée dépend du système sur lequel on travaille ainsi que de la clause
PICTURE associée.(sur PC en cobol m-soft V4.5 , un index déclaré en USAGE IS INDEX est en
réalité une zone binaire sur un mot de 4 bytes).

En indexation directe , les index se manipulent comme des indices ; c’est-à-dire placés entre
parenthèses derrière la donnée concernée.
En indexation relative , le nom d’index est suivi par « + » ou « - » suivi d’un littéral entier
ex : zone(ind + 3)

Un index ne peut être modifié que par les verbes : SET , SEARCH , et PERFORM ..VARYING.

Toutes les règles concernant l’indiçage s’appliquent à l’indexation.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 60


ESAT-DI [LRE] page 11-61
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

règles générales concernant l’utilisation du format n° 4

signification des mots du format :

identificateur-2 identificateur-3 identificateur-4


VARYING FROM nom-index-2 BY UNTIL
condition-1
nom-index-1 littéral-1 littéral-2

   
POUR variable variant DE i avec k jusqu’à j
un pas de


identificateur-5

identificateur-6

identificateur-7

AFTER FROM nom-index-4 BY UNTIL
condition-2
nom-index-3 littéral-3 littéral-4

NB:

les règles que nous allons voir sont valables aussi bien pour les nom-données associés à
VARYING,FROM,AFTER que pour les index.

Si nom-d’index-1 est spécifié , la valeur d’identificateur-3 , nom-d’index-2 ou littéral-1 doit


correspondre à l’indice d’un élément dans la table associée à index-1 au début de l’exécution du
PERFORM.

Si nom-d’index-3 est spécifié , la valeur d’identificateur-6 , nom-d’index-4 ou littéral-3 doit


correspondre à l’indice d’un élément dans la table associée à index-3 au début de l’exécution du
PERFORM.

les incrémentations consécutives de index-1 ou index-3 ne doivent pas permettre de dépasser le


nombre d’éléménts des tables associées (sauf en fin de PERFORM , l’index peut contenir l’indice
maximum + 1 ou le minimum - 1)

Avec la présence des clauses AFTER , il est obligatoire de ranger le bloc d’instructions hors ligne.

cas n° ❶ : PERFORM avec une seule variable (=> une seule boucle) avec WITH TEST
BEFORE

principe :

identificateur-2 ⇐ identificateur-3 ou littéral-1


faire tant que non-condition-1
exécution du bloc d’instruction (en ou hors ligne)
identificateur-2 = identificateur-2 + identificateur-4 ou littéral-2
fin-faire

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 61


ESAT-DI [LRE] page 11-62
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

Comme le montre le pseudo-code ci-dessus ou le schéma suivant , un PERFORM VARYING à une seule variable
est équivalent à un « FAIRE TANT QUE ... » dans lequel on gère nous même l’incrémentation (ou
décrémentation) , l’initialisation ainsi que le pas.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 62


ESAT-DI [LRE] page 11-63
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

initialisation de
identificateur-2
avec identificateur-3 ou ..

si non-condition-1 est vraie

bloc
d’instructions

incémentation
ou décrémentation (avec la valeur BY)

tant que non-condition-1 est vraie

exemples simples de PERFORM VARYING à une


variable

IDENTIFICATION DIVISION.
PROGRAM-ID. vary1.
author. IC LAFARGUE.
ENVIRONMENT DIVISION.
data division.
WORKING-STORAGE SECTION.
77 v pic s9(6) value 0.
77 r pic s9(6) value 0.
77 i pic s9(6) value 0.
77 j pic s9(6) value 2.
77 n pic s9(6) value 5.
77 index-3 usage is index.
1 wtableau value "001002004008016032064128256512".
3 wnbin occurs 10 indexed by index-1 index-2 pic 999.

r=000055 (verif = 10/2 * 11)

v=000000 , v=000002 , v=000004 , v=000006


v=000008

factorielle(000005)=000120

i=000504 =8+16+32+64+256

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 63


ESAT-DI [LRE] page 11-64
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

debut.

perform varying v from 10 by -1 until v < 1


compute r = r + v
end-perform
display "r= " r "(vérif = 10/2 * 11)"

perform varying v from i by j until v > 8


display "v=" v
end-perform

move 1 to i
perform factorielle-n
varying v from 1 by 1 until v > n
display "factorielle(" n ")=" i

move 0 to i
set index-2 to 5
perform calcul varying index-1
from index-2
by 1
until index-1 > 10
display "i=" i "=8+16+32+64+128+256)".

stop run.
factorielle-n.
compute i = i * v.

calcul.
compute i = i + wnbin(index-1 - 1).

cas n° ❷ : PERFORM avec deux variables (=> deux boucles) : 1 VARYING+1 AFTER + avec WITH TEST
BEFORE

principe :

identificateur-2 ⇐ identificateur-3 ou littéral-1


identificateur-5 ⇐ identificateur-6 ou littéral-3
faire tant que non-condition-1
 voir
α remarques
page suivante
faire tant que non condition-2
exécution du bloc d’instruction (hors ligne obligatoire avec AFTER)
identificateur-5 = identificateur-5 + identificateur-7 ou littéral-4
fin-faire

identificateur-5 ⇐ identificateur-6 ou littéral-3


identificateur-2 = identificateur-2 + identificateur-4 ou littéral-2 β
fin-faire

Comme le montre le pseudo-code ci-dessus ou le schéma suivant , un PERFORM VARYING avec une phrase AFTER
(=> perform à 2 variables ) est équivalent à deux « FAIRE TANT QUE ... » imbriqués dans lequels on gère
nous même les incrémentations (ou décrémentations) , les initialisations et les pas.

INIT-1= initialisation de identificateur-2 avec identificateur--3 ou (FROM)..


INIT-2= initialisation de identificateur-5 avec identificateur--6 ou (FROM)..

si non-condition-1 est vraie (ou si condition-1 est fausse)

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 64


ESAT-DI [LRE] page 11-65
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

si non-condition-2 est vraie

exécution
du bloc d’instructions
(hors ligne)

incrémenter identificateur-5
avec sa valeur BY

tant que non


condition-2 vraie

réinitialisation
INIT-2
+ incrémentation de
identificateur-2 (valeur BY)

tant que non-condition-1 est vraie

vers l’instruction
qui suit le
perform

remarques sur la structure du PERFORM VARYING + AFTER : α βet


Contrairement à deux « faire tant que ... » indépendants , on ne peut écrire aucune instruction entre les
2 boucles (en α ou β ) : tout se passe comme si on avait :

faire tant que non condition-1 ou non-condition-2


si condition-2 vrai
identificateur-5 ⇐mut identificateur-6 ou littéral-3
fin-si
exécution du bloc d’instruction (hors ligne obligatoire avec AFTER)
identificateur-2 = identificateur-2 + identificateur-4 ou littéral-2 ou ..
identificateur-5 = identificateur-5 + identificateur-7 ou littéral-4 ou ..
fin-faire

exemples de PERFORM VARYING à deux variables => avec une phrase AFTER

exercice sur les nombres premiers :

On veut afficher dans un tableau de l lignes et c colonnes tous les


nombres premiers qui se terminent par le chiffre q et qui ne
dépassent pas une valeur limite z.

Les informations sont rangées par ligne (on remplit d’abord la ligne
1 puis la n° 2 ,..)

Même s’il n’y a pas assez de nombres pour remplir le tableau , on


affiche toujours les l lignes et les c colonnes (=> même les vides).

Au bout de chaque ligne et de chaque colonne , on affiche le total


des nombres.

remarques concernant les 2 exemples présentés

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 65


ESAT-DI [LRE] page 11-66
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

[les 2 exemples présentés ci-dessous concernent tous les nombres premiers < 230 se terminant par « 7 » à
ranger dans un tableau de 5 lignes et 3 colonnes.]

Le premier exemple donne la solution naturelle obtenue en structuré : on a donc 2 « faire tant que... »
imbriqués que l’on a traduit par des PERFORM VARYING simplement pour éviter de gèrer les indices des
lignes et des colonnes.

Le deuxième qui a pour but d’illustrer le VARYING + AFTER est plus complexe : il reprend le même problème
mais les deux boucles classiques ont été remplacées par le PERFORM VARYING+AFTER .
L’utilisation de format a imposé d’autres changements qui ont accru la difficulté et le manque de
lisibilité du programme :

aussi déconseille-je son utilisation dont je ne vois pas vraiment l’utilité d’autant qu’il ne
correspond à aucune structure de base de la programmation structurée.

résultat à obtenir (et obtenu par les 2

1 2 3 total
1 7 17 37 61
2 47 67 97 211
3 107 127 137 371
4 157 167 197 521
5 227 227
total=> 545 378 468

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 66


ESAT-DI [LRE] page 11-67
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

IDENTIFICATION DIVISION.
PROGRAM-ID. vary2. creation-table-eratosthene.
author. IC LAFARGUE. compute racine = 1 + limite ** 0.5
data division. perform with test after until k >= racine
WORKING-STORAGE SECTION. add 1 to k
77 l pic 99 value 0. if wt(k) = 1
77 c pic 99 value 0. compute i = (k ** 2) - k
77 n pic s9(5) value 0. perform until i >= limite
77 limite pic 9(6) value 230. add k to i
77 vlimite pic 9(6) value 0. move 0 to wt(i)
77 wtotlig pic 9(6) value 0. end-perform
77 wpremier pic 9 value 0. end-if
88 premier value 1. end-perform.
1 termix.
3 termi pic 9 value 7. calcul-vraie-limite.
1 wtable-total-colonnes value zero. move limite to vlimite
3 wtotcol occurs 3 pic 9(6). perform until vlimite(6:1) = termix
1 wtable-eratosthene value all "1". subtract 1 from vlimite
3 wt pic 9 occurs 12000. end-perform.
1 windices-eratoshene.
5 k pic 999999 value 1.
5 i pic 999999 value 0. (on a choisi une limite de 230 , la vraie limite
5 racine pic 999999 value 0. est le premier nombre <= qui se termine par 7
==> 227
1 wligne-resultat value spaces. On prend cette valeur car on incrémente par )
3 wcol1. dizaines dans la boucle centrale)
5 wnum pic zz.
5 pic x(5).
3 occurs 3.
5 pic xx.
5 wnb pic z(6).
3 pic xx.
3 wcol5.
5 pic x.
5 wtotligz pic z(6).
5 pic xx.
procedure division.
debut.
perform calcul-vraie-limite
perform creation-table-eratosthene CF principe page 49
perform 3 times
add 1 to n
move n to wnb(n) affichage de la ligne en-tête
end-perform
move "total" to wcol5(3:7)
display wligne-resultat
move -3 to n
perform varying l from 1 by 1 until l > 5
move zero to wtotlig
move spaces to wligne-resultat
move l to wnum
perform varying c from 1 by 1 until c > 3
move 0 to wpremier
perform until premier or n >= vlimite CAS n° 1 : avec
add 10 to n
if wt(n) = 1
then deux PERFORM VARYING simples
set premier to true
move n to wnb(c)
add n to wtotlig wtotcol(c)
end-if
end-perform
end-perform
move wtotlig to wtotligz
display wligne-resultat
end-perform
move spaces to wligne-resultat
move "total=>" to wcol1
move 0 to i
perform 3 times
add 1 to i affichage de la ligne « total » colonnes
move wtotcol(i) to wnb(i)
end-perform
display wligne-resultat
stop run.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 67


ESAT-DI [LRE] page 11-68
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

affichage-resultats.
move 0 to n
perform 3 times
add 1 to n affichage
move n to wnb(n) ligne
end-perform en-tête
move "total" to wcol5(3:7)
display wligne-resultat
move 0 to l
perform until l >= 5
add 1 to l
move l to wnum vidage
move 0 to c table
move spaces to wligne-resultat résultats
perform until c >= 3
add 1 to c
move co(l c) to wnb(c)
end-perform
move co(l 4) to wtotligz
display wligne-resultat
end-perform
move spaces to wligne-resultat
move "total=>" to wcol1
move 0 to i affichage
perform 3 times lignes
add 1 to i totaux
move co(6 i) to wnb(i)
end-perform
display wligne-resultat.

IDENTIFICATION DIVISION.
PROGRAM-ID. vary3.
author. IC LAFARGUE.
data division.
WORKING-STORAGE SECTION.
77 l pic 99 value 0.
77 c pic 99 value 0.
77 n pic s9(5) value -3.
77 limite pic 9(6) value 230.
77 vlimite pic 9(6) value 0.
77 wpremier pic 9 value 0.
88 premier value 1.
1 termix.
3 termi pic 9 value 7.
1 wtable-eratosthene value all "1".
3 wt pic 9 occurs 12000.
1 windices-eratoshene.
5 k pic 999999 value 1.
5 i pic 999999 value 0.
5 racine pic 999999 value 0.
1 wtabl-resultat value zero.
3 lig occurs 6.
5 co pic 9(5) occurs 4.

1 wligne-resultat value spaces.


3 wcol1.
5 wnum pic zz.
5 pic x(5).
3 occurs 3.
5 pic xx.
5 wnb pic z(6).
3 pic xx.
3 wcol5.
5 pic x.
5 wtotligz pic z(6).
5 pic xx.
procedure division.
debut.
perform calcul-vraie-limite
perform creation-table-eratosthene
perform traitement-tableau
with test before
CAS n° 2 : avec

PERFORM VARYING +
Cours de COBOL-85 Les sous-programmes
AFTER Chapître 11 - page 68
ESAT-DI [LRE] page 11-69
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

varying l from 1 by 1 until l > 5


after c from 1 by 1 until c > 3
perform affichage-resultats
stop run.

creation-table-eratosthene.
compute racine = 1 + limite ** 0.5
perform with test after until k >= racine
add 1 to k
if wt(k) = 1
compute i = (k ** 2) - k
perform until i >= limite
add k to i
move 0 to wt(i)
end-perform
end-if
end-perform.

calcul-vraie-limite.
move limite to vlimite
perform until vlimite(6:1) = termix (ou bien faire vlimite = vlimite - 10
subtract 1 from vlimite vlimite(6:1) ¬ termix)
end-perform.

traitement-tableau.
move 0 to wpremier
perform until premier or n >= vlimite
add 10 to n
if wt(n) = 1
then
set premier to true
move n to co(l c)
add n to co( l 4) co(6 c)
end-if
end-perform.

D25 les formats du verbe EXIT

EXIT format n° ❶

EXIT PERFORM [ ]
CYCLE format n° ❷

EXIT { PARAGRAPHE
} format n° ❸
SECTION

 Le EXIT sert à fournir une fin commune à plusieurs procédures.


Il permet également de sortir d’un PERFORM en ligne , d’un paragraphe ou d’une section.

 LE FORMAT N° 1

avec certains compilateurs , le verbe EXIT doit être la seule instruction du paragraphe.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 69


ESAT-DI [LRE] page 11-70
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

un verbe EXIT placé n’importe où dans du code n’a aucun effet :l’exécution du programme se
poursuit à l’instruction suivante.

 LE FORMAT N° 2

Utilisé uniquement pour quitter un perform en ligne.

Sans la clause CYCLE , le contrôle est passé à un « CONTINUE » implicite placé


immédiatement à la suite du END-PERFORM considéré : c’est à dire que le programme se
poursuit à partir de l’instruction qui suit le PERFORM.

Avec « CYCLE » , le contrôle est passé à un CONTINUE implicite placé immédiatement avant le
END-PERFORM considéré.

rappel sur l’instruction CONTINUE :

L’instruction CONTINUE permet de ne pas exécuter une séquence dans certaines


circonstances et de continuer le programme.

Elle est surtout utilisée avec des instructions comprenant une condition ou un test
d’erreur :

exemple : ADD 25 to zone


on size error
CONTINUE
END-ADD

 LE FORMAT N° 3

Avec l’option PARAGRAPHE :

l’EXIT doit être contenu dans un paragraphe.

Le contrôle est passé à un CONTINUE implicite précédant :

- immédiatement le paragraphe suivant ou le début de la section suivante.

- ou immédiatement avant la fin du source s’il n’y a pas de paragraphe suivant ou de

section suivante.

Avec l’option SECTION :

l’EXIT doit être contenu dans une section.

Le contrôle est passé à un CONTINUE implicite précédant :

- le début de la section suivante

- ou immédiatement avant la fin du source s’il n’y a pas de section entre cet EXIT et

la fin du programme.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 70


ESAT-DI [LRE] page 11-71
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 71


ESAT-DI [LRE] page 11-72
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

D3 LES EXEMPLES d’utilisation du verbe PERFORM

D31 exemple complet utilisant les formats 1


et 3

sujet du problème à résoudre


Les Sous-Officiers (dont l’article dans le fichier en entrée est correct => matricule : en X ; l’indice :
numérique) nés entre 1952 et 1956 ou en 1958 ou en 1960 et de 1963 à 1970 ont droit à une prime calculée
de la façon suivante :
S’ils appartiennent à l’Arme «TRS » ou « INF » :
2% du salaire brut s’ils ont une note < 12 [ salaire brut = valeur point * indice / 12 ]
4% si 12 >= leur note < 14
6% si 14 >= leur note < 16
8% si leur note est >= 16

S’ils appartiennent à une autre arme


ils auront les mêmes taux divisés par 2 sauf s’ils sont « Sergent-Chef » (SCH) : dans ce cas les
taux sont multipliés par 2.

Les Personnels Civils (non Officiers et non Sous-Officiers) auront tous 2% sauf s’ils sont inspecteurs
(grade = « ins » ou « is » ou « ipe » ou « ic ») ; dans ce cas la prime sera de 10%.

Les Officiers ne touchent pas de prime

Pour les personnes (ayant droit à une prime) dont l’article est incorrect , il faudra inscrire «anomalie»
à la place de la valeur de la prime sur l’état imprimé.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 72


ESAT-DI [LRE] page 11-73
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

F ic hie r de s P e rs o nne ls
o rg anis atio n s é qu e n tie lle
No n T r i é
c : \p e r so n .t x t
A A M M JJ co d e
m a tric u le nom p ré n o m g ra d e a r m e d a te n a iss . h iér a c h iq u e in d ice n o te
x(6) x (2 0 ) x(20) xxx x (3 ) x (6 ) 99 9(6) 99 v99

1 => G é n ér a l
P S / C BL 85
2 => C o lo n el
3 => L ie u te n a n t-C o lo n el
4 => C om m an d ant
5 => etc ..
c : \p r im e s .t x t
é ta t d e s p r im e s 97 Page 1

NOM PRENOM P R IM E
D ugen ou M arcel 1 8 2 5 ,2 3 F
P in o u fle t H ecto r 1 9 2 8 ,5 2 F
D a n lep a n E m il e 2 1 8 3 ,6 0 F
G radou chon M a r c e l lo a n o m a l ie F
B e r li n o u Jean 8 1 6 2 ,1 8 F
J o b a r tin i M ic h e l a n o m a l ie F
K a v itc h k y n o v sk y J u les 3 7 0 0 ,5 1 F
G o u y o u -G a z o u E m i li e n 2 7 1 2 ,2 3 F
. . .
. . .
. . .

( u n s a u t d e p a g e a v e c ré é c ri tu r e d u titre
e t d e l' e n - tê te d è s q u 'o n a é c ri t 3 0 li g n es "d é t ail " )

début programme principal.


ouvrir les fichiers.
lecture du fichier en entrée (nom : FPERS ; zone entrée : ZE)
récupérer la date système + MZM de l’année en ligne titre
cpage(ZM)  0 pseudo-code
faire tant que non FF(FENTREE ) structuré
Si la personne lue (ZE) est Sous-Officier
alors
si l’année de naissance(ZE) est dans la liste pour une prime
alors
si l’article n’est pas correct (matricule ou indice erroné)
alors
MZS « anomalie »
appel du module écriture
sinon
si son arme (ZE) est « trs » ou « inf »
alors
MZM (pour être utilisé par le module choix-taux) des taux (ZM)
(t10(ZM)  t1(ZM) ; t20(ZM)  t2(ZM) ; t30(ZM)  t3(ZM) ; t40(ZM)  t4(ZM)
sinon
si son grade (ZE) = « SCH »
alors
t10(ZM) = t1(ZM) * 2 calcul des nouveaux taux
t20(ZM) = t2(ZM) * 2
t30(ZM) = t3(ZM) * 2
t40(ZM) = t4(ZM) * 2
sinon
t10(ZM) = t1(ZM) / 2 calcul des nouveaux taux
t20(ZM) = t2(ZM) / 2
t30(ZM) = t3(ZM) / 2
t40(ZM) = t4(ZM) / 2
fin si
fin si

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 73


ESAT-DI [LRE] page 11-74
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

appel du module choix-taux


appel du module calcul prime
appel du module écriture
fin si
fin si
sinon
si elle n’est pas Officier
alors
si l’article n’est pas correct (matricule ou indice erroné)
alors
MZS « anomalie »
appel du module écriture
sinon
si elle est inspecteur
alors
taux-choisi(ZM)  10
sinon
taux-choisi(ZM)  2
fin si
appel du module calcul-prime
appel du module écriture
fin si
fin si
fin si
lecture du fichier en entrée FPERS
fin faire
fermer les fichiers
arrêt du programme.

début module choix-taux.


au cas ou
la note(ZE) < 12
taux-choisi(ZM)  t10(ZM)
la note(ZE) >=12 et < 14
taux-choisi(ZM)  t20(ZM)
la note(ZE) >= 14 et < 16
taux-choisi(ZM)  t30(ZM)
la note(ZE) >= 16
taux-choisi(ZM)  t40(ZM)
fin au cas ou.

début module calcul-prime.


calculer prime(ZM) = taux-choisi(ZM) * valeur-point(ZM) *
indice(ZE) / 1200
MZS de prime(ZM).

début module écriture.


MZS nom,prénom(ZE)
si compteur de lignes >= 30
alors
cpage(ZM)  +1
écriture du titre avec saut de page
écriture de l’en-tête
compteur de lignes(ZM)  0
fin si
compteur de lignes(ZM)  +1
écriture de la ligne détail.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 74


ESAT-DI [LRE] page 11-75
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

IDENTIFICATION DIVISION. programme


PROGRAM-ID. prime. cobol
ENVIRONMENT DIVISION.
input-output section.
file-control.
select fimpri assign to "c:\primes.txt".
select fpers assign to "c:\person.txt".

data division.
file section.

fd fimpri linage is 60.


1 sligne pic x(80).

fd fpers.
1 enreg.
3 ematri pic x(6).
3 enom pic x(20).
3 eprenom pic x(20).
3 egrade pic xxx.
88 sof value "sgt" "sch" "adj" "adc" "maj" "mdc" "mdl".
88 ofi value "asp" "ltn" "cne" "cdt" "cbn" "cba" "lcl" "col".
88 bon-civil value "ins" "is " "ic " "ipe".
3 earme pic xxx.
88 trs-inf value "trs" "inf".
3 ea pic 99.
88 bon-annee value 58 thru 60 62 65 70 thru 73.
3 pic x(6).
3 eind pic 9(6).
3 emoy pic 99v99.

WORKING-STORAGE SECTION.
77 wctf pic 9 value 0.
88 ff value 1.

77 wpoint pic 9999v99 value 344.56.


77 wtaux pic 999v99 value 0.

77 w1 pic 999v99 value 0.


77 w2 pic 999v99 value 0.
77 w3 pic 999v99 value 0.
77 w4 pic 999v99 value 0.
77 wprime pic 9(6)v99 value 0.
77 wt1 pic 999v99 value 2.
77 wt2 pic 999v99 value 4.
77 wt3 pic 999v99 value 6.
77 wt4 pic 999v99 value 8.
77 wctl pic 99 value 30.

1 wdetail.
3 snom pic x(21).
3 sprenom pic x(30).
3 sprimex.
5 sprime9 pic z(5)9v,99.
3 pic x value «F».

1 wtitre value « état des primes ».


3 pic x(17).
3 wa pic x(40).
3 pic x(6) value « page ».
3 wpage pic 99.

1 wdate pic x(6).

1 wentete pic x(46)


value « NOM PRENOM PRIME».

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 75


ESAT-DI [LRE] page 11-76
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

procedure division.
debut.
open input fpers output fimpri
accept wdate from date
move wdate(1:2) to wa
move 0 to wpage
read fpers
at end
set ff to true
display "fichier entrée vide"
end-read
perform until ff
if sof
then
if bon-annee
then
if ematri alphabetic or ematri numeric
or eind not numeric
then
move "anomalie" to sprimex
perform ecriture
else
if trs-inf
then
move wt1 to w1
move wt2 to w2
move wt3 to w3
move wt4 to w4

else
if egrade = "sch"
then
compute w1 = wt1 * 2
compute w2 = wt2 * 2
compute w3 = wt3 * 2
compute w4 = wt4 * 2
else
compute w1 = wt1 / 2
compute w2 = wt2 / 2
compute w3 = wt3 / 2
compute w4 = wt4 / 2
end-if
end-if
perform choix-taux thru ecriture
end-if
end-if
else
if not ofi
then
if ematri alphabetic or ematri numeric
or eind not numeric
then
move "anomalie" to sprimex
perform ecriture
else
if bon-civil
then
move 10 to wtaux
else
move 2 to wtaux
end-if
perform calcul-prime thru
ecriture
end-if
end-if
end-if
read fpers
at end
set ff to true
end-read
end-perform
close fimpri fpers
stop run.

choix-taux.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 76


ESAT-DI [LRE] page 11-77
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

evaluate emoy < 12 also emoy < 14 also emoy < 16


when true also any also any
move w1 to wtaux
when false also true also any
move w2 to wtaux
when false also false also true
move w3 to wtaux
when false also false also false
move w4 to wtaux
end-evaluate.

calcul-prime.
compute wprime = wtaux * wpoint *
eind / 1200
move wprime to sprime9.

ecriture.
move enom to snom
move eprenom to sprenom
if wctl >= 30
then
add 1 to wa
write sligne from wtitre
after page
write sligne from wentete
after 4
move spaces to sligne
write sligne after 5
move 0 to wctl
end-if
add 1 to wctl
write sligne from wdetail.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 77


ESAT-DI [LRE] page 11-78
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

D32 exemple sur les PERFORM qui se chevauchent (cas incorrect page 42)

Le but du programme était de vérifier un cas cité comme « incorrect » à la page 42 ; en fait , il
démontre un fonctionnement normal (sans erreur) néanmoins , il vaut mieux éviter ce type d’appels qui
échappent à toute méthodologie et qui peuvent toujours donner dans certaines configurations des résultats
incorrects ou indéfinis (tous les cas n’ont pas été testés dans cet exemple).

IDENTIFICATION DIVISION.
PROGRAM-ID. chevauch.
data division.
WORKING-STORAGE SECTION.
77 i pic 9(4) value 3.
77 j pic 9(4) value 2.
77 r pic 9(4) value 0.
procedure division.
debut.
display "-01- deb début i=" i " et j =" j
perform suite thru impot
display "-02- fin début i=" i " et j =" j
stop run.
suite.
display "-03- deb suite i=" i " et j =" j
compute i = i ** 2 * 3
add i to j
perform prime thru ecriture
display "-04- fin suite i=" i " et j =" j.
prime.
display "-05- deb prime i=" i " et j =" j
subtract 4 from i j
display "-06- fin prime i=" i " et j =" j.

impot.
display "-07- deb impot i=" i " et j =" j.
compute j = j + 0.1 * j.
add 5 to i.
display "-08- fin impot i=" i " et j =" j.
tva.
display "-09- deb tva i=" i " et j =" j.
divide j by 2 giving i remainder r
multiply 3 by i.
display "-10- fin tva i=" i " et j =" j.
ecriture.
display "-11- deb écriture i=" i " et j =" j
add -3 to i j
display "-12 fin écriture i=" i " et j =" j.

résultats obtenus

i j
-01- deb début" 3 2
-03- deb suite 3 2
-05- deb prime 27 29
-06- fin prime 23 25
-07- deb impot 23 25
-08- deb impot 28 27
-09- deb tva 28 27
-10- fin tva 39 27
-11- deb ecriture 36 24
-12- fin ecriture 36 24
-04- fin suite 36 24
-05- deb prime 36 24
-06- deb prime 32 20
-07- deb impot 32 20
-08- deb impot 37 22
-02- fin début 37 22

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 78


ESAT-DI [LRE] page 11-79
Cours CBL-85 CHAPÎTRE 11 Les sous-programmes [ call et perform ]
ANS85/m-soft 11/10/2009 -
11/10/2009

D33 autres exemples

IDENTIFICATION DIVISION.
PROGRAM-ID. boucles.
author. IC LAFARGUE.
data division.
WORKING-STORAGE SECTION.
77 i pic 999 value 0.
77 j pic 999 value 0.
77 k pic 999 value 0.
77 w1 pic 9(6) value 0.
77 n1 pic 999 value 10.
77 w2 pic 9(6) value 0.
77 w3 pic 9(6) value 1.
77 w4 pic 9(6) value 0.
1 wtab4 value "000200040008001600320064012802560512102420484096".
3 wt4 pic 9999 occurs 12 indexed by index1 index2.
1 windex1 pic 9(6) value 0.
procedure division.
debut.

move 1 to w2 le « POUR i=1 jusqu’à n avec un pas de 1 » ...


perform n1 times
add 1 to i
compute w2 = w2 + 2 ** i
end-perform
display "w2=" w2 w2=2047 [=(2**11)-1]

move 0 to i j le « répéter ...jusqu’à » avec mauvaise initialisation..


perform with test after until j - i <= 0
add 1 to i w3
end-perform
display "w3=" w3 il passe quand même une fois => w3=2

move 0 to i le « répéter ...jusqu’à » avec bonne initialisation..


move 10 to j
move 1 to w3
perform with test after until j - i <= 0
add 1 to i
compute w3 = w3 * 2
end-perform
display "w3=" w3 w3=1024

perform with test before varying index1 from 3 by 2 le « faire tant que .... » avec VARYING
until w4 >= 1000
compute w4 = w4 + wt4(index1)
set windex1 to index1 visualisation du contenu de l’index
display "windex1=" windex1 =3,5,7,11
end-perform
display "w4=" w4 w4=2728 [=8+32+128+512+2048]

move 0 to w4 le «pour i de 1 à n...» VARYING


perform with test before varying i from 5 by 3 until i >= 20
compute w4 = w4 + i
end-perform
display "w4=" w4 w4=55 [=5+8+11+14+17]

stop run.

Cours de COBOL-85 Les sous-programmes Chapître 11 - page 79