Programmation structurée en RPG/400

BoTTom |    Changer de couleur
 
                  Programmation structurée en RPG IV 
 
 PREAMBULE:
 
 le GAP 4 (ou RPG-IV) est un langage hybride ayant comme contrainte
   d'être compatible (en fonctionnalités) avec le GAP III .
 
 vous trouverez donc souvent deux écritures possibles
 
                     (voir le IF ci-dessous)
 
     C     codpai        IFEQ      'CHQ'          (style GAP III)
ou
     C                   if        codpai = 'CHQ' (style GAP 4)
 
 
 la première ligne utilise une spécif C standard (IPC sous SEU)
 
 la deuxième une spécif à facture 2 étendu (IPCX sous SEU) ou est utilisée
  dans un bloc en format libre [/free  /end-free]
 


|    Changer de couleur
 
                  Programmation structurée en RPG IV 
 
  But : améliorer la lisibilité donc la maintenabilité
 
        des pgms écrits en RPG IV
 
 
 Pour cela il faut Bannir GOTO - et autres TAG et abandonner les
  indicateurs en colonnes 9 à 11 (obligatoire en format libre)
 
 
 Les utiliser (les indicateurs) sous la forme *INxx ou *IN(xx)
                                                 (tableau de 99 postes)
    en les comparant à *ON  (vrai, = '1')
                    ou *OFF (faux, = '0')
 
 Exemple:  Facteur1++++++Codop+++++Facteur2++++++
     C     *IN03         IFEQ      *ON            (style GAP III)
     ou
     C                   if        *in03 [= *ON]  (style GAP IV)
 


|    Changer de couleur
                  Programmation structurée en RPG IV 
 
  Conditions : 
                           IFxx
 
 compare Facteur1 à Facteur2 avec l'opérateur xx    | format libre
                                                    |----------------------,
  EQ -> =   égal à                EQUAL             |      =
  NE -> <>  différent de          NOT EQUAL         |      <>
  GT -> >   plus grand que        GREATER THAN      |      >
  GE -> >=  plus grand ou égal    GREATER OR EQUAL  |      >=
  LT -> <   plus petit que        LESS THAN         |      <
  LE -> <=  plus petit ou égal    LESS OR EQUAL     |      <=
 
 Si la condition est vraie, RPG exécute tout ce qui suit le IF jusqu'à ENDIF
                                                                   ou  ELSE
 
 Si la condition est fausse, RPG saute à l'instruction qui suit ENDIF
                                                             ou ELSE
 Exemple:  Facteur1++++++Codop+++++Facteur2++++++
     C     CODE          IFEQ      'A'
 


|    Changer de couleur
  Exemple : 
           Facteur1++++++Codop+++++Facteur2++++++
           TOTFAC        IFGT      5000
                         ...                --!
                         ...                --!  Total > 5000,00
                         else
                         ...                --!  total < ou = 5000,00
                         ...                --!
                         ENDIF
 
 Vous pouvez imbriquer des conditions
           TOTFAC        IFGT      5000  -----------------------!
                           ...                                  ! Total
           CODPAI        IFEQ      'C'   ----!  total > 5000 ET !  >
                          ...                !   code = 'C'     ! 5000
                         else            ----!                  !
                          ...                !  total > 5000 ET !
                         ENDIF           ----!  code <> 'C'     !
                         ELSE         --------------------------!-----------
                          ...                                   ! Total < =
                          ...                                   !    5000
                         ENDIF        --------------------------!


|    Changer de couleur
  Exemple (spécif C étendue): 
           ++++++++++++++Codop+++++Facteur2+++++++++++++++++++++++++++
                         IF        totfac > 5000
                         ...                --!
                         ...                --!  Total > 5000,00
                         else
                         ...                --!  total < ou = 5000,00
                         ...                --!
                         endif
 
 Vous pouvez imbriquer des conditions (ici format libre)
        if        totfac > 5000;
          ...
          if        codpai='C';
               ...
          else;
               ...
          endif;
        else;
          ...
          ...
        endif;


