pause-café

  L'appel d'un programme peut-être écrit en format libre (V3.60)


  cela ce réalise avec un protoype (modèle) puis l'ordre CALLP.


     il faut pour cela déclarer le programme et ses paramètres avant,
      en spécif D, cela s'appelle un PROTOTYPE.


  DEXEC             PR                  EXTPGM(QCMDEXC)
  D cmd                          250
  D cmdlen                        15P 5 CONST


    PR indique qu'il s'agit d'un prototype (même positions que DS)


    EXTPGM le nom du pgm externe


    CONST sur un paramètre indique qu'il s'agit d'un paramètre non
          modifiable, car copié en mémoire, ce qui autorise les expressions.


ce qui permet
     C                   callp     exec(commande:%size(commande))


                        

  Le même ordre peut être utilisé pour l'appel à des procédures liées
     (liage par copie[module] ou par référence[programme de service].)


     il faut alors déclarer la procédure et ses paramètres, avant, en
      spécif D avec le mot-clé EXTPROC


  Dinviteclient     PR                  EXTPROC('F4Client')
  D nocli                          6  0
  D fenetre                        1    CONST


    EXTPROC le nom de la procédure

    CONST (idem EXTPGM), ici VALUE aurait permis un passage de paramètre par valeur


ce qui permet


     /free

                 inviteclient(nocli:'O')) ;

    /end-free

                        

Intégration des langages ILE/RPG4 et JAVA.



 Il est possible de déclarer et d'utiliser depuis RPG4 :


   - des méthodes Java
   - des objets (retournés par Java ou destinés à être retournés)



 Il est aussi possible de déclarer en RPG4 :


   - des fonctions RPG4 devant être utilisées depuis java


                        

 Quelques rappels :


 - java est un langage orienté objet


 - en java un objet est matérialisé par une Classe (CLASS en anglais)


   cette classe encapsule (contient et protège)


   + des variables, souvent privées, c.a.d dire non visibles de l'exterieur


        - ces variables peuvent être des données élémentaires
          (octet, entier, numérique à virgule flottante, ..)


        - ou bien elles même des objets (String par exemple est un objet)


   + des méthodes (ou fonctions) chargée de traiter et de retourner
      les variables sus nommées.


    Une de ces méthodes peut porter le même nom que la classe (on parle
    alors de constructeur) elle est chargée de réaliser l'initialisation
     lors de la création d'une instance de l'objet en mémoire.

 Déclaration d'un objet/java en RPG4


 D javaChaine      S               O   CLASS(*JAVA : 'java.lang.string')


 cette définition peut être placée


  en tant que variable
  en tant que paramètre d'une procédure
  en tant que valeur retournée par une procédure


  Ici, l'objet javaChaine va probablement être chargé par l'appel à une
   méthode sous la forme javaChaine = maMethode()


 Déclaration d'une méthode


 D maMehtode       PR          ->  ?   EXTPROC(*JAVA : 'nom de la classe' :
                              /                        'méthode' ou
                             /                                *CONSTRUCTOR)
                            /
  vous devez indiquer le type de donnée retourné


                        

 par exemple, la methode suivante transforme l'objet String en suite
  d'octets :


 D StringversChainePR          32767   VARYING
                                       EXTPROC(*JAVA : 'java.lang.String'
                                                       'getBytes')


 et celle ci transforme l'objet Date en Objet String


 D DateversString  PR              O   CLASS(*JAVA : 'java.lang.String')
                                       EXTPROC(*JAVA : 'java.lang.Date'
                                                       'toString')
 bien sur vous pourrez écrire :


      var1 = StringversChaine( DateversString(obj1) ) ;


  où obj1 et var1 sont déclarés :


 D obj1            S               O   CLASS(*JAVA : 'java.lang.Date')
 D var1            S             10A


                        

 Appel et passage de paramètres :


  il existe deux types de méthodes en Java.


  1/ les méthodes statiques ou méthodes de classe, elles sont déclarées


     Static  typeretour nomMethode() {
     }


     elle ne s'appuient pas sur une instance pour réaliser le traitement


     VOUS DEVREZ AJOUTER STATIC, lors du prototypage RPG




  2/ les méthodes qui s'appuient sur une instance (un objet en mémoire)


     VOUS DEVREZ AJOUTER un paramètre aux paramètre(s) déclaré(s) dans le
      prototype: le nom de l'objet instancié.


        en java dat1.toString
        en RPG4 DateversString(dat1)

