Cas particulier des boucles DO et CO

Le code spécifique écrit dans Pacbase peut contenir des boucles de types DO et CO. Ces boucles ne peuvent pas être insérées comme les autres types de condition (DW et IT par exemple) avec l'assistant de création de sous-fonctions de Rational Programming Patterns. En revanche, elles sont migrées et vous devez savoir comment les maintenir.

La boucle DO

Cette boucle peut être indiquée sur une sous-fonction uniquement. Elle permet d'exécuter un traitement de façon répétitive entre deux bornes en fonction d’un pas positif ou négatif. Les bornes sont obligatoires alors que le pas est facultatif. Un indice représente le code de la sous-fonction dans les zones de travail.

Cette boucle n'est pas reprise dans Rational Programming Patterns mais elle est migrée. Elle est représentée par la sous-fonction Fffss contenant le code généré de la boucle et par l’indice associé JffssR dans les zones de travail. Elle est repérable dans l'éditeur COBOL PDP et l'éditeur COBOL de Macro grâce à l'indication *.DO à la fin de la ligne de commentaire qui précède la sous-fonction. Le code généré est affiché sur les lignes suivantes :
Exemple : Une boucle DO est indiquée dans la sous-fonction 48BD de la façon suivante dans Pacbase :
A SS NLG OPE OPERANDE                      NVTY CONDITION
  BD     N   VERIFICATION COMPATIBILITE    15DO 1 ITA00M
  BD 100 M   ZERO T-TA00-00540 (J48BDR)

Lorsque le Programme intégrant cette sous-fonction DO est généré et migré dans Rational Programming Patterns, les lignes suivantes s'affichent dans l'éditeur COBOL :

 *N48BD.    NOTE *VERIFICATION COMPATIBILITE         *.DO
  F48BD.
      MOVE        1                        TO J48BDR
                               GO TO     F48BD-B.
  F48BD-A.
      ADD         1                        TO J48BDR.
  F48BD-B.
      IF          J48BDR                   >  ITA00M 
                               GO TO     F48BD-FN.
      MOVE        ZERO TO T-TA00-00540 (J48BDR). 
  F48BD-900. GO TO F48BD-A. 
  F48BD-FN. EXIT.
Dans les zones de travail, l'indice associé est généré sous la zone 01 INDICES sur la ligne suivante :
Exemple :
05        J48BDR PICTURE S9(4) VALUE   ZERO.
Vous pouvez effectuer les mises à jour suivantes dans le code généré de la sous-fonction :
  • Modifier la borne inférieure. Cette borne est affichée sur la première ligne de traitement de la sous-fonction.
    Exemple :
      MOVE        1                        TO J48BDR
    Dans cet exemple, 1 est la borne inférieure.
  • Modifier la borne supérieure. Cette borne est affichée avant la ligne de branchement à la fin de la sous-fonction.
    Exemple :
      IF          J48BDR                   >  ITA00M 
    Dans cet exemple, ITA00M est la borne supérieure.
  • Modifier le pas, s'il a été indiqué. Le pas est affiché sur la ligne commençant par ADD ou SUBTRACT.
    Exemple :
      ADD         1                        TO J48BDR.
    Dans cet exemple, 1 est le pas. Il est précédé de ADD car il a une valeur positive.
  • Déplacer la sous-fonction.
    Vous pouvez la couper et la coller à un autre emplacement dans le code. Vous devez alors remplacer toutes les références à l’ancien code sous-fonction par le nouveau code sous-fonction. Vous devez aussi créer le nouvel indice JffssR dans les zones de travail et supprimer l’ancien à l’emplacement suivant :
     01   INDICES  COMPUTATIONAL  SYNC.

    Vous pouvez effectuer ces actions avec l'assistant de recherche et remplacement. Vous recherchez l'ancien code sous-fonction et le remplacez par le nouveau code.

  • Créer une autre boucle DO.

    Vous pouvez copier et coller une sous-fonction DO existante. Cependant, pour indiquer qu'un traitement doit être effectué de façon répétitive, il est conseillé d'insérer le fragment Insertion d'une boucle. Ce fragment est disponible depuis la vue Fragments, catégorie Fragments RPP. Ce fragment insère un ordre COBOL PERFORM.

