RÉINGÉNIERIE DE CODE RPG 4e étape – Touches de fonction

  1. Dans les anciennes méthodes, les touches de fonction utilisent les indicateurs INK?, où ? est une lettre de A à X.

Parfois un indicateur de réponse a été spécifié dans le DDS, *IN03 dans l’exemple ci-dessous, qui sera mis à ‘1’ si la touche de fonction a été enfoncée.

     A                                      CA03(03)  

Pour que les touches de fonction soient déclarées de façon plus explicites, nous allons baser des indicateurs sur l’espace mémoire des touches de fonction grâce à l’utilisation des pointeurs.

      // Indicateurs de touches fonctions *INKA, ...                                                
      // à utiliser par /COPY                                                                       
                                                                                                    
      /if defined(FONCTION_H)                                                                       
       /eof                                                                                         
      /endif                                                                                        
                                                                                                    
       /define FONCTION_H                                                                           
                                                                                                    
       dcl-s P_INKA pointer inz(%addr(*inka));                                                      
       dcl-s F1 ind based(p_inka);                                                                  
       dcl-s Aide ind based(p_inka);                                                                
       dcl-s P_INKB pointer inz(%addr(*inkb));                                                      
       dcl-s F2 ind based(p_inkb);                                                                  
       dcl-s P_INKC pointer inz(%addr(*inkc));                                                      
       dcl-s F3 ind based(p_inkc);                                                                  
       dcl-s Sortie ind based(p_inkc);                                                              
       dcl-s Exit ind based(p_inkc);                                                                
       dcl-s P_INKD pointer inz(%addr(*inkd));                                                      
       dcl-s F4 ind based(p_inkd);                                                                  
       dcl-s Guide ind based(p_inkd);                                                               
       dcl-s P_INKE pointer inz(%addr(*inke));                                                      
       dcl-s F5 ind based(p_inke);                                                                  
       dcl-s Refresh ind based(p_inke);                                                             
       dcl-s P_INKF pointer inz(%addr(*inkf));                                                      
       dcl-s F6 ind based(p_inkf);                                                                  
       dcl-s Creer ind based(p_inkf);                                                               
       dcl-s P_INKG pointer inz(%addr(*inkg));                                                      
       dcl-s F7 ind based(p_inkg);                                                                  
       dcl-s P_INKH pointer inz(%addr(*inkh));                                                      
       dcl-s F8 ind based(p_inkh);                                                                  
       dcl-s Imprimer ind based(p_inkh);                                                            
       dcl-s P_INKI pointer inz(%addr(*inki));                                                      
       dcl-s F9 ind based(p_inki);                                                                  
       dcl-s P_INKJ pointer inz(%addr(*inkj));                                                      
       dcl-s F10 ind based(p_inkj);                                                                 
       dcl-s P_INKK pointer inz(%addr(*inkk));                                                      
       dcl-s F11 ind based(p_inkk);                                                                 
       dcl-s P_INKL pointer inz(%addr(*inkl));                                                      
       dcl-s F12 ind based(p_inkl);                                                                 
       dcl-s Cancel ind based(p_inkl);                                                              
       dcl-s Annuler ind based(p_inkl);                                                             
       dcl-s P_INKM pointer inz(%addr(*inkm));                                                      
       dcl-s F13 ind based(p_inkm);                                                                 
       dcl-s P_INKN pointer inz(%addr(*inkn));                                                      
       dcl-s F14 ind based(p_inkn);                                                                 
       dcl-s P_INKP pointer inz(%addr(*inkp));                                                      
       dcl-s F15 ind based(p_inkp);                                                                 
       dcl-s P_INKQ pointer inz(%addr(*inkq));                                                      
       dcl-s F16 ind based(p_inkq);                                                                 
       dcl-s P_INKR pointer inz(%addr(*inkr));                                                      
       dcl-s F17 ind based(p_inkr);                                                                 
       dcl-s P_INKS pointer inz(%addr(*inks));                                                      
       dcl-s F18 ind based(p_inks);                                                                 
       dcl-s P_INKT pointer inz(%addr(*inkt));                                                      
       dcl-s F19 ind based(p_inkt);                                                                 
       dcl-s P_INKU pointer inz(%addr(*inku));                                                      
       dcl-s F20 ind based(p_inku);                                                                 
       dcl-s P_INKV pointer inz(%addr(*inkv));                                                      
       dcl-s F21 ind based(p_inkv);                                                                 
       dcl-s P_INKW pointer inz(%addr(*inkw));                                                      
       dcl-s F22 ind based(p_inkw);                                                                 
       dcl-s P_INKX pointer inz(%addr(*inkx));                                                      
       dcl-s F23 ind based(p_inkx);                                                                 
       dcl-s P_INKY pointer inz(%addr(*inky));                                                      
      * ------------------------------------------------------                                      
       dcl-s F24 ind based(p_inky);                                                                  

Par exemple pour PF3, P_INKC est le pointer contenant l’adresse de l’indicateur de la touche de fonction PF3.

       dcl-s P_INKC pointer inz(%addr(*inkc)); 