Exemple avec la méthode equalsIgnoreCase de l'objet String.


 Cette méthode compare deux objets String et indique (par un booléen)
  que leur contenu est identique (true) ou non (false)


 en java :


 public class Equals {
     public static void main(String[] args) {


          String maChaine1 = new String("test1");
          String maChaine2 = new String("test2");


          if (maChaine1.equalsIgnoreCase(maChaine2)) {


           System.out.println("identique");
          } else {
           System.out.println("différents");
          }
     }
}

 en RPG4 :
 H DFTACTGRP(*NO) ACTGRP(*CALLER) THREAD(*SERIALIZE)


 D newString       PR              O   EXTPROC(*JAVA : 'java.lang.String')
 D                                                     *CONSTRUCTOR)
 D                               30A   CONST VARYING


 D maChaine1       S               O   CLASS(*JAVA : 'java.lang.String')
 D maChaine2       S               O   CLASS(*JAVA : 'java.lang.String')


 D StrEquals       PR              N   EXTPROC(*JAVA : 'java.lang.String' :
                                                        'equalsIgnoreCase')
 D                                 O   CLASS(*JAVA : 'java.lang.String')


/free
  maChaine1 = newstring('test1');
  maChaine2 = newstring('test2');
  if StrEquals(maChaine1 : maChaine2) ;
     dsply 'identique' ;
  endif;
  *inlr = *on;
/end-free

