Discussion :

[aloula]

Bonsoir, voici une petite logique simplifiée de ce que j'aimerais faire dans un programmes cobol:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
indice <- 1
x <- 0
TANQUE non EOF fichier
            TANQUE compteur<cptmax
                        SI sexe(du fichier)=tableau(indice)
                            x <- x+1
                            indice <- indice+1
                        FINSI
            FINTANQUE
FINTANQUE

Donc, dans le PROCEDURE DIVISION j'aurais (en simplifié):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
Principal.
       PERFORM Lecture.
       PERFORM Traitement UNTIL EOF=1.
       PERFORM Fin.

Lecture.
//ce n'est pas grave, on fait ici une première lecture.

Traitement.
//ici je ne voi vraiment pas comment m'y prendre. On doit donc pour  chaque element du fichier aller verifier si SEXE est égale a un élément du  tableau. Donc je dois comparer chaque élément du fichier a TOUS les  elements du tableau.

Merci de m'aider

[aloula]

J'ai une idée mais je ne sais pas si c'est permi par Cobol, mettre un perform dans le perform.. c'est à dire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Principal.
       PERFORM Lecture.
       PERFORM Traitement UNTIL EOF=1.
       PERFORM Fin.

Lecture.
//ce n'est pas grave, on fait ici une première lecture.

Traitement.
       PERFORM le deuxieme tanque

Le deuxieme tanque.
       //ici

[Christianchristian]

J'ai une idée mais je ne sais pas si c'est permi par Cobol, mettre un perform dans le perform.. c'est à dire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Principal.
       PERFORM Lecture.
       PERFORM Traitement UNTIL EOF=1.
       PERFORM Fin.

Lecture.
//ce n'est pas grave, on fait ici une première lecture.

Traitement.
       PERFORM le deuxieme tanque

Le deuxieme tanque.
       //ici

Bonsoir,

Oui c'est autorisé, si les séquences d'ordres de chaque sous-prog ne se chevauchent pas.
Mais un petit conseil : Pour davantage de sécurité et de lisibilité programme toujours tes PERFORM avec l'option THRU pour la partie "appel" et pour le sous-programme utilise systématiquement l'ordre (inopérant) EXIT qui doit être le seul ordre COBOL qui suit immédiatement le second nom de paragraphe-: exemple :
..............................
.............................
PERFORM NOM_PARAGRAPHE THRU FIN-NOM_PARAGRAPHE.
.............................
.......
STOP RUN.
NOM_PARAGRAPHE.
..........................
ordres COBOL appelés par perform
.....................
FIN-NOM_PARAGRAPHE.
EXIT.
FIN-PGM. par exemple.

Sit tu respectes cette règle simple tu ne connaîtras pas les déboires enoncés quelques lignes plus bas, car elle permet de s''affranchir d'une erreur de logique assez difficille à localiser et qui peut survenir lors :
- du développement initial du programme (ce n'est pas le cas le plus fréquent),
- ET SURTOUT lors des modifications, apportées ultérieurement dans le cadre des maintenances, par toi-même ou une autre personne, aux séquences d'ordres appelées par PERFORM sans l'option THRU .
Cette erreur consiste à ajouter, pour les besoins d'une maintenance 1 ou plusieurs paragraphes (un seul suffit) dans une séquence d'ordres appelés par PERFORM sans l'option THRU. C'est vite fait surtout lorsque cette séquence est importante.
Dans ce cas l'exécution de la séquence appelée par un ordre PERFORM SANS l'option THRU (qui signifie en l'occurence JUSQU'A inclus) stoppera à la rencontre du 1er nom de paragraphe. Dans mon scénario c'est la présence du 1er paragraphe ajouté qui arrêtera l'exécution, ce qui n'est pas souhaitable.
MAUVAIS exemple : PERFORM SANS L'OPTION THRU
. .............................
.............................
PERFORM NOM_PARAGRAPHE.
.............................
.......
STOP RUN.
NOM_PARAGRAPHE.
..........................
ordres appelés par PERFORM NOM_PARAGRAPHE
.....................
NEW-PARAG.
Ajout d'un nom de paragraphe ==> nouvelle portée d'exécution de l'ordre PERFORM comprise entre NOM_PARAGRAPHE et NEW_PARAG non inclus.
........ Les instructions suivant NEW_PARAG jusqu'à AUTRE-NOM_PARAGRAPHE ne seront jamais exécutées par l'appel de l'ordre PERFORM simple sans l'option THRU. C'est la conséquence de l'ajout de NEW-PARAG.
.....................
........
AUTRE-NOM_PARAGRAPHE. (fin de la portée initiale d'éxécution de l'ordre PERFORM Avant l'ajout de NEW-PARAG)

FIN-PGM. par exemple.

En toute logique si la programmation est bien "structurée" on ne doit jamais rencontrer le cas de figure : Ajout de paragaphe(s) dans une séquence d'ordres appelée par un PERFROM .
Il ne doit théoriquement pas exister de boucle faisant intervenir l'ordre GO TO, et tout ajout de code doit normalement donner naissance à un nouveau sous-programme ou à un PERFORM in-line. Mais il arrive que l'on ait à reprendre en maintenance d'anciens pgm pas forcément structurés.

NB. A propos du GO TO, lorsqu'il est utilisé dans une séquence d'instructions appelée par un PERFORM, sa portée (illustrée par un branchement vers un nom de paragraphe, en vérité une adresse) ne doit jamais se situer EN DEHORS de la limite repésentée par l'ensemble des instructions du sous-programme (ensemble repésenté par les ordres et le(s) nom(s) de paragraphe(s)). Dans le cas contraire l'adresse de retour est perdue ==> ça donne des résultats d'exécution étonnants surtout quand on sait que l'exécution du progamme peut, après bien des péripéties, "retrouver" incidemment son adresse de retour.
Alors, suivant l'expression consacrée : "Attention aux GO TO qui sortent des PERFORM".

_____________________________

Tout ceci, pour enfin répondre à ta question par un exemple :

PROCEDURE DIVISION.
..............................
.............................
............................. (autres PERFORM éventuellement)
PERFORM NOM_PARAGRAPHE1 THRU FIN-NOM_PARAGRAPHE1.
............................. (autres PERFORM éventuellement)
.......
STOP RUN.
NOM_PARAGRAPHE1.
..........................
ordres COBOL appelées par le 1er perform
PERFORM NOM_PARAGRAPHE2 THRU FIN-NOM_PARAGRAPHE2.
......................
AUTRE-PARAG1.
.....................
....................
FIN-NOM_PARAGRAPHE1.
EXIT.

NOM_PARAGRAPHE2.
..........................
ordres COBOL appelés par le second perform
.....................
AUTRE-PARAG2.
.....................
....................
FIN-NOM_PARAGRAPHE2.
EXIT.

FIN-PGM. par exemple.

Commentaire : La "portée" de chaque ordre PERFORM est inconditionnellement bornée par NOM_PARAGRAPHEx et FIN-NOM_PARAGRAPHEx.
Il peut donc coexister d'autres noms de paragraphes (ex :AUTRE-PARAGx) entre ces 2 bornes. Que ceux-ci aient été programmés intentionnellement ou accidentellement importe peu.


Cordialement,