3 autres Indicateurs sont déclarés et basés sur ce pointer.

       dcl-s F3 ind based(p_inkc);                                                                  
       dcl-s Sortie ind based(p_inkc);                                                              
       dcl-s Exit ind based(p_inkc); 

Dans le source RPG ILE, cela permet de tester les indicateurs F3, Sortie ou Exit, plus explicite, à la place de *INKC.

         // touches F3 et F12
         IF Sortie OR
               Annuler;
           // on met l'indicateur à Off = fin du programme
           g_Sortie = *OFF;
           g_Fin_actions = *OFF;
         ENDIF;  

 

Et si vous souhaitez normaliser vos développements, mettez cette déclaration dans une copie.

RÉINGÉNIERIE DE CODE RPG 1re étape RPG III vers RPG ILE
RÉINGÉNIERIE DE CODE RPG 2e étape – Code en commentaire
RÉINGÉNIERIE DE CODE RPG 3e étape Indicateurs Fichier
RÉINGÉNIERIE DE CODE RPG 5e étape – Indicateurs DSPF

RÉINGÉNIERIE DE CODE RPG 3e étape Indicateurs Fichier

3ème étape : Convertir les indicateurs des opérations sur fichiers par l’usage du BIF correspondant:

  • CHAIN
    • Indicateur HI correspond à %Found,
    • Indicateur LO correspond à %Error,

Exemple:

     C     CLNFC2        CHAIN     TNFCP                              60

Devient:

         CHAIN CLNFC2 TNFCP;

         If not %found(TNFCP);
  • SETLL
    • Indicateur HI correspond à %Found,
    • Indicateur LO correspond à %Error,
    • Indicateur EQ correspond à %Qual,

Exemple:

 C     CLNFC         SETLL     TNFCP                              
    60
    

Devient

         SETLL CLNFC2 TNFCP;

         If %Equal(TNFCP);
  • UPDATE
    • Indicateur LO correspond à %Error,
  • DELETE
    • Indicateur HI correspond à %Found,
    • Indicateur LO correspond à %Error,

Exemple

     C     CLNFC2        DELETE    TNFCF                              70
     C   70              MOVE      '1'           *IN72

Devient

                 DELETE CLNFC2 TNFCF;
                 If Not %found(TNFCF);
     C                   MOVE      '1'           *IN72
                 Endif; 

 

L’usage de la fonction de transformation en format libre de RDI peut vous y aider. Les indicateurs seront alimentés par les BIF correspondants.

 

     C     CLNFC         CHAIN     TUCHF                              78      

Sera remplacé par:

CHAIN CLNFC TUCHF;
*In78 = not %Found(TUCHF);      

Ensuite vous pourrez changer l’indicateur par le BIF correspondant.

RÉINGÉNIERIE DE CODE RPG 1re étape RPG III vers RPG ILE
RÉINGÉNIERIE DE CODE RPG 2e étape – Code en commentaire
RÉINGÉNIERIE DE CODE RPG 4e étape – Touches de fonction
RÉINGÉNIERIE DE CODE RPG 5e étape – Indicateurs DSPF

RÉINGÉNIERIE DE CODE RPG 2e étape – Suppression code en commentaire

La deuxième étape est de supprimer les lignes de code mises en commentaire, il y a des chances pour que la raison de cette mis en commentaire ne soit plus connue.

De plus, dans une entreprise bien organisée, des sauvegardes de sources ont lieu régulièrement sur bande.

Et supprimer les tag mis par les programmeur dans les colonnes 1 à 5, un commentaire bien explicite sera plus efficace.

RÉINGÉNIERIE DE CODE RPG 1re étape RPG III vers RPG ILE
RÉINGÉNIERIE DE CODE RPG 3e étape Indicateurs Fichier
RÉINGÉNIERIE DE CODE RPG 4e étape – Touches de fonction
RÉINGÉNIERIE DE CODE RPG 5e étape – Indicateurs DSPF

RÉINGÉNIERIE DE CODE RPG 1re étape RPG III vers RPG ILE

Face à un vieux sources OPM en RPG III, il est nécessaire d’y faire de la réingénierie , en d’autre terme réorganiser et moderniser le source pour qu’il devienne plus lisible et plus facile  à maintenir.

La première étape est de convertir le source RPG III en RPG IV. La commande native utilisée est CVTSRCPF. (ou avec UPGRPGSRC  de https://software.projex.com/ , je n’ai pas essayé, si vous l’avez fait, n’hésiter pas à nous faire un retour dans les commentaires).

CVTRPGSRC FROMFILE(MABIB/QRPGSRC)
          FROMMBR(SOURCEMBR)     
          TOFILE(MABIB/QRPGLESRC)
          TOMBR(SOURCEMBR)       

RÉINGÉNIERIE DE CODE RPG 2e étape – Code en commentaire
RÉINGÉNIERIE DE CODE RPG 3e étape Indicateurs Fichier
RÉINGÉNIERIE DE CODE RPG 4e étape – Touches de fonction
RÉINGÉNIERIE DE CODE RPG 5e étape – Indicateurs DSPF