La boucle CO

Cette boucle peut être indiquée sur une sous-fonction uniquement. Elle permet d'exécuter des traitements exclusifs les uns des autres, suivant les valeurs possibles d’une variable. Seul le nom de la variable est indiqué au niveau de la sous-fonction CO. Les traitements sont décrits à la suite dans des sous-fonctions de type IT de niveau inférieur, avec comme condition la valeur de la variable correspondant à chaque traitement.
Remarque : On parle d’une sous-fonction de niveau inférieur si son nombre niveau est plus grand.
La condition d'exécution CO a été reprise dans Rational Programming Patterns sous forme d'un micro-pattern CO, dans les Macros uniquement. Les raisons suivantes expliquent cette restriction :
  • La boucle CO ne génère rien à l'endroit où elle est appelée mais insère la variable indiquée dans le conditionnement sur toutes les sous-fonctions de niveau immédiatement inférieur.
  • Les sous-fonctions contenant les conditions d'application peuvent se trouver dans des Macros différentes.
Exemple : Dans Pacbase, une structure CO est indiquée dans la sous-fonction 26BB d'une Macro. Elle est suivie par des sous-fonctions IT dont seule la première est indiquée dans l'exemple suivant. Cette sous-fonction de type IT sera exécutée si la variable $1-COVIL a la valeur 75001 :
A SS NLG OPE OPERANDE                      NVTY CONDITION
  BB     N   TEST CODE VILLE               10CO $1-COVIL
- -- --- --- ----------------------------- ---- ---------
  CB     N   CAS 75001                     15IT "75001"
  CB 100 M   "PARIS 01" $1-LIVIL
Cette condition d'exécution CO est reprise dans Rational Programming Patterns par la ligne *!CO "$1-COVIL", où CO est un micro-pattern :
 F26BB
 000   *N26BB.    NOTE *TEST CODE VILLE             *.
       *LV=10            
 010   *!CO "$1-COVIL"
 F26CB
 000   *N26CB.   NOTE *CAS 75001                    *.
       *IT LV15
                "75001"
 100       MOVE "PARIS 01" TO $1-LIVIL 
Lorsque le Programme, l'Ecran ou le Serveur appelant la Macro est généré, le micro-pattern CO est étendu et les lignes suivantes apparaissent dans le code affiché dans l'éditeur COBOL :
 *N26BB.    NOTE *TEST CODE VILLE                    *.
 *F26BB. EXIT.                                                lv10
 *N26CB.    NOTE *CAS 75001                          *.IT
  F26CB.    IF    WW00-COVIL =                                lv15
                  "75001"
            NEXT SENTENCE ELSE GO TO     F26CB-FN
      MOVE "PARIS 01" TO WW00-LIVIL.
  F26CB-900. GO TO F26BB-FN.
  F26CB-FN. EXIT. 
Le micro-pattern CO insère la valeur à tester uniquement sur les sous-fonctions de niveau immédiatement inférieur se trouvant dans la Macro. En aucun cas, il ne modifie le code spécifique dans le Programme, l'Ecran ou le Serveur appelant la Macro.
Exemple : Dans l'exemple précédent, une sous-fonction spécifique F26CE est ajoutée et la valeur du paramètre $1 est modifiée. Après regénération, la boucle CO prend en compte le nouveau paramètre mais la sous-fonction spécifique F26CE n'est pas modifiée.
 *N26BB.    NOTE *TEST CODE VILLE                    *.
 *F26BB. EXIT.                                                lv10
 *N26CB.    NOTE *CAS 75001                          *.IT
  F26CB.    IF    WW01-COVIL =                                lv15
                  "75001"
            NEXT SENTENCE ELSE GO TO     F26CB-FN
      MOVE "PARIS 01" TO WW01-LIVIL.
  F26CB-900. GO TO F26BB-FN.
  F26CB-FN. EXIT. 
