Tous les articles par Ibmiiste

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

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);                                                                  

Un pointer est défini sur l’adresse de l’espace mémoire d’une touche de fonction.

Par exemple pour PF3.

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

Le pointer P_INKC est le pointer contenant l’adresse de l’indicateur de la touche de fonction PF3.

3 autres Indicateurs sont déclarées et basées 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 = '1' OR
               Annuler = '1';
           // on met l'indicateur à Off = fin du programme
           g_Sortie = *OFF;
           g_Fin_actions = *OFF;
         ENDIF;  

 

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

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

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 2e étape

La deuxième étape est de supprimer les paragraphes et les lignes  mis 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

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)       

IBM i et GIT, filtrer les fichiers inutiles des projets i

Pour pouvoir filtrer les fichiers dans le Staging de git, vous devez créer un fichier qui contient les règles. En règle générale, il est appelé .gitignore, mais vous pouvez l’appelez comme vous voulez.

Ensuite vous indiquez à Git via les préférences de Rdi où se trouve le fichier.

Créez le fichier .gitignore contenant les lignes suivantes :

/.ibmi
*.project

Et enregistrez le dans C:\Users\Votre profil\git\

Dans la configuration git (Menu Fenètres->Préférences->Equipe->Git->Configuration), ajoutez une entrée, puis faîtes OK.

Vous obtenez cette configuration :

Faîtes Appliquer ou OK puis redémarrer Rdi.

Et tadam!!:

Gérer la suppression de table SQL DB2 i

Pour éviter des erreurs de création avec DROP TABLE dans l’utilisation de RUNSQLSTM, vous pouvez utiliser ce bout de code:

 

BEGIN
   DECLARE CONTINUE HANDLER FOR SQLEXCEPTION
      BEGIN END;
   DROP TABLE RNPROW;
END;  

Faking Create Or Replace Table – IT Jungle

The new CREATE OR REPLACE feature of SQL has been most helpful to me. It works for aliases, functions, masks, permissions, procedures, sequences, triggers, variables and views. It would be nice if it worked for tables, especially when I’m developing a new application. Here’s a workaround. The trick is to use a dynamic compound statement.

Source: www.itjungle.com/2015/01/20/fhg012015-story01/

 

Le matos pour un serveur Raspberry Pi2+

Comme indiquer dans un billet précédent, je souhaite m’autohéberger. Pour ce faire, j’ai choisi d’utiliser un Raspberry Pi2+ comme serveur Web.

Première chose, pour ceux qui ne l’ont pas encore, il faut acheter le matériel: