Discussion :

[mutsum1]

Bonjour,

Mieux vaut tard que jamais, je me mets au Free RPG.
C'est assez puissant coté code, mais je le trouve un peu plus brouillon dès qu'il s'agit d'accéder à des fichiers. Enfin, je persévère...

Mon problème est que traditionnellement, en RPG3, j'utilise beaucoup les syntaxes DO *HIVAL ... ITER / LEAVE ... ENDDO

Et je n'arrive pas à reproduire ce modèle en Free RPG.

Est-ce possible ?

[jump400]

Bonjour,

Le DO n'existe pas en "Free". Officiellement l'équivalent est FOR.
Mais dans ton cas il faut contourner le problème.
Il y a bien sûr plein de possibilités, en voici une :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
/FREE             
   *InLR = *on;    
   Dou 1 = 2;    
       // ...
      Iter;   
      // ...  
      Leave;  
      // ...      
   Enddo;          
/END-FREE

[mutsum1]

Effectivement, ça marche aussi.

Je vais appliquer cette méthode, avec un petit commentaire en fin de ligne pour décrire le pourquoi.

Merci pour ta réponse.

[Mercure]

Hmm... AMHA il vaudrait mieux employer une méthode moins risquée comme de savoir le nombre d'itérations à faire ou tester l'EOF.

[mutsum1]

non on ne peut pas tester l'eof sans faire une lecture préalable du fichier.
Du coup on se retrouve avec 2 lectures, une avant et une dans la boucle.
Ca complique tout et c'est vite illisible.

J'ai remplacé mon DO *Hival par un DOU *inLR, et ça marche pareil.

[Mercure]

non on ne peut pas tester l'eof sans faire une lecture préalable du fichier.
Du coup on se retrouve avec 2 lectures, une avant et une dans la boucle.
Ca complique tout et c'est vite illisible.

Qu'est-ce que ça complique ? Et en quoi est-ce illisible ?
Et qu'est-que le mode libre (/free) a de plus puissant que les autre modes d'écriture du RPG IV ?

Avec un DoU, tu places l'indicateur LR sur le READx puis tu le testes pour sortir de la boucle, et çà, c'est ce qu'on faisait en GAP III. Toi qui veux passer au free, en utilisant l'indicateur LR comme tu le fais, c'est du codage ancien peu professionnel qui sent son GAP III à des kilomètres.

En RPG IV, on utilise les fonctions intégrées comme %EOF(). On réserve les indicateurs pour la gestion des écrans car on ne peut malheureusement pas y couper, mais on leur affecte une équivalence telle que "ClearSfl" et "DspSflCtl" pour tester la valeur des indicateurs 40 et 41 par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
D IndDsPtr        S               *   Inz( %Addr( *IN )) 
                                                         
D IndDs           DS            99    Based( IndDsPtr )  
D  ...
D  ClearSfl              40      40n                      
D  DspSflCtl             41      41n   

  /free
   ...
   DspSflCtl = *On;
   ...

C'est quand même plus lisible et plus parlant que *In40 et *In41, pas vrai ?

Et je ne trouve pas qu'avec un DoW et deux lectures, ce soit particulièrement compliqué, c'est tout ce qu'il y a de plus standard :

Code :

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

1
2
3
4
5
6
7
8
 /free
   Setll clefs format;
   Reade clefs format;
   doW %EOF
      // Traitement du record lu ici
      ...
      Reade clefs format;
    enddo;

Qu'y-a-t-il de compliqué là-dedans ?

Cependant, je ne me battrais certainement pas si un programmeur préfère employer un DoU et tester 2 fois l'EOF dans la boucle au lieu d'utiliser DoW et 2 lectures. Ces 2 méthodes se valent.

Mais qu'on soit bien clair. Là où je ne suis plus d'accord avec toi, c'est sur l'emploi des indicateurs et notamment de l'indicateur LR tel que tu l'emploies.

Je sens que je vais me faire incendier avec ces remarques mais je persiste et signe quand même pour essayer d'éviter que se répande une façon de travailler qui, AMHA (et à celui de beaucoup d'autres d'ailleurs), relève du passé et ne devrait plus être employée de nos jours.

[mutsum1]

Je n'est rien contre tout ça.
Je programme généralement en RPG3 ou RPG4, que je trouve forts pratiques.

Je ne passe au /free que pour modifier un programme écrit par quelqu'un d'autre dans lequel je veux m'insérer. Ca me permet aussi de me former à ce langage. Après quelques jours, je ne le trouve ni mieux ni moins bien, c'est juste une autre façon d'écrire. Ce n'est pas lui qui me fera abandonner mes colonnages.


Pour ce qui est des méthodes de lecture d'un fichier : dans ton exemple qui est par ailleurs tout à fait standard (et que tout le monde apprend en formation RPG), tu as un read avant la boucle et un read en fin de boucle, après un traitement qui parfois peut-être long. Du coup, tu as 2 lignes qui ont exactement la même fonction, et qui sont séparées parfois de plusieurs dizaines de lignes.
C'est à mon avis fort peu optimisé, autant à lire (tu parcours le traitement et tu tombes sur un read qui semble hors de propos puisque normalement réalisé avant, et qui plus est le test sur ce dernier read est fait x lignes AVANT) et à modifier (2 lignes à changer si modification à venir). Cerise sur le gateau : impossible de faire un ITER dans ton traitement pour passer à l'enregistrement suivant, donc obligation d'utiliser des IF en cascades, et à nouveau alourdissement de l'écriture.

Je préfère nettement l'écriture suivante, que j'écris exprès en /free :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
setll Key Fichier;
Do *HIVAL

Read Fichier;
if (%eof); 
  leave;
endif;

... Sélection éventuelle : si enregistrement à ne pas prendre -> ITER

... Traitement ...

enddo;

Un seul read, et situé avant le traitement qu'il conditionne. Utilisation possible de l'instruction ITER n'importe où dans la boucle pour passer à l'enregistrement suivant. Donc une lecture nettement plus claire car on scinde bien les processus et on alourdi pas le code avec des IF.

C'est clair et optimisé, tout ce que j'aime.

Mon problème, d'où l'objet de ce message, est que ce Do *HIVAL n'existe plus en Free RPG. Ce que je trouve bien dommage.
Je le remplace donc par DOU *inLR, qui est certes peu académique, mais qui vaut encore mieux que tous les inconvénients amenés par ton exemple.

Tu n'aimes pas ce test incongru, je le conçois. Mais trouve moi autre chose que ta double lecture alors, car elle trop pénalisante à mes yeux.

[Mercure]

Tu peux ne pas aimer les DoW avec 2 lectures, c'est ton droit et également, je trouve que ta boucle DoU avec %EOF() est très bien