*N26CE.    NOTE *TEST SPECIFIQUE                     *.IT
  F26CE.                                                      lv15
            IF    WW00-COVIL = 
                  "75004"
            NEXT SENTENCE ELSE GO TO     F26CE-FN
       MOVE "PARIS 04" TO WW00-LIVIL
  F26CE-FN. EXIT.

Vous pouvez transformer les sous-fonctions dépendantes d'une condition d'exécution CASE OF en ordre COBOL EVALUATE si toutes ces sous-fonctions sont écrites en spécifique. La boucle CO peut être écrite entièrement en spécifique (sans micro-pattern dans ce cas) ou consister en un appel du micro-pattern CO dans une Macro avec toutes les sous-fonctions dépendantes écrites en spécifique.

Pour transformer une boucle CO en un ordre EVALUATE, ouvrez la vue Structure du code généré du Programme, de l'Ecran ou du Serveur appelant la Macro. Faites un clic droit sur la sous-fonction contenant le CO et sélectionnez Actions sur fonction et sous-fonction > Reformatage du CASE OF en EVALUATE. Ce choix ne peut être sélectionné que si le Langage généré dans la Définition de la Bibliothèque du Programme, de l'Ecran ou du Serveur est D : COBOL II, 85, LE. La variable est alors testée pour toutes les sous-fonctions dépendantes du CO et un renvoi vers le traitement de chaque sous-fonction est effectué.

Les modifications suivantes sont automatiquement effectuées :
  • Dans la sous-fonction contenant le CO, les ordres suivants sont insérés :
    • EVALUATE <variable>. Dans cet ordre, variable représente la variable ciblée par la condition CASE OF.
    • WHEN. Un ordre de ce type est inséré pour chaque sous-fonction dépendante. Il est inséré sous la forme WHEN <valeur> PERFORM <Fffss> THRU <Fffss-FN>. Dans cette ligne, Fffss est le code de la sous-fonction dépendante et valeur la valeur testée sur cette sous-fonction.
    • WHEN OTHER. Cet ordre est inséré pour la dernière sous-fonction dépendante traitant des autres cas. Si cette sous-fonction n'existe pas, l'ordre n'est pas inséré.
    • END-EVALUATE.
    • GO TO <Fffss> -FN, où Fffss est le code de la sous-fonction courante.
  • Dans les sous-fonctions dépendantes du CO, les suppressions suivantes sont effectuées :
    • IT après le titre de la sous-fonction,
    • Lignes de la condition (IF...NEXT SENTENCE ...),
    • Ligne -900.
Exemple : Soit un CASE OF en spécifique ayant les mêmes sous-fonctions que l'exemple précédent. Après reformatage, le code affiché dans l'éditeur COBOL est le suivant :
*N26BB.    NOTE *TEST CODE VILLE                      *.    
 F26BB.                                                      lv10
    EVALUATE WW00-COVIL    
         WHEN ‘75001’ 
          PERFORM F26CB THRU F26CB-FN
    END-EVALUATE.          
    GO TO F26BB-FN.
*N26CB.    NOTE *CAS 75001                             *.
 F26CB.                                                      lv15
    MOVE "PARIS 01" TO WW00-LIVIL.                                                          .
 F26CB-FN. EXIT.
*F26BB. EXIT. 
La transformation n’est pas réalisée dans les cas suivants :
  • Les sous-fonctions dépendantes du CASE OF proviennent du code spécifique et aussi de Macros.
  • La détermination de la variable concernée par le CASE OF n’est pas identifiable.
  • La structure du CASE OF n’est pas respectée. Ceci est le cas, par exemple, lorsqu'un conditionnement sur plusieurs lignes sur une sous-fonction dépendante ne permet pas l’écriture de l’ordre EVALUATE.
Pour chacun de ces cas, un message est affiché pour expliquer pourquoi la transformation n'a pas été effectuée.

Si un micro-pattern CASE OF est défini dans une Macro et si toutes ses sous-fonctions dépendantes sont écrites en spécifique, la transformation est effectuée. Cependant, le micro-pattern CO dans la Macro n’a plus lieu d’être. Lors de la génération, un avertissement prévient l'utilisateur.


Vos commentaires