|    Changer de couleur
 
 Vous pouvez définir des conditions complexes en les reliant entre elles
  par OU (OR) ou bien ET (AND)
                                |
   spécif C standard            | spécif C en format libre
 -------------------------------|-----------------------------------------
              IFxx              |        if     or, and, not
              ANDxx             |               "(" et ")"
              ORxx              |
                                |
              ENDIF             |
 
 Attention, avec les spécif C en format standard,
  vous ne bénificiez pas de parenthèses pour indiquer des priorités
 
 LA REGLE EST DONC LA SUIVANTE: un OU sépare des groupes de ET.
 (autrement dit vous redémarrez UNE NOUVELLE CONDITION à chaque OR.)
 
 Ce qui peut vous amener à répeter un condition dans chaque groupe de ET
  ou, mieux, utilisez le format libre de RPG-IV
 
                         IF        totfac > 5000 or codpai = 'C'            


|    Changer de couleur
Si vous avez des conditions mutuellement exclusives, qui s'enchainent
 vous pouvez utiliser SELECT :
 
           Facteur1++++++Codop+++++Facteur2++++++
                         SELECT
           f1            WHENxx    f2-- 1ere condition. Si vraie exéc  ution
                           ...          !  des instructions qui suivent puis
                           ...      -----  saut à ENDSL.
           f1            when      f2----
                           ...          ! 2eme condition (testée uniquement
                           ...      -----  si la première est fausse).Même
                         endsl                                      principe
 
  ou encore une fois le format libre de RPG-IV  avec WHEN seul :
           SELECT;
                 when      codfac = 'C';
                   ...
                 when      codfac = 'T';
                   ...
                 other;   //   si tous les WHxx précédents sont faux
                  ...
           ENDSL;


|    Changer de couleur
 
 Il existe une fonction analogue avec les sous programmes:
 
           Facteur1++++++Codop+++++Facteur2++++++ZR+++++++
           f1            CASxx     f2            NOMSR
 
 Si la condition est vraie, exécution du sous programme NOMSR puis saut à
  l'instruction qui suit ENDCS.
 Sinon, instruction suivante (ne peut être que CASxx ou ENDCS)
 
 Il n'est pas possible de définir des conditions complèxes
 
 L'équivalent de OTHER s'écrit CAS  (CAS sans xx)
 
 exemple:
           Facteur1++++++Codop+++++Facteur2++++++ZR+++++++
           CODFAC        CASEQ     'C'           FACCHQ
           CODFAC        CASEQ     'T'           FACTRT
                         CAS                     FACDIV
                         ENDCS
 
 


|    Changer de couleur
 
 Les boucles:  DOUxx-DOWxx-ENDDO
 
  les boucles se font par l'intermédiaire des instructions DOUxx (jusqu'à)
                                                           DOWxx (tant que)
  Différences: 
 
           DOUxx               !               DOWxx
                               !
  le test se fait sur ENDDO    ! le test se fait sur DOWxx
 (au moins une boucle)         ! (peut être exécutée 0 fois)
                               !
 on donne la condition d'arret ! on donne la condition pour boucler 
                               !
            !                  !      !-------->DOW
   !------>DOU                 !      !           ? (condition)--  
 f !        !                  !      !         v!             !f
 a !        !                  !      !         r!             !a
 u !      ENDDO                !      !         a!             !u
 s !         ? (condition)      !      !         i!             !s
 s ---------v                  !      ---------ENDDO           !s
 e           vraie             !                 !<------------!e


