Archives de catégorie : Programmation

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/

 

Planifier le transfert d’un objet d’un IBM i à un autre

On peut livrer sur une autre machine de façon différée avec System i Navigator.

Allez dans Systèmes de fichiers->Système de fichiers intégré->QSYS.LIB->Bib de départ

Sélectionnez l’objet à transférer et faites clic droit->envoi

Une fenêtre s’affiche et vous y trouverez un bouton planification:

cliquez le bouton Planification,

 

Saisissez la date et l’heure puis OK. La mise en production est programmée.

Et après la date planifiée, nous obtenons les messages suivants:

Et sur CICA98, on trouve notre objet livré:

 

Se lancer dans une nouvelle évolution d’une application grâce à RDI couplé à GIT

Introduction

Seconde partie sur l’association de RDI avec GIT, votre référentiel est créé (voir article précédent) et on vous demande de nouveaux développements. Nous allons voir comment créer une nouvelle branche dans GIT. Continuer la lecture de Se lancer dans une nouvelle évolution d’une application grâce à RDI couplé à GIT

Comment faire votre première image de votre application dans GIT?

Après avoir découvert Git intégré à Rdi, j’ai du faire une documentation pour pouvoir l’utiliser. En effet, les informations trouvées sur le net était quelque peu limitées au commit sur dépôt local et aux connaissances basiques de son utilisation.

Vous trouverez dans ce blog, une série d’articles reprenant la documentation que je me suis faite.

Puisque sur IBM i, nous avons souvent des applications anciennes en maintenance, ce premier article va vous éclaircir sur la création du premier dépôt, nous dirons de référence, d’une application existante.

Introduction

Pour information, le serveur Git utilisé dans cet exemple est hébergé sur GITHUB, mais pour d’autre site comme Gitlab ou Bitbucket, cela reste similaire.

Concernant les mot anglais, en général il sont utilisés quand je désigne ce mot dans une application et le mot en français quand il est utilisé dans le texte de façon général.

N’ayant pas trouvé de mot français correct, le mot anglais commit n’est pas traduit. Merge aura comme équivalent le nom fusion ou le verbe fusionner et repository aura dépôt.

Paramètres initiaux

Dans les préférences de RDI, ayez ce qui suit, c’est pour éviter, sur le serveur GIT, de transportez les dates et les numéros de séquences dans les sources (Les personnes faisant des copier/coller à partir du serveur apprécieront).

Création de l’environnement initial de l’application

Création d’un projet

Allez sur votre serveur Git, cliquez sur New repository:

 

Renseignez les champs selon votre environnement de travail, chez nous, nous utilisons ce qui suit :

  • Le nom du dépôt:
  • Une description du dépôt/projet/application
  • Cocher Public ou Private

Puis cliquer sur Create Repository:

 

Ajout de tous les sources de références dans le dépôt

Allez sur RDI puis le menu fenêtre et ouvrir la perspective Git :

Dans la perspective, cliquez sur cloner un dépôt

Cet écran s’affiche

Revenez dans GITHUB et copier le lien proposé :

Puis collez le dans la ligne Url de la fenêtre Rdi, les lignes suivantes sont automatiquement alimentées, éventuellement saisir vos identifiants de connexion au serveur GIT :

Après suivant, la fenêtre suivante s’affiche :

Faites suivant :

Puis terminer :

Le dépôt est cloné en local:

Aller dans la perspective Projets i :

Créer un nouveau projet :

Fichier->Nouveau->Projet IBM i

Alimenter la fenêtre suivante comme ci-dessous :

Indiquez la connexion utilisée et la bibliothèque concernée:

Faites suivant et choisissez les options du projet i :

Puis terminer, le projet est créé :

Le projet est lié automatiquement au dépôt cloné, maintenant il faut mettre tous les sources de références de l’application et faire le commit initial.

On fait un filtre objet sur les fichiers sources de l’application :

Sélectionnez tous les fichiers que vous allez ajouter au projet :

Clic droit et choisissez Ajouter au projet :

Sélectionner le projet :

Sélectionnez tous les fichiers puis clic droit->team->Add to index :

Sélectionnez le projet puis clic droit->Team->Commit

Saisir dans la fenêtre un texte explicatif :

Cliquez sur Commit and Push:

Faites suivant :

Faites Terminer :

Faites OK. Sur GITHUB, vous avez une image des sources de l’application :

 

A partir de là, vous avez un dépôt de référence à partir duquel vous pouvez commencer à travailler.

 

Ci-dessous, différents sites qui m’ont aidé à comprendre:

Documentation GIT en français

Getting Relic Package Manager to your IBM i using RDi and Git