Sous-Procédures & Fonctions

// Bonjour,

// L'unité de code qui tourne, sur un iSeries ou désormais System i,

// c'est la procédure...

Les sous-procédures ou fonctions sont des sortes de sous-programmes, avec beaucoup d'avantages !

  Le code est local
  On peut les appeler dans un "eval". Et les imbriquer. 
  ("callp" si pas de parm en retour).
  Elles peuvent être stockées dans un "programme de service".
  Beaucoup de vérifications à la compile.
  Mais il faut en passer par les "prototypes" PR et les "procedure interface" PI.
  (Ces 2 structures, et les appels à la procédure doivent être cohérents...)

Habituellement, les procédures d'intérêt général sont externalisées dans un "programme de service", (sorte de dll). Et donc les prototypes dans l'appelant et l'appelé sont mutualisés dans un membre source distinct et intégrés dans chaque programme par des /copy.

NB : Les prototypes servent aussi à appeler les programmes externes.
C'est la norme en free-rpg. "call" n'existe pas, il faut utiliser "callp".
"p" pour "prototyped procedure or program"...

Ils servent aussi à appeler des méthodes Java.

Autant le dire, les prototypes sont incontournables et riches en possibilités.
(cf la doc IBM)

Hdftactgrp(*no)
Ftest01fm  cf    e             workstn
D loop              s                n
D chiffre           c                     '1234567890'
D errw              s               3  0 
D testa             s              21   
* 
* PROTOTYPE d'appel :
* Sur la 1°ligne, est indiquée éventuellement la valeur de retour. (ici 23  5)
* Suivent les 3 paramètres (les noms sont facultatifs dans PR et requis dans PI),
* ils sont passés par valeur.
* 
* Pour passer de l'alpha au num
Dalphanum          pr             23  5                le PROTOTYPE
D zonealpha                        18     value varying
D decimales                           1     value 
D negatif                               1     value
*
*
*
/free
     do  loop;

exfmt ecran01;
if *inkc;
*inlr = *on;
return;
endif;

      // Appel de la fonction (procedure qui retourne une valeur)
testn = alphanum(test18:dec:nega); // Les 3 parms viennent de l'écran.

enddo;
/end-free
*
*
* * * * * * * * * * *
*
* PROCEDURE INTERFACE
* Le nom est facultatif puisqu'il est indiqué en carte "P".
* S'il s'agit d'une fonction, "return" doit renvoyer quelque chose.
* Les zones définies ici sont "locales". Les "globales" sont aussi accessibles (ex : errw)
*
* Pour passer de l'alpha au num
* (Si erreur, la zone globale errw est renseignée :
* il faut la tester après chaque appel !)
Palphanum           b
D                   pi                   23  5                la PROCEDURE INTERFACE
D zonealpha                        18     value varying
D decimales                          1     value 
D negatif                              1     value

D zonenum           s              18  0
D resultn             s              23  5
D diviseur             s              11  0
D decn                  s               1  0

* NB : ce qui suit est du vieux code en format fixe...
* On peut maintenant utiliser des Bif comme %dec !

C                       eval           resultn = 0
C                      eval           errw = 0

C                      eval           zonealpha = %trim(zonealpha)

C                      if               %check(chiffre:zonealpha) <> 0
C                      eval           errw = 1
C                     return         0   
C                     endif

C                    move          zonealpha    zonenum

C                     if                decimales <> *blanks
C                     if               %check(chiffre:decimales) <> 0
C                    eval            errw =2
C                    return         0
C                     endif

C                    move          decimales    decn
C                     eval            diviseur = 10 ** decn
C                    eval            resultn = zonenum / diviseur
C                     else
C                     eval            resultn = nonenum
C                     endif

C                    if                 negatif = '-'
C                    eval              resultn =- resultn
C                    else
C                   if                   negatif <> *blanks
C                   eval               errw = 3
C                    return           0
C                   endif
C                    endif

C                    return          resultn

P              e