|    Changer de couleur
 Vous pouvez sortir d'une boucle de manière anticipée
 
                         LEAVE  permet de sortir de la boucle
                                  (saut après ENDDO)
 
                         ITER   sortie de CE TOUR de boucle
                                  (saut à ENDDO  ==> boucle suivante sera
                                                     réalisée suivant la
                                                     condition DOUxx-DOWxx.)
 Exemple: 
 
        dou       %eof;
          READ      FICHIER;
          select;
             when      %eof;
               LEAVE;                 //  EOF = sortie de la boucle
             when      codfac = 'T';
               ITER;                  // je ne traite pas code = 'T'
             other;
               ...                    //  traitement d'un enreg lu.
          endsl;
        enddo;


|    Changer de couleur
 
L'ordre DO seul possède de multiples fonctionnalités (spécif C classique)
 
  Nxx      Facteur1++++++Codop+++++Facteur2++++++ZR+++++++
   aa      déb           DO        fin           rés
                          ...
                          ...
                          ...
   bb                    ENDDO     inc
 
   aa= condition pour faire (si la condition est fausse -> saut après ENDDO)
 
   bb= condition pour boucler(si fausse, RPG ne "voit" pas ENDDO et sort)
 
   déb = valeur de début de boucle (dft = 1)
 
   fin = val de fin de boucle, Si rés > à fin -> saut après ENDDO.(dft = 1)
 
   rés = zone du pgm servant de compteur (dft = compteur interne à RPG).
 
   inc = val de l'incrément à chaque fin de boucle,avant comparaison.(dft=1)
 


|    Changer de couleur
 Exemples : 
  Nxx      Facteur1++++++Codop+++++Facteur2++++++ZR+++++++
 
   40                    DO        10
                         ...            faire 10 fois si 40 est ON
                         ...
                         ENDDO
 
           2             DO        Z
                         ...            faire jusqu'à Z à partir de 2  ,
                         ...                            par pas de 2.
                         ENDDO     2
 
                         DO        10            CPT          (1 dt 0)
                         ...
                         ...             le pgm plante !!!!
                         ...
                         ENDDO           en effet CPT va prendre tout
                                            les valeurs de 1 à 9 puis doit
                                            prendre la valeur 10, impossible
                                           ==> RPG ne contrôle pas votre
                                                compteur.


|    Changer de couleur
 
 FOR            réalisation d'une boucle en faisant varier un indice
 
 
                FOR     indice [= val. de départ]
                               [BY incrément]
                               [TO val. maxi | DOWNTO val. mini]
 
                 ...
 
                ENDFOR
 
  valeur de départ et incrément sont par défaut de 1.
  valeur limite est par défaut *HIVAL
 
  comme avec le DO, des indicateurs peuvent être utilisés
 
  un indicateur sur l'ordre FOR contitionne l'ensembel du traitement
 
  un indicateur sur le ENDFOR conditionne la REPETITION (comme DO)
 
 


|    Changer de couleur
 
 Quelques exemples :
 
 
 
     C                   eval      factoriel = 1
     C                   FOR       i = 1 to n
     C                   eval       factoriel = factoriel * i
     C                   ENDFOR
 
 
      // recherche du dernier car. non blanc
           FOR i = %len(raisoc) downto 1;
             if %subst(raisoc : i : 1) <> ' ';
               leave;
             endif;
           ENDFOR;
 
 
 
 
 


|    Changer de couleur
 
 Et n'oubliez pas les sous programmes (meilleure lisibilité)
 
  Nxx      Facteur1++++++Codop+++++Facteur2++++++ZR+++++++
                         EXSR      SP1      exécute SP1 puis reprend à
                          ...               l'instruction qui suit EXSR.
                          ...
                         eval      *inlr = *on
 
           SP1           BEGSR         Les variables sont communes au pgm
                           ...           principal et aux sous programmes
                         ENDSR          (ce n'est pas le cas des procédures)
 
(V4R40)
 
                         LEAVESR       pour sortie anticipée d'un sous-pgm.
 
 
 Pour tous ces codes opération l'ordre END (seul) était admis (sauf ENDSR)
 
 Pour une plus grande lisibilité de vos listes de compilation, utilisez le
  paramètre INDENT de la commande de création ou le mot-clé en spécif H.





©AF400