Equivalence des différents type de données :
 +-----------------+------------------+----------------------------------+
 +  Java           +  RPG4            + commentaires                     +
 +-----------------+------------------+----------------------------------+
 +   Boolean       +     N            +  indicateur                      +
 +-----------------+------------------+----------------------------------+
 +   Byte          +    3I 0          +  un octet binaire                +
 +                 +                  +   (pas de conversion)            +
 +                 +    1A            +  un caractère                    +
 +                 +                  +   (conversion ASCII/EBCDIC)      +
 +-----------------+------------------+----------------------------------+
 +   Byte[]        +    1A     DIM(x) +  tableau d'octets                +
 +-----------------+------------------+----------------------------------+
 +   Short         +    5I 0          +  entier court (deux octets)      +
 +-----------------+------------------+----------------------------------+
 +   Int           +   10I 0          +  entier (quatre octets)          +
 +-----------------+------------------+----------------------------------+
 +   Long          +   20I 0          +  entier long (8 octets)          +
 +-----------------+------------------+----------------------------------+
 +   float         +    4F            +  flottant (4 octets)             +
 +-----------------+------------------+----------------------------------+

 +-----------------+------------------+----------------------------------+
 +  Java           +  RPG4            + commentaires                     +
 +-----------------+------------------+----------------------------------+
 +   double        +    8F            +  flottant (8 octets)             +
 +-----------------+------------------+----------------------------------+
 +   Char          +    1C            +  1 octets en UCS-2 (unicode)     +
 +-----------------+------------------+----------------------------------+
 +   Char[]        +    nC            +  n octets en UCS-2 (unicode)     +
 +-----------------+------------------+----------------------------------+
 +  un objet       +     O            +  CLASS(*JAVA : ..)               +
 +-----------------+------------------+----------------------------------+
 +  tableau        +     ?  DIM(x)    +  pour pouvez faire un tableau    +
 +                 +                  +   de n'importe quelle définition +
 +-----------------+------------------+----------------------------------+


 la plupart des chaines sont à taille variable :


   pour les variables caractères (UCS-2) indiquez VARYING


   Pour les tableaux de caractères indiquez OPTIONS(*VARSIZE)


                        

 Pour appeller une méthode java depuis RPG4


 Nous l'avons vu, utiliser directement la méthode ou bien CALLP
  si la méthode ne retourne pas de valeur (void).


 RPG va vérifier si la JVM (machine virtuelle Java, "run-time" java)
  est démarrée, sinon, il la démarre.


  Vous pouvez la démarrer par pgm (et l'arreter) en utilisant les API JNI.
   (voir plus loin, les exemples associés à ce cours)


  Java possède sont propre ramasse-miette (méchanisme qui permet à la JVM
   de détruire les objets de la mémoire quand ils ne sont plus utilisés)
  Dans notre cas, Java ne sait plus, et nous devons donc supprimer les
   instances, nous même, toujours avec les API JNI.


  Enfin, si vous utilisez des classes non standard, précisez bien la
   CLASSPATH par :
                   ADDENVVAR ENVVAR(CLASSPATH)
                           VALUE('/mesclasses/:classes/autresclasses.jar')


                        

 A l'inverse, pour lancer une fonction RPG4 depuis une classe JAVA
  vous devrez :


   1/ coder le prototype avec EXPORT (fonction publique, visible)


   2/ créér un programme de service et le placer dans *LIBL.


   2/ déclarer votre programme de service en JAVA par :
      .............................................................
      : static                                                    :
      : {                                                         :
      :       System.loadLibrary("MONSRVPGM");                    :
      : }                                                         :
      :                                                           :
      : (static) native boolean verifClient(byte nomDuClient[]);  :
      :...........................................................:


     bien sûr il faut ensuite envoyer des arguments compatibles
      avec le type attendu, par exemple :


            if ( verifClient(str.getBytes() ) { // ne pas envoyer un String

 si vous souhaitez un code RPG4 simple, envoyez des types élémentaires
    (byte, int , etc...)


 si vous souhaitez un code JAVA simple, envoyez des objets et faites
  la conversion (par exemple String en Bytes) dans le programme RPG4.


Exemple 1:


 Fonction RPG retournant la longueur d'une variable d'environnement.


 DgetenvvarL       PR            10I 0 STATIC
 D                                     EXTPROC(*JAVA : 'EnvClassL' :
 D                                      'getEnvVarL')
 D                              128A   VARYING CONST


 PgetEnvVarL       B                   EXPORT
 D                 PI            10I 0 STATIC
 D param1                       128A   VARYING CONST


 ../... (suivent d'autres déclarations, voir l'exemple complet)


                        

  /free
      envname = param1 ;
      envnamelg = %len(%trim(envname)) ;
      getenv(env : envlg : envvallg :
             envname : envnamelg : APIERR) ;  // API de QTMHCGI
      retour = %len(%trim(env));
      return retour;
  /end-free
 PgetEnvVarL       E




La classe JAVA


 class EnvClassL
 {
    static
    {
      System.loadLibrary("GETENVVARL");
    }


    native static int getEnvVarL (byte envname[] );


                        

    public static void main(String[] args)


    {
       String envvar = args[0] ;
       int retour;
       retour = getEnvVarL(envvar.getBytes() ) ;
       System.out.println("variable " + envvar + " =" + retour );
    }
}


Vous remarquerez l'envoi de données simples à l'aide de .getButes




A l'inverse ce deuxième exemple utilsie des données String (objet)


le programme RPG4, doit donc transformer l'objet String en chaine simple
(déclaration de la méthode getBytes), puis transformer la variable
 contenant les données à retourner en String (*CONSTRUCTOR sur la classe
 java.lang.string)




                        

 DgetEnvVarO       PR              O    EXTPROC(*JAVA : 'EnvClassO' :
 D                                              'getEnvVarO')
 D                                       CLASS(*JAVA : 'java.lang.String'
 D                                       STATIC
 D                                 O   CLASS(*JAVA : 'java.lang.String')


  *  de transformation String -> Bytes
 DgetBytes         PR           128A   EXTPROC(*JAVA : 'java.lang.String'
 D                                             : 'getBytes') VARYING
  *  de transformation Byte -> String
 DnewString        PR              O   EXTPROC(*JAVA : 'java.lang.String'
 D                                             : *CONSTRUCTOR)
 D bytes                        128A    CONST VARYING


 PgetEnvVarO       B                   EXPORT
 D                 PI              O   CLASS(*JAVA : 'java.lang.String')
 D                                      STATIC
 D String1                         O   CLASS(*JAVA : 'java.lang.String')


  * variables
 D String2         S               O   CLASS(*JAVA : 'java.lang.String')
  ...

  /free
      envname = getBytes(String1);
      envnamelg = %len(%trim(envname)) ;


      getenv(env : envlg : envvallg :
             envname : envnamelg : APIERR)  //APi de QTMHCGI


      String2 = newString(env);
      return String2;
  /end-free
 PgetEnvVarO       E


 L'utilisation en JAVA est beaucoup plus simple (déclaration identique)


    native static String getEnvVarO (String envname );


    public static void main(String[] args)
    {
       String envvar = args[0] ;
       String retour = getEnvVarO(envvar) ;
       System.out.println("variable " + envvar + " =" + retour );
    }

contient les éléments placés par l'utilisateur
  (définitons de requête, ...)

•Onglet (affiche un menu)

Sorties Imprimantes

Imprimantes

Imprimantes Internet

Partages imrpimantes

Files d'attente en sortie

•Onglet

Affichage des messages

Envoi d'un message

Messages opérateur

Files d'attente messages

•Onglet

Travaux

Travaux de serveur

•Onglet

Sessions Actives

Sessions configurées

Liste des sessions configurées

Démarrage de session

Démarrage avec invite d'une session

• /iWA5250?sessname=xx démarre la session xx
• /iWA5250 démarre une session par défaut

•Onglet

Tables

Mes Demandes

Liste des demandes de transfert de fichier mémorisées :

Exécution d'instructions  SQL

Copie de données dans une table

Importation de demandes

•Onglet

Recherche de fichiers

partages de fichiers

•Onglet

Mes commandes

Exécution de commandes

Recherche

•Onglet

Préférences

Gestion des paramètres de l'utilisateur en cours

Profils utilisateurs

Paramètres par utilisateur

Profils de groupe

Paramètres par profil de groupe
  (*PUBLIC pour tout le monde)

Profil sélectionné

Paramètres d'un profil (à saisir)

•Onglet

Modification du mot de passe

Pool de connexion

Trace

A propos

Non répertoriés dans un menu

Valeurs système

/iWASysValList
/iWASysValGroupList

listes des valeurs système
Liste des valeurs système par catégorie

liste des produits

Informations sur un produit

PTF du produit

Infos sur une PTF

Test de Webaccess