Tuteur pour le langage REXX

Texte du Tuteur écrit par Gilles HUNAULT

Une liste des autres tuteurs (langages, logiciels, systèmes d'exploitations...) est accessible par Mosaic...


See also the official Rexx Page and the Regina page ...et le groupe de "news" associé

Table des Matières

Le langage Rexx

        - Introduction au langage
        - Exemple élémentaire de script
        - Fonctions en Rexx
        - Exemple de dialogue et d'appel de sous-programme
        - Tests et Boucles
        - Phrases et Mots, découpage et parsing(analyse syntaxique)
        - Fichiers et Tableaux
        - Divers

Une vingtaine d'exemples gradués

       - xmp01 : lire et écrire
       - xmp02 : lire et écrire plus sophistiqués
       - xmp03 : si alors sinon
       - xmp04 : structure de cas
       - xmp05 : boucles
       - xmp06 : tableaux
       - xmp07 : parse, essayer avec XMP7 une petite phrase pour REXX
       - xmp08 : appel de procédures
       - xmp09 : appel de programme, vérification de fichier
       - xmp10 : "Write a note to a disk file.  Add today's date and time."
       - xmp11 : bonjour, programme de démonstration
       - xmp12 : un dialogue
       - xmp13 : les 1111
       - xmp14 : gestion de répertoire
       - xmp15   le but du jeu 
       - xmp16      est de trouver ce que font 
       - xmp17          et comment on utilise 
       - xmp18             les fichiers xmp15 
       - xmp19                 à xmp19 

INTRODUCTION


    Le langage  REXX est  prévu pour  interfacer le  système
    d'exploitation (Dos, VM/SP etc.).  Une fois installé, il
    est transparent, c'est-à-dire qu'on lance les programmes
    Rexx comme des commandes Dos.

    Toute instruction non reconnue et toute instruction entre
    apostrophe  '  est passée à Dos.

    On délimite les instructions par un  ; . Les commentaires
    commencent par  /*  et finissent par  */  ; on ne distingue
    pas majuscule et minuscule.

    On ne déclare  pas les variables. Elles sont initialisées avec le
    nom de la variable en majuscule. Ainsi, i est initialisé à "I",
    NbCar à "NBCAR".

   Arg récupère les arguments passés à la commande, say afffiche
   à l'écran.

EXEMPLE 1


  Avec le programme DEMO.REX suivant    /* mon premier programme en Rexx */
                                           arg sdf
                                           say "C'est parti ! "
                                           'dir ' sdf '| more' 

  et la commande  :   demo *.tut

  on obtient comme affichage :    C'est parti !
                                  Répertoire de  D:\
                                  APL      TUT    11256   8-10-91   5:46p
                                  AWK      TUT    11150   8-12-91  11:10a
                                  DISP     TUT    19186   8-12-91   9:42a
                                  LISP     TUT    11863   8-10-91   5:45p
                                  REXX     TUT    10733   8-12-91  11:16a
                                  TUT      TUT    19227   8-12-91  11:05a
                                  C        TUT   178222   8-12-91  10:34a
                                  EXC      TUT    16611   8-12-91  10:43a
                                  8 Fichiers    894976 octets disponibles


 

Explications :

arg sdf avec demo *.tut met *.tut dans sdf 'dir ' sdf '|more' concatène dir et *.tut et |more la commande passée au dos est donc : dir *.tut | more

FONCTIONS


  Rexx dispose d'une  syntaxe concise  et de nombreuses  fonctions .
  Ainsi  words(x)  renvoie le nombre de mots de x et  word(c,n)  renvoie
  le nième mot de c.

  L'affectation se fait avec  =  ou par la puissante instruction  parse .
  Les boucles dérivent toutes de  do ... end . Les test se font avec
  if then [else]  ou avec  select when/then [otherwise] end .

  Un sous-programme se repère par le symbole de label  : .
  Call  appelle un sous-programme et  return  en ressort.
  Expose gère les paramètres "par adresse".

  Pull  est un résumé pour  parse upper pull  et lit au clavier avec
  conversion en majuscule . Parse pull  lit sans convertir.
  Call charout ,  écrit sans retour charriot, contrairement à  say .

  parse  lit plusieurs valeurs, peut découper une phrase en morceaux, etc.


EXEMPLE 2



   /* un programme élémentaire */

    say " Votre nom ? " ; pull Nom
    call charout , " et votre prénom ? "
    parse pull pren
    call finprog
    exit
    finprog: procedure expose nom  pren
      say " Au revoir, " Monsieur pren nom
    return


   affiche à l'exécution :

    Votre nom ?
    hunault
    et votre prénom ? gilles
    Au revoir,  MONSIEUR gilles HUNAULT

EXPLICATIONS DE L'EXEMPLE 2


   /* un programme élémentaire */
    say " Votre nom ? " ; pull Nom
                              écrit (say)                      Votre nom ?
                              passe à la ligne suivante
                              puis lit (pull) la réponse       hunault
                              et la traduit en majuscules : nom contient donc HUNAULT
    call charout , " et votre prénom ? "
                              écrit                            et votre prénom ?
                              sans passer à la ligne
    parse pull pren
                              lit au clavier sans traduire en majuscule : pren contient donc gilles
    call finprog
                              appelle le sous programme finprog

    finprog: procedure expose nom  pren
                              indique que nom et pren sont les variables précédentes
    say " Au revoir, " Monsieur pren nom
                              écrit        Au revoir
                              Monsieur n'existe pas ; la variable monsieur est donc
                              crée et initialisée avec MONSIEUR
                              écrit        Au revoir MONSIEUR gilles HUNAULT
    return
                              du sous programme rend la main au programme principal
    exit
                              termine le programme principal

TESTS ET BOUCLES


 /* Programme  de la Table de multiplication      */
    arg nbep . /* ne récupére que le premier argument */

 /* on efface l'écran sous DOS */
    'CLS'

 /* on écrit le titre centré sur 65 caractères et souligné par des - */
    say center('table de multiplication',65) ; say centre(copies('-',25),65)
     do 2 ; say ; end /* on saute deux lignes */

 /* s'il ny a pas de paramètre passé ou si le paramètre
    n'est pas de type numérique, entier et positif, on
    redemande un nombre */

  if  (nbep ="") | ^datatype(nbep,W)  then   do
    /* DEMANDE DU NOMBRE */
       call charout  , " Donner un nombre entier et positif "
       PULL nbep ;  do ; say ; say ; end
  end  /* du si */


     if nbep <= 0   /* TEST DE LA POSITIVITE SEULEMENT */
         then  say " Votre nombre n'est pas entier et positif"
         else  do /* Table de Multiplication */

          do Ifois = 1 to 10
           say nbep  " fois " right(' '||Ifois,2) " = " format(nbep*Ifois,4)
         end /* FIN_POUR Ifois DEUNA 10 */
     end /* test si NBEP est positif */

 La syntaxe de la boucle do est :   do i = . to . by . for . until . while .
 iterate reprend au début de do, leave quitte la boucle,
 exit quitte le programme. La fonction d2c() converit en caractères.

 Ainsi do j = 1 by 3 ; call charout , d2c(64+j) ;
          if j > 13 then j = j-3  ; else iterate ;
          j = j+1 ; if j > 20 then exit ; end

 affiche  ADGJMPQRSTUVW  ; j correspond en fait aux valeurs
    1  4  7  10  13  16  17  18  19  20  21  22  23

PHRASES ET MOTS


  On gère les phrases avec words(phr) et word(phr,i). Ainsi, à l'invite
  du programme

      say " donner une action étendue "  ; pull act
      say " donner une spécif étendue "  ; pull spe
      do i = 1 to words(act)
         word(act,i) word(spe,i)
      end

  si on tape     dir    del     (va dans act)
  puis           *.bat  *.bak   (va dans spe)

  les commandes dir *.bat et del *.bak seront exécutées.

  car, rappelons le, toute commande non comprise va à l'environnement,
  ici Dos.


  Arg et Parse découpent aussi les phrases, les arguments, les
  valeurs ; ainsi le programme

   phraz = "le petit chat / mange la souris"
   say phraz stop
   call proc1 phraz stop
   exit
     proc1 : procedure
     arg a . b
     say a
     say b
     return

  affiche à l'exécution

              le petit chat / mange la souris STOP
              LE                                         (a)
              CHAT / MANGE LA SOURIS STOP                (b)


  De même, le programme

   phraz = "le petit chat /"
   phraz = phraz "mange la souris"
   say phraz stop
   call proc2 phraz stop
   exit
     proc2 : procedure
     arg debut fin
     parse upper var debut deb1 deb2
     say debut
     say deb1
     say deb2
     say fin
     parse value fin"!" with dd "/" ff
     say dd
     say ff
     return
 affiche à l'exécution

 le petit chat / mange la souris STOP

 LE

 LE



 PETIT CHAT / MANGE LA SOURIS STOP

 PETIT CHAT

  MANGE LA SOURIS STOP!


   Enfin, signalons que Rexx sait aussi assurer un découpage
   classique des sous-chaines, avec parse ou avec index et
   substr. Ainsi le programme

   phraz = "le petit chat / mange la souris"
   say phraz stop
   say substr(phraz,1,7)
   say substr(phraz,index(phraz,"t "),6)
   call proc3 phraz stop
   exit
     proc3 : procedure
     parse arg fraz
     parse var fraz un 8 deux 15
     say un
     say deux
     return
affiche à l'exécution
  le peti
  t chat
  le peti
  t chat

FICHIERS ET TABLEAUX


 L'élément indice i du tableau T se note T.i ; i peut-être numérique
 ou caractère. On lit la ligne courante (disons L) du fichier F
 par L = linein(f) ; on ferme le fichier X par call lineout X. On écrit
 Z sur Y par call lineout Y , Z. La fin de fichier se teste par
 lines(). Dosdir(F) renvoie les informations sur F ou "" si le
 fichier n'est pas vu. Le programme :

 fn = 'Tst.Tmp' ;  cnt. = 0 ; nf = 0 ; nbe = 0 ; tail = 0
 do while lines(fn) ; lig = linein(fn) ; if lig <> "" then do
       parse var lig nom ext kO . ; if pos("-",lig) > 0 then do
       tail = tail + kO ;   nf = nf + 1 ;
       if cnt.ext = 0 then do ; cnt.ext = 1 ; nbe = nbe + 1 ;
 end ; end ; end ; end ; call lineout fn
 say  nf fichiers nbe extensions tail octets

 appliqué au fichier :   STATDIR  REX     2457   8-12-91   4:41p
                         ST       REX     1357   8-12-91   4:42p
                         TST      TMP       28   8-12-91   4:42p
                         3 Fichiers    776192 octets disponibles

 affiche :  3 FICHIERS 2 EXTENSIONS 3842 OCTETS

 

DIVERS

Rexx contient de nombreuses autres fonctionnalitésqui en font un très bon langage de commandes programmable et portable. Citons notamment la possibilité d'utiliser des piles et de queues dynamiques et l'arithmétique étendue (consulter le fichier 37).

Cliquez ici pour une vingtaine d'exemples gradués