jluc.lefloch - REXX - Ober

REXX: INSTRUCTIONS ET FONCTIONS

DROP
L'instruction DROP permet de désassigner une ou plusieurs variables.
Format : DROP var1 var2 var3 ...

Exemple :
A=3
SAY A ===> on obtient 3
DROP A
SAY A ===> on obtient A

NOTEZ LE
DROP A. désassigne la collection de variables dont, le radical est A.

VALUE
La fonction VALUE permet de récupérer le contenu d'une variable. Cette fonction est généralement utilisée pour faire une double substitution sur une variable qui contient le nom d'une autre variable.
Format : VALUE(var1)

Exemple :
VAR1 = "XYZ"
VAR2 = "VAR1"
SAY VALUE(VAR2) ===> on obtient XYZ

RC
La variable RC est une variable réservée utilisée pour le stockage du code retour des différentes instructions et commandes codées dans la procédure. Elle peut être testée au moyen de l'instruction IF.

Informations sur l'environnement

DATE

Cette fonction permet de récupérer des informations concernant la date sous différents formats.
Format : DATE([option])

Les options possibles sont les suivantes :
• Pas d'option : Récupération de la date sous la forme JJ mois AAAA ;
• Basic : Nombre de jours écoulés depuis le 1er janvier 0001 ;
• Century : Nombre de jours écoulés depuis le 1er janvier du siècle en cours ;
• Days : Nombre de jours écoulés depuis le début de l'année en cours ;
• European : Date sous la forme JJ/MM/AA ;
• Julian : Date sous la forme AAQQQ ;
• Month : Nom anglais du mois en cours ;
• Normal : Date sous la forme JJ mois AAAA ;
• Ordered Date sous la forme AA/MM/JJ ;
• Sorted : Date sous la forme AAAAMMJJ
• Usa : Date sous la forme MM/JJ/AA ;
• Weekday : Nom anglais du jour de la semaine en cours.

Exemples :
Imaginons que la date du jour soit le 2 août 1990, on obtiendra :

DATE() => 2 August 1990
DATE('B') => 726680
DATE('D') => 214
DATE('E') => 02/08/90
DATE('M') => August
DATE('N') => 2 Aug 1990
DATE('O') => 90/08/02
DATE('S') => 19900802
DATE('U') => 08/02/90
DATE('W') => Thursday

Depuis la version rexx livrée en standard avec l'os390 v2r5 la fonction date a évoluée.

Format :

Elle retourne par défaut, la date locale dans le format : dd mm yyyy (jour, le mois, année -- par exemple, 25 décembre 1996).

Sinon, l' "input_date" est converti au format spécifié par date_format1.
"date_format2" est spécifié pour définir le format d'input_date.
Le défaut pour date_format1 et le date_format2 est Normal.

Exemple :

Nous considérons que nous sommes le 13 mars 1992
DATE() -> '13 Mar 1992'
DATE(,'19960527','S') -> '27 May 1996'
DATE('B') -> '727269'
DATE('B','27 May 1996') -> '728805'
DATE('C') -> '33675'
DATE('E') -> '13/03/92'
DATE('J') -> '92073'
DATE('M') -> 'March'
DATE('N') -> '13 Mar 1992'
DATE('N','35488','C') -> '28 Feb 1997'
DATE('O') -> '92/03/13'
DATE('S') -> '19920313'
DATE('U') -> '03/13/92'
DATE('U','96/05/27','O') -> '05/27/96'
DATE('U','97059','J') -> '02/28/97'
DATE('W') -> 'Friday'

SYSVAR

Cette fonction permet de récupérer des informations sur MVS, TSO et la session en cours. Ces informations sont de quatre types :
1. Informations utilisateur ;
2. Informations terminal ;
3. Informations procédure ;
4. Informations système.

Format : SYSVAR(option)

Les options possibles sont les suivantes :

SYSPREF Préfixe défini dans la profile TSO de l'utilisateur
SYSPROC Nom de la procédure de logon utilisée pour la session en cours
SYSUID Identification de l'utilisateur connecté
SYSLTERM Nombre de lignes disponibles sur l'écran
SYSWTERM Nombre de colonnes disponibles sur l'écran
SYSENV Environnement d'exécution de la procédure (FORE : foreground, BACK : background)
SYSICMD Nom sous lequel la procédure a été appelée (chaîne nulle en cas d'appel explicite)
SYSISPF Etat d'ISPF (ACTIVE ou NOT ACTIVE)
SYSNEST Permet de savoir si la procédure a été appelée à partir d'une autre procédure ou d'un programme
(YES ou NO)
SYSPCMD Nom de la dernière commande TSO exécutée
SYSSCMD Nom de la dernière sous-commande TSO exécutée
SYSCPU Temps CPU écoulé depuis le début de la session sous la forme secondes.centièmes-de-secondes
SYSHSM Niveau du DFHSM en cours. Ne retourne rien si DFHSM est inactif ou non installé
SYSLRACF Niveau du RACF installé. Ne retourne rien si RACF n'est pas installé
SYSRACF Etat de RACF (AVÀILABLE, NOT AVAILABLE ou NOTINSTALLED)
SYSSRV Nombre d'unités de service SRM consommées depuis le début de la session
SYSTSOE Niveau du TSO installé

TIME

Cette fonction permet de récupérer des informations concernant l'heure sous différents formats.

Format : TIME([option])

Les options possibles sont les suivantes :
• pas d'option : Heure sous la forme HH:MM:SS ;
• Civil : Heure sous la forme HH:MMxx (xx pouvant prendre les valeurs AM ou PM) ;
• Elapsed : Temps écoulé depuis l'initialisation de l'horloge sous la forme secondes.microsecondes ;
• Hours ; Nombre d'heures écoulées depuis minuit.
• Long : Heure sous la forme HH:MM:SS.microsecondes. ;
• Minutes : Nombre de minutes écoulées depuis minuit ;
• Normal : Heure sous la forme HH:MM:SS. ;
• Reset : Temps écoulé depuis l'initialisation ou la réinitialisation de l'horloge sous la forme secondes.microsecondes. Repositionne aussi l'horloge à zéro.
• Seconds : Nombre de secondes écoulées, depuis minuit.

Exemples :
TIME() => 09:31:00
TIME('C') => 09:31am
TIME('H') => 09
TIME('L') => 09:31:00.123456
TIME('M') => 571
TIME('N') => 09:31:00
TIME('S') => 34260

USERID

Fonction non SAA. Cette fonction permet de récupérer l'identification de l'utilisateur TSO qui a demandé l'exécution de la procédure REXX.

Si la procédure s'exécute dans un espace adresses non TSO, la fonction retourne l'une des valeur suivantes :
• Userid de la carte job ;
• Nom d'étape ;
• Nom de job.

Format : USERID()

Le traitement conversationnel

On entent par traitement conversationnel, la possibilité d'afficher des informations à l'écran, de saisir des informations à l'écran et de récupérer des données saisies à l'écran.

Affichage de données à l'écran

SAY
Format : SAY expression
• Expression : Littéral ou variable. Un littéral doit être donné entre quotes. On peut combiner l'utilisation de littéraux et de variables.
Exemple :
JOUR DATE()
SAY "NOUS SOMMES LE:" JOUR

Interrogation à l'écran

PULL
Format : PULL var1 var2 ...
Cette instruction est une forme abrégée de l'instruction : PARSE UPPER PULL var1 var2 ...

Lorsque l'interpréteur rencontre cette instruction, il commence par lire le contenu du stack. Si le stack est vide, il se met en attente d'une entrée terminal. La ligne de stack ou la saisie utilisateur seront stockées en majuscules dans les variables nommées par l'instruction. Le délimiteur de dispatching est le blanc.

Pour respecter les majuscules et les minuscules utiliser l'instruction : PARSE PULL var1 var2...

Il est possible de remplacer une ou plusieurs variables par un point pour ignorer certains mots dans la ligne récupérée.

Exemples :

SAY "DONNER LE NOM DU FICHIER"
PULL FIC_ENT
On répond à l'écran : MON.FICHIER.SEQUENTIEL
FIC_ENT récupère MON.FICHIER.SEQUENTIEL

SAY "DONNER LES PARAMETRES"
PULL DAT TYPE
On répond à l'écran : 01042001 MENSUEL
DAT récupère 01042001
TYPE récupère MENSUEL

SAY "DONNER LES PARAMETRES"
PULL DAT
On répond à l'écran : 010401 MENSUEL
DAT récupère 010401 MENSUEL

SAY "DONNER LES:PARAMETRES"
PULL DAT.
On répond à l'écran : 010401 MENSUEL
DAT récupère 010401

Exemple à partir du terminal :

/* Données entrées au terminal REXX */
SAY 'Entrez votre prénom et votre nom :'
/* l'utilisateur entre Pierre ROBERT */

PULL prenom nom
/* prenom contient 'PIERRE' */
/* nom contient 'ROBERT' */
Exit

/* Données entrées au terminal REXX */
SAY 'Entrez votre prénom et votre nom :'
/* l'utilisateur entre Pierre ROBERT */

PARSE PULL prenom nom
/* prenom contient 'Pierre' */
/* nom contient 'ROBERT' */
Exit

Paramètrage d'une procédure

Il est possible de prévoir dans une procédure la récupération de paramètres passés à l'appel . Cette récupération se fait au moyen de l'instruction ARG.

ARG

Format : ARG var1 var2 ...

Les variables non renseignées sont initialisées avec une chaîne nulle.

Cette instruction est une forme abrégée de l'instruction : PARSE UPPER ARG var1 var2...

Les paramètres passés à l'appel sont stockés en majuscules dans les variables nommées dans l'instruction.

Pour respecter les majuscules et les minuscules utiliser l'instruction : PARSE ARG var1 var2 ...

Il est possible de remplacer une ou plusieurs variables par un point pour ignorer certains mots dans les paramètres récupérés.

Exemples :
/* REXX */
ARG DAT TYPE
Appel : %REXX01 020890 MENSUEL
DAT récupère 020890
TYPE récupère MENSUEL

Les opérateurs

Les opérateurs permettent de faire des évaluations sur des données. Ces données peuvent être des données numériques ou caractères, des variables ou des résultats de fonctions.

Il existe 3 types d'opérateurs :

1. Les opérateurs arithmétiques permettent d'effectuer des opérations sur des données numériques ;
2. Les opérateurs de comparaison permettent d'effectuer des comparaisons entre expressions.
3. Les expressions de comparaison retournent la valeur 1 si elles sont vraies ou la valeur 0 si elles sont fausses.
4. Les opérateurs logiques ; ou Booléens permettent d'effectuer des comparaisons logiques entre plusieurs conditions. Les opérateurs logiques combinent deux comparaisons et retournent les valeurs 1 ou 0 (vrai ou faux) en fonction du résultat de la .comparaison.

Tableau des opérateurs

Opération Fonction Symbole
Arithmétique Addition +
Soustraction -
Multiplication *
Division /
Résultat entier d'une division %
Reste d'une division //
Élévation à la puissance **
Nombre négatif -nombre
Nombre positif +nombre
Comparaison Strictement égal ==
Égal =
Pas srictement égal ¬== ou ^== ou /==
Pas égal ¬= ou ^= ou /=
Supérieur à >
Inférieur à <
Supérieur ou inférieur à ><
Supérieur ou égal à >=
Pas inférieur à ¬< ou ^< ou /<
Inférieur ou égal à <=
Pas supérieur à ¬> ou ^> ou />
Logique ET &
OU inclusif !
OU exclusif &&
NON logique ¬ ou ^ou /

Priorité des opérateurs
Les expressions sont évaluées de la gauche vers la droite.
1. Opérateurs préfixes (¬ +n -n) ;
2. Élévation à la puissance ;
3. Multiplication, division, résultat entier et reste de division ;
4. Addition, soustraction ;
5. Opérateurs de concaténation ;
6. Opérateurs de comparaison ;
7. ET logique ;
8. OU inclusif, OU exclusif.

Pour changer cet ordre, il suffit de coder entre parenthèses l'expression que l'on veut voir évaluée en priorité.
Exemples :

X = 10 + 4 * 2/4 --- > 12
x = (10+ 4) 2 / 4 --- > 7
X = (1 + 4) 2+ 4) 2 --- > 7
X = (1 + 4) * 2 + 4 /2 --- > 12

Fonctionnement des opérateurs logiques
Si l'on code les lignes suivantes,
expression 1 ! expression 2
expression 1 & expression 2
expression 1 && expression 2

on obtiendra les résultats suivants :

!
Expression 1 1 0 0 1
Expression 2 2 0 1 0
Résultat --> 0 1 1 1
&
Expression 1 1 0 0 1
Expression 2 2 0 1 0
Résultat --> 0 0 0 1
&&
Expression 1 1 0 0 1
Expression 2 2 0 1 0
Résultat --> 0 1 1 0

Les structures
DO FOREVER

Le DO FOREVER permet de créer une boucle infinie. La sortie de boucle peut être demandée par l'instruction LEAVE.

Format :
DO FOREVER
instruction
instruction
END

Exemple :
DO FOREVER
I = I + 1
SAY "ON BOUCLE"
IF I = 10 THEN LEAVE
END

DO itératif

Le DO itératif permet de contrôler les passages dans la boucle en faisant varier une variable d'une valeur source vers une valeur cible. Dès que la valeur cible est dépassée, on quitte la boucle.

Format :
DO DO I = n [TO n] [BY x] [FOR y]
instruction
instruction
END

• n : Valeur de départ ;
• n : Valeur cible ;
• x : Incrément facultatif (Défaut 1) ;
• y : Nombre maximum d'itérations.

Exemple :
DO I = 1 TO 10 BY 2
SAY "BOUCLE NUMERO" I
END

DO répétitif

Le DO répétitif permet de demander un certain nombre d'exécutions d'une série d'instructions. Lorsque ce nombre est atteint on quitte la boucle.

Format :
DO nombre
instruction
instruction
END

• Nombre : Nombre d'exécutions de la boucle.

Exemple :
DO 5
SAY "ON BOUCLE"
END

DO-UNTIL-END

Permet l'exécution répétitive d'une, suite d'instructions jusqu'à ce qu'une ou plusieurs conditions soient réalisées.

Format :
DO UNTIL expression
instruction
instruction
END

• Expression : Expression logique dont l'évaluation retourne les valeurs 0 ou 1.
• Il y a exécution des instructions codifiées dans la boucle jusqu'à ce que l'expression soit vraie.
• Dès que l'expression devient vraie, il y a poursuite en séquence derrière le END.
• Le test est fait en fin de boucle.
• La séquence est exécutée au moins une fois.

Traitement :

Exemple :
DO UNTIL REP = "OUI" ! REP "NON"
SAY "SUPPRESSION FICHIER (OUI ou NON)
PULL REP
END

DO-WHILE-END

Permet l'exécution répétitive d'une suite d'instructions tant qu'une ou plusieurs conditions sont réalisées.

Format :
DO WHILE expression
instruction
instruction
END

• Expression : Expression logique dont l'évaluation retoume les valeurs 0 ou 1. Tant que l'expression est vraie (1), il y a exécution des instructions codifiées dans la boucle.
• Dès que l'expression devient fausse (0), il y a poursuite en séquence derrière le END.
• Le test est fait en entrée de boucle. Si l'expression est fausse dès le début, la séquence n'est pas exécutée.

Traitement du DO-WHILE-END :

Exemple :
/* rexx : Boucle pour imprimer des fichiers */
say 'entrez un nom de fichier (ou ARRET pour terminer) :'
pull nom
do while nom¬='ARRET'
"PRINTDS DA("nom")"
say nom 'imprimé'
say 'entrez un autre nom:'
pull nom
end
say 'fini'

IF-THEN-ELSE

Cette séquence d'instructions est employée pour conditionner l'exécution d'autres instructions. Il est possible d'imbriquer les séquences IF-THEN-ELSE.

Format : expression THEN instruction [ELSE instruction]

• Expression : Expression logique dont l'évaluation retourne les valeurs 0 ou 1.
• Si l'expression est vraie (1) il y a exécution de l'instruction codifiée après THEN ;
• Si l'expression est fausse (0) il y a exécution de l'instruction codifiée après ELSE ou poursuite en séquence derrière le IF si ELSE est omis.
• Instruction : Instruction REXX, commande TSO, ordre ISPF, ordre macro éditeur.

On peut aussi utiliser l'instruction nulle NOP. Si l'action à effectuer nécessite plusieurs instructions, les encadrer par DO et END.

Traitement du IF-THEN-ELSE :

Exemple :

/* REXX et les tests */
IF temps = pluie THEN SAY 'Prends un bon livre'
ELSE DO
SAY 'Voulez-vous jouer au tennis
PULL reponse
END

/* REXX , les tests et le NOP (No Process) */
IF temps = beau THEN
DO
SAY 'Quelle belle journ‚e'
IF tenniscourt = libre THEN
SAY 'voulez-vous jouer.?'
ELSE NOP
END
ELSE SAY 'Prenez un parapluie'

ITERATE

L'instruction ITERATE permet de remonter prématurément en début de boucle.

Format : ITERATE [nom-boucle]

• Nom-boucle : Nom de la boucle dans laquelle on veut remonter. Ce paramètre ne peut être utilisé que dans le cas d'une imbrication de boucles itératives. On fournit le nom de la variable utilisée pour contrôler la boucle à reprendre. Par défaut, on reprend le niveau de boucle en cours.

Exemple :

DO I=1 TO10
SAY "BOUCLE 1"
DO J = 1 TO 10
IF 1 = 4 THEN ITERATE
SAY "BOUCLE 2"
END J
END I

LEAVE

L'instruction LEAVE permet de quitter prématurément une boucle.

Format : LEAVE [nom-boucle]
• Nom-boucle : Nom de la boucle à quitter. Ce paramètre ne peut être utilisé que dans le cas d'une imbrication de boucles itératives. On fournit le nom de la variable utilisée pour contrôler la boucle à quitter. Par défaut, on quitte le niveau de boucle en cours. La variable de contrôle garde la valeur en cours au moment du LEAVE.

Exemple :

DO I=1 TO10
SAY "BOUCLE 1"
DO J = 1 TO 10
SAY "BOUCLE 2"
IF J = 4 THEN LEAVE I
END
END

SELECT

Le SELECT permet de conditionner l'exécution d'une instruction dans une série de tests.

Lorsqu'une expression est vraie, il y a exécution de l'instruction correspondante puis sortie en séquence derrière le END.

Si aucune expression n'est vraie, il y a exécution de l'instruction codée dans OTHERWISE puis sortie en séquence derrière le END.

OTHERWISE n'est obligatoire qu'à partir du moment où il faut passer dedans.

Format :

SELECT
WHEN expression THEN instruction
WHEN expression THEN instruction

OTHERWISE instruction
END

Traitement :

Exemple 1 :
SELECT
WHEN MOIS=06 THEN MOIS JUIN
WHEN MOIS=08 THEN MOIS AOUT
OTHERWISE NOP
END

Exemple 2 :

/* rexx et select */
say 'entrez quatre nombres'
parse pull a b c d
select
when a>b & c>d then do
say 'a>b'
say 'c>d'
end
when a>b & c<d then do
say 'a>b'
say 'c <d'
end
when a<b & c>d then do
say 'a<b'
say 'c>d'
end
when a<b & c<d then do
say 'a<b'
say 'c<d'
end
otherwise
end

Résultat :

entrez quatre nombres
10 5 10 5
a>b
c>d

entrez quatre nombres
5 10 10 5
a<b
c>d

Traitement des chaînes alphanumériques

ABBREV

Cette fonction retourne la valeur 1 si la chaîne de caractères qu'elle teste est l'abréviation d'une chaîne de référence. Dans le cas contraire elle retourne la valeur 0.

Format : ABBREV(chaîne1,chaîne2[,longueur])
• Chaîne : Chaîne de caractères de référence ;
• Chaîne2 : Chaîne de caractères à tester ;
• Longueur : Longueur minimum que doit avoir chaîne2 pour satisfaire au test. Par défaut le test est fait sur la longueur réelle de chaîne2.

Exemple :
ABBREV("INFORMATION","INFO") --> 1
ABBREV("INFORMATION","INFO",4) --> 1
ABBREV("INFORMATION","INFO",3) --> 1
ABBREV("INFORMATION","INFO",5) --> 0
La fonction retourne la valeur 1 si chaîne2 est égale au début de chaîne1 et si la longueur de chaîne2 est supérieure ou égale à la longueur spécifiée dans l'argument.

CENTER

Cette fonction permet de centrer une chaîne de caractères sur une certaine longueur avec ou sans complémentation.

Format : CENTER(chaîne,longueur[,caractère])

• Chaîne : Chaîne de caractères à centrer ;
• Longueur :Longueur sur laquelle doit se faire le centrage. Si la chaîne de caractères est supérieure à la longueur indiquée, elle est tronquée aux deux extrémités.
• Caractère : Caractère de complémentation. Blanc par défaut.

Exemple :
CENTER("ABC",7) --> ' ABC '
CENTER("ABC",7,"-") --> '--ABC--'
CENTER("ABCDEFG",3) --> 'CDE'

COMPARE

Elle retourne la valeur 0 si les deux chaînes sont identiques. Si elles ne sont pas identiques, la valeur retournée est la position du premier caractère qui diffère quelle que soit la chaîne dans laquelle il est trouvé. La chaîne la plus courte est complémentée à droite si nécessaire.

Format : COMPARE(chaîne1,chaîne2[,caractère])
• Caractère : Caractère de complémentation. Blanc par défaut.

Exemple :
COMPARE("ABC","ABC") ---> 0
COMPARE("ABC","AK") ---> 2
COMPARE("AB-- ","AB","-") ---> 5

COPIES

Cette fonction permet de concaténer plusieurs exemplaires d'une chaîne de caractères.

Format : COPIES(chaîne,nombre)
• Chaîne : Chaîne de caractères à traiter ;
• Nombre : Nombre de concaténations à effectuer.

Exemple :
COPIES("ABC",3) --> ABCABCABC
COPIES("ABC",0) --> ""

DATATYPE

Cette fonction permet de connaître la nature d'une chaîne de caractères.
Format : DATATYPE(chaîne[,type])
• Chaîne : Chaîne de caractères à traiter ;
• Type : Type de test à réaliser. Si ce paramètre n'est pas fourni la fonction retourne les valeurs : NUM (chaîne numérique) ou CHAR (chaîne non numérique). Les valeurs possibles pour ce paramètre sont :
• Alphanumeric : retourne la valeur 1 si la chaîne ne contient que des caractères alphanumériques (a-z, A-Z, 0-9).
• Bits : Retourne la valeur 1 si la chaîne ne contient que des caractères binaires (0 ou 1).
• Lowercase (L) : Retourne la valeur 1 si la chaîne ne contient que des caractères minuscules.
• Mixed case (M) : Retourne la valeur 1 si la chaîne ne contient que des caractères majuscules ou minuscules.
• Number (N) : Retourne la valeur 1 si la chaîne ne contient que des caractères numériques.
• Symbol (S) : Retourne la valeur 1 si la chaîne ne contient que des symboles REXX (a-z, A-Z, 0-9, @ # $ . ! ? _).
• Uppercase (U) : Retourne la valeur 1 si la chaîne ne contient que des caractères majuscules.
• Whole number : Retourne la valeur 1 si la chaîne contient un nombre entier.
• Hexadecimal : Retourne la valeur 1 si la chaîne ne contient que des caractères hexadécimaux (a-f, A-F, 0-9).

Exemple :
DATATYPE("12") ---> NUM
DATATYPE("ABC") ---> CHAR
DATATYPE("12.3","N") ---> 1
DATATYPE("FRED","L") ---> 0
DATATYPE("Fred","M") ---> 1

DELSTR

Cette fonction permet de supprimer des caractères à l'intérieur d'une chaîne de caractères.
Format : : DELSTR(chaîne,pos,[longueur])
• Chaîne : Chaîne de caractères à traiter ;
• Pos : Position à partir de laquelle la suppression doit être faite. Si cette valeur est supérieure au nombre de caractères contenus dans chaîne, la chaîne n'est pas traitée.
• Longueur : Nombre de caractères à supprimer. Par défaut : suppression de la fin de la chaîne.

Exemple :
DELSTR("abcd",3) --> ab
DELSTR("abcde",3,2) --> abe

DELWORD

Cette fonction permet de supprimer des mots dans une chaîne de caractères.
Format : DELWORD(chaîne,pos,[longueur])
• Chaîne : Chaîne de caractères à traiter ;
• Pos : Position du premier mot à supprimer. Si cette valeur est supérieure au nombre de mots contenus dans chaîne, la chaîne n'est pas traitée.
• Longueur : Nombre de mots à supprimer. Par défaut : suppression de la fin de la chaîne.

Exemple :
DELWORD("ab cd ef",2) --> ab
DELWORD("ab cd ef",2,1) --> ab ef
DELWORD("ab cd ef",4) --> ab cd ef

FIND

Fonction non SAA. Il est préférable d'utiliser WORDPOS.
Cette fonction permet de rechercher une chaîne de mots dans une phrase. Retourne la position de la première occurrence trouvée. Retourne 0 si la chaîne de mots n'existe pas dans la phrase.
Format : FIND(phrase,chaîne)
• Phrase : Phrase dans laquelle la recherche doit être faite ;
• Chaîne : Chaîne de mots à rechercher.

Exemple :
FIND("ab cd ef","cd ef") --> 2
FIND("ab cd ef","ab ef") --> 0

INDEX

Cette fonction permet de récupérer la position d'une chaîne de caractères dans une autre. Si la chaîne à rechercher n'existe pas, la fonction retourne la valeur 0. (Fonction non SAA. Il est préférable d'utiliser POS).
Format : INDEX(chaîne1,chaîne2[,début])
• Chaîne1 : Chaîne de caractères dans laquelle doit se faire la recherche ;
• Chaîne2 : Chaîne de caractères à rechercher ;
• Début : Position de départ pour la recherche dans chaîne1 (1er caractère de chaîne1 par défaut).
Exemple :
INDEX("abcdef","cd") --> 3
INDEX("abcdef","xg") --> 0
INDEX("abcdef","cd",5) --> 0

INSERT

Cette fonction permet d'insérer une chaîne de caractères dans une autre.
Format : INSERT(,chaîne1,chaîne2[,pos[,longueur][,caractère])
• Chaîne1 : Chaîne de caractères à insérer ;
• chaîne2 : Chaîne de caractères dans laquelle doit se faire l'insertion ;
• Pos : Position dans chaîne2 après laquelle doit se faire l'insertion. Si la valeur de pos est supérieure à la longueur de la chaîne cible, celle-ci est complémentée en conséquence. La valeur par défaut de pos est 0 qui signifie insertion avant le premier caractère de chaîne2.
• Longueur : La chaîne de caractères à insérer doit être complémentée pour atteindre la longueur indiquée dans ce paramètre.
• Caractère : Caractère à utiliser pour les complémentations. Blanc par défaut.
Exemple :
INSERT(" ","abcdef",3) --> abc def
INSERT("123","abc",5,6,"+") --> abc++123+++
INSERT("123","abc",,5,"-") --> 123--abc

JUSTIFY

Fonction non SAA. Cette fonction permet de gérer l'insertion de caractères de complémentation entre les mots d'une chaîne de caractères de façon à aligner celle-ci sur une longueur précise.
Format : JUSTIFY(chaîne,longueur[,caractère])
• Chaîne : Chaîne de caractères à traiter ;
• Longueur : Longueur à utiliser pour l'alignement ;
• Caractère : Caràctère de complémentation à utiliser. Blanc par défaut

Exemple :
JUSTIFY("abcd",7,"-") --> abcd
JUSTIFY("ab cd",7,"-") --> ab---cd

LASTPOS

Cette fonction permet de récupérer la position de la dernière occurrence d'une chaîne de caractères dans une autre.
Si la chaîne recherchée n'existe pas, la fonction retourne la valeur 0. La chaîne de référence est manipulée de la droite vers la gauche.

Format : LASTPOS(chaîne1,chaîne2[,début])
• Chaîne1 : Chaîne de caractères à rechercher ;
• Chaîne2 : Chaîne de caractères dans laquelle doit se faire la recherche ;
• Début : Position dans la chaîne de référence à partir de laquelle doit se faire la recherche. La chaîne recherchée doit se terminer au plus à la position spécifiée.
Exemple :
LASTPOS(" ","ab cd ef") --> 6
LASTPOS(" ","ab cd ef",5) --> 3

LEFT

Cette fonction permet de cadrer une chaîne de caractères à gauche, sur une certaine longueur, avec troncation ou complémentation à droite.

Format : LEFT(chaîne,longueur[,caractère])
• Chaîne : Chaîne de caractères à traiter ;
• Longueur : Longueur de la chaîne de caractères après traitement ;
• Caractère : Caractère de complémentation à utiliser. Blanc par défaut.
Exemple :
LEFT("abc d",8,".") ---> abc d...
LEFT("abcdefghij",7) ---> abcdefg

LENGTH

Cette fonction permet de récupérer la longueur d'une chaîne de caractères.
Format : LENGTH(chaîne)
• Chaîne : Chaîne de caractères à traiter.
Exemple :
LENGTH("abc d") ---> 5
LENGTH("") ---> 0

OVERLAY

Cette fonction permet de remplacer des caractères dans une chaîne de référence.
Format : OVERLAY(chaîne1,chaîne2[,pos[ longueur][,caractère]])
• Chaîne1 : Chaîne de caractères à utiliser pour le remplacement ;
• Chaîne2 : Chaîne de caractères dans laquelle doit se faire le remplacement ;
• pos : Position de chaîne2 à partir de laquelle le remplacement doit être fait (1er caractère par défaut).
• Longueur : Longueur sur laquelle doit se faire le remplacement.
• Caractère : Caractère de remplacement à utiliser (blanc par défaut).
Exemple :
OVERLAY(" ","abcdef",3) --> ab def
OVERLAY("123","abc",5,6,"+") --> abc+123+++
OVERLAY(".","abcdef",3,2) --> ab. ef

PARSE VALUE

Cette instruction permet de dispatcher une expression dans une ou plusieurs variables. L'expression est d'abord évaluée puis le résultat est traité par PARSE VALUE.
L'expression peut être un littéral, une fonction ou une variable.
Format : PARSE VALUE expression WITH structure-de-réception
• Expression : Littéral ou fonction ;
• Structure-de-réception : Cette structure peut être composée d'une combinaison des éléments suivants :
• Des variables réceptrices ;
• Des caractères délimiteurs ;
• Des pointeurs numériques permettant de se positionner dans le contenu de l'expression.
• Des points permettant d'ignorer une partie du contenu de l'expression.
Exemple :
PARSE VALUE TIME() WITH HH ":" MM ":' SS

PARSE VAR

Cette instruction permet de dispatcher le contenu d'une variable dans une ou plusieurs autres variables.
Format : PARSE VAR variable structure-de-réception
• Variable : Variable à traiter ;
• Structure-de-réception : Cette structure peut être composée d'une combinaison des éléments suivants :
• Des variables réceptrices ;
• Des caractères délimiteurs ;
• Des pointeurs numériques permettant de se positionner dans le contenu de la variable ;
• Des points permettant d'ignorer une partie du contenu de la variable.

Exemple :
VAR1="AB CD/EF.GH"
PARSE VAR VAR1 X Y --> X=AB et Y=CD/EF.GH
PARSE VAR VAR1 . X "/"Y"." Z --> X=,CD, Y=EF et Z=GH
PARSE VAR VAR1 X "/" +0 Y --> X=AB CD et Y=/EF.GH

POS

Cette fonction permet de récupérer la position d'une chaîne de caractères dans une autre. Si la chaîne recherchée n'existe pas, la fonction retourne la valeur 0. La chaîne de référence est manipulée de la gauche vers la droite.
Format : POS(chaîne1,chaîne2[,début])
• Chaîne1 : Chaîne de caractères à rechercher ;
• Chaîne2 : Chaîne de caractères dans laquelle doit se faire la recherche.
• Début : Position dans la chaîne de référence à partir de laquelle doit se faire la recherche. C'est une position par rapport au début de la chaîne (1er caractère par défaut).

Exemple :
POS(" ","ab cd ef") ---> 3
POS(" ","ab cd ef",5) ---> 6

REVERSE

Cette fonction permet d'inverser les caractères d'une chaîne.
Format : REVERSE(chaîne)
• Chaîne : Chaîne de caractères à traiter.

Exemple :
REVERSE("abcd") ---> dcba
REVERSE("ABc.") ---> .cBA

RIGHT

Cette fonction permet de cadrer une chaîne de caractères à droite, sur une certaine longueur, avec troncation ou complémentation à gauche.
Format : RIGHT(chaîne,longueur[,caractère])
• Chaîne : Chaîine de caractères à traiter ;
• Longueur : Longueur de la chaîne de caractères après traitement ;
• Caractère : Caractère de complémentation à utiliser. Blanc par défaut.

Exemple :
RIGHT("abc d",8,".") ---> ...abc d
RIGHT("abcdefghij",7) ---> defghij

SPACE

Cette fonction permet de gérer l'insertion de caractères de complémentation entre les mots d'une chaîne de caractères.
Format : SPACE(chaîne,n[,caractère])
• Chaîne : Chaîne de caractères à traiter ;
• n : nombre de caractères de complémentation à insérer entre les mots (par défaut 1). Si n = 0, il y a suppression de tous les blancs entre les mots.
• Caractère : Caractère de complémentation à utiliser. Blanc par défaut.

Exemple :
SPACE("abc def",1) ---> abc def
SPACE("abc def",0) ---> abcdef
SPACE("abc def",3,"+") ---> abc+++def

STRIP

Cette fonction permet de supprimer les caractères de début ou de fin dans une chaîne.
Format : STRIP(chaîne,[option[,caractère]])
• Chaîne : Chaîne de caractères à traiter ;
• Option : Option de suppression. les options possibles sont les suivantes :
• Both : Suppression en tête et en fin de chaîne (Défaut) ;
• Leading : Suppression en tête de chaîne ;
• Trailing : Suppression en fin de chaîne.
• Caractère : Caractère à supprimer (blanc par défaut).

Exemple :
STRIP(" ab cd ") --> "ab cd"
STRIP(+++ab cd ",L,"+") --> "ab cd "

SUBSTR

Cette fonction permet d'extraire des caractères dans une chaîne, sur une certaine longueur, avec possibilité de complémentation.
Format : SUBSTR(chaîne,pos[,longueur][,caractère])
• Chaîne : Chaîne de caractères à traiter ;
• Pos : Position à partir de laquelle doit se faire l'extraction ;
• Longueur : Nombre,de caractères à extraire. Si ce nombre est supérieur à la longueur de la chaîne, il y a extraction de la fin de la chaîne et complémentation de la chaîne résultante.
• Caractère : Caractère de complémentation à utiliser.

Exemple :
SUBSTR("abc",2) ---> bc
SUBSTR("abc",2,6,"+") ---> bc++++

SUBWORD

Cette fonction permet d'extraire des mots dans une chaîne de caractères.
Format : SUBWORD(chaîne,pos[,Iongueurl)
• Chaîne : Chaîne de caractères à traiter ;
• Pos : Position à partir de laquelle doit se faire l'extraction ;
• Longueur : Nombre de mots à extraire. Si ce nombre est supérieur au nombre de mots contenus dans la chaîne, la fonction retourne une chaîne nulle. Si il est omis, la fonction extrait la fin de la chaîne.
Exemple :
SUBWORD("ab cd ef gh",2,2) ---> cd ef

TRANSLATE

Cette fonction permet de remplacer des caractères dans une chaîne. Elle permet aussi de réorganiser une chaîne de caractères.
Format : TRANSLATE(chaîne[,table-o[,table-i][,caractère]])
• Chaîne : Chaîne de caractères à traiter ;
• table-o : Table contenant les caractères de remplacement ;
• table-i : Table contenant les caractères de 'chaîne' à remplacer ;
• Caractère : Caractère de remplacement à utiliser par défaut. Ce caractère est utilisé lorsque le contenu de table-o est inférieur au contenu de table-i.
• Si le contenu de table-o est supérieur au contenu de table-i il est tronqué à droite.
Exemple :
TRANSLATE("abbc","$","b") ---> a$$c
TRANSLATE("abcdef","12","ec") ---> ab2d1f
TRANSLATE("abcdef","12","abcd","+") ---> 12++ef

VERIFY

Cette fonction permet de vérifier q'une chaîne de caractères est constituée uniquement de caractères appartenant à une chaîne de référence. Si tous les caractères correspondent, la fonction retourne la valeur 0. Dans la cas contraire, la fonction retourne la position du 1er caractère qui ne correspond pas.
Format : VERIFY(chaîne,référence[,[option][,début]])
• Chaîne : Chaîne de caractères à traiter ;
• Référence : Chaîne contenant les caractères de référence ;
• Option : Option de traitement :
• Nomatch : La fonction retourne la position du premier caractère de chaîne qui ne figure pas dans la référence (défaut).
• Match (M) : La fonction retourne la position du premier caractère de chaîne qui figure dans la référence.
• Début : Point de départ pour la recherche dans chaîne (Premier caractère par défaut).

Exemple :
VERIFY("abcdef","fedcba") ---> 0
VERIFY("abcdxy","fedcba") ---> 5
VERI]FY("abcdef","fedcba","M") ---> 1

WORD

Cette fonction permet d'extraire un mot dans une chaîne de caractères. Elle équivaut à la fonction SUBWORD(chaîne,n,1).
Format : WORD(chaîne,pos)
• Chaîne : Chaîne de caractères à traiter ;
• Pos : Position du mot à extraire dans chaîne. Si la valeur de ce paramètre est supérieure au nombre de mots contenus dans chaîine, la fonction retourne un résultat nul.
Exemple :
WORD("ab cd ef gh",3) --> ef
WORD("ab cd ef gh",5) --> ""

WORDINDEX

Cette fonction permet de récupérer la position du premier caractère d'un mot dans une chaîne.
Format : WORDINDEX(chaîne,pos)
• Chaîne : Chaîne de caractères à traiter ;
• Pos : Rang dans la chaîne du mot dont on veut récupérer la position du premier caractère. Si la valeur de ce paramètre est supérieure au nombre de mots contenus dans chaîne la fonction retourne la valeur 0.
Exemple :
WORDINDEX("ab cd ef gh",3) ---> 7
WORDINDEX("ab cd ef gh",5) ---> 0

WORDLENGTH

Cette fonction permet de récupérer la longueur d'un mot dans une chaîne.
Format : WORDLENGTH(chaîne,pos)
• Chaîne : Chaîne de caractères à traiter ;
• Pos : Position du mot dans la chaîne. Si la valeur de ce paramètre est supérieure au nombre de mots contenus dans la chaîne, la fonction retourne la valeur 0.

Exemple :
WORDLENGTH(" ab cd efgh",3) ---> 4
WORDLENGTH("ab cd efgh",5) ---> 0

WORDPOS

Cette fonction permet de rechercher la position d'un mot dans une chaîne.
Format : WORDPOS(chaîne1,chaîne2[,début])
• chaîne1 : Mot à rechercher. Si il n'existe pas, la fonction retourne la valeur 0.
• chaîne2 : Chaîne dans laquelle doit se faire la recherche ;
• Début : Point de départ de la recherche.

Exemple :
WORDPOS("ab","ab cd ef ab") ---> 1
WORDPOS("ab","ab cd ef ab",3) ---> 4

WORDS

Cette fonction permet de récupérer le nombre de mots contenus dans une chaîne.
Format : WORDS(chaîne)
• Chaîne : Chaîne de caractères à traiter.

Exemple :
WORDS("ab cd ef ab") ---> 4
WORDS(" ") ---> 0

XRANGE

Cette fonction permet de récupérer une chaîne de caractères compris entre deux extrêmes.
Format : XRANGE([début][,fin])
• Début : Caractère de début de liste (X'00'par défaut).
• Fin : Caractère de fin de liste (X'FF' par défaut).

Exemple :
XRANGE("a","f") ---> abcdef
XRANGE("i","j") ---> X'898A8B8C8D8E8F9091'

Traitement des chaînes numériques

ABS

Cette fonction permet de récupérer la valeur absolue d'un nombre. Le résultat n'est pas signé et est formaté en fonction de la précision en cours.
Format : ABS(nombre)
• Nombre : Nombre à traiter.

Exemple :
ABS(" 12.3") ---> "12.3"
ABS(" -0.307" ---> "0.307"

DIGITS

Cette fonction perrnet de récupérer la précision numérique en cours.
Format : DIGITS()

Exemple :
DIGITS() --> 9

FORM

Cette fonction permet de récupérer le type de notation exponentielle en cours.
Format : FORM()

Exemple :
FORM() --> SCIENTIFIC

FORMAT

Cette fonction permet d'arrondir et de formater un nombre.
Format : FORMAT(nombre[,avant[,après]])
• Nombre : Nombre à formatter. Si on ne donne pas d'autres paramètres, le nombre est soumis aux règles de formattage standard de REXX (<==>
• opération "nombre + 0").
• Avant : Permet de donner le nombre de caractères à utiliser pour la partie entière du nombre. Si cette valeur n'est pas suffisante pour contenir la partie entière réelle du nombre, elle provoque une erreur.
• Après : Permet de donner le nombre de caractères à utiliser pour la partie décimale du nombre. Si cette valeur ne correspond pas à la réalité, la partie décimale du nombre est ajustée par troncation ou complémentation à 0. Si cette valeur est nulle, le nombre est arrondi à sa partie entière.

Exemple :
Format :("3",4) --> " 3"
Format :("1.73",4,0) --> " 2"'
Format :("1.73",4,3) --> " 1.730"
Format :("0.000") --> "0"

MAX

Cette fonction permet de récupérer le plus grand nombre d'une liste de nombres. On peut spécifier jusqu'à 20 nombres. Au-delà de cette valeur, il faut imbriquer les fonctions. Les nombres peuvent être des variables, des constantes numériques, des expressions arithmétiques, des fonctions arithmétiques.
Format : MAX(nombre1,[,nombre2,nombre3,...])

Exemple :
MAX(12,6,7,9) --> 12
MAX(-7,-3,-4.3) --> -3
MAX(1,2,3,4,5,6,7,8,9,MAX(10,11,12,13,14,15)) --> 15

MIN

Cette fonction permet, de; récupérer le plus petit nombre d'une liste de nombres. On peut spécifier jusqu'à 20 nombres. Au-delà de cette valeur, il faut imbriquer les fonctions MIN. Les nombres peuvent être des variables, des constantes numériques, des expressions arithmétiques, des fonctions arithmétiques.

Format : MIN(nombre1[,nombre2,nombre3,...]

Exemple :
MIN(12,6,7,9) --> 6
MIN(-7,-3,-4.3) --> -7
MIN(1,2,3,4,5,6,7,8,9,MIN(10,11,12,13,14,15)) --> 1

NUMERIC

Cette instruction permet de contrôler le format du résultat des opérations arithmétiques.

Format :
NUMERIC [DIGITS,[expression]]
[FORM [SCIENTIFIC / ENGINEERING]]
[FUZZ [expression]]

• DIGITS : Permet de contrôler la précision des résultats d'opérations arithmétiques.
• "expression" est un nombre positif indiquant le nombre de positions numériques à utiliser pour le résultat (9 par défaut). En dehors de la taille mémoire disponible, il n'y a pas de limite à la valeur de "expression". Il faut toutefois noter qu'une précision trop élevée coûte très cher en temps CPU.
• FORM : Permet de contrôler la forme de notation exponentielle utilisée par REXX pour le résultat d'opérations arithmétiques :
• SCIENTIFIC : Un seul chiffre différent de 0 apparaît avant le point décimal (Format : pris par défaut).
• ENGINEERING : La puissance de 10 est toujours un multiple de 3. Le nombre de chiffres, avant le point décimal est variable.
• FUZZ : Permet de réduire la précision des nombres lors des comparaisons.

SIGN

Cette fonction permet de récupérer une valeur indiquant le signe d'un nombre.
• Si le nombre est négatif la fonction retourne la valeur -1 ;
• Si le nombre est nul la fonction retourne la valeur 0 ;
• Si le nombre est positif la fonction retourne la valeur 1 ;
• Le nombre peut être une constante numérique, le contenu d'une variable, le résultat d'une expression ou d'une fonction arithmétique.

Format : SIGN(nombre)

Exemple :
SIGN("12.3") --> 1
SIGN("-0.307") --> -1
SIGN("0.000") --> 0

TRUNC

Cette fonction permet de gérer le nombre de décimales d'un nombre. Le nombre n'est jamais arrondi.

Format : TRUNC(nombre[,n])
• Nombre : Nombre à traiter ;
• N : Nombre de décimales à affecter au nombre.
• Si n est inférieur à la réalité, la partie décimale est tronquée ;
• Si n est supérieur à la réalité, la partie décimale est complétée à 0 ;
• Si n est nul, la fonction retourne la partie entière du nombre. 0 est la valeur par défaut de n.

Exemple :
TRUNC(12.3) --> 12
TRUNC(12.09782,3) --> 12.097
TRUNC(12,3) --> 12.000

Gestion du stack

Introduction

Le terme "stack" désigne des structures extensibles utilisées pour stocker temporairement des données. Ces structures sont en mémoires.

Il existe 2 types de structures de données : les "piles" et les "files". La différence entre ces 2 types de structures réside dans la façon dont les données y sont stockées et lues :

• Les "piles" sont traitées selon la technique LIFO (Last In First Out). Les éléments stockés les derniers sont relus les premiers.
• Les "files" sont traitées selon la technique FIFO (First In First Out). Les éléments stockés les premiers sont relus les premiers.

Les stacks de données REXX sont une combinaison de "Piles" et de "files". Ils peuvent être remplis parle haut ou par le bas. La lecture se fait toujours par le haut.

Le stack peut être manipulé par :

• Des instructions REXX ;
• Des fonctions REXX ;
• Des commandes TSO REXX.

DELSTACK

Cette commande permet de supprimer le stack le plus récent ainsi que les éléments qu'il contient. Si aucun stack privé n'a été créé, la commande supprime tous les éléments du stack d'origine.

Format : DELSTACK

DROPBUF

Cette commande permet de supprimer un ou plusieurs buffers créés par MAKEBUF ainsi que tous les éléments qu'ils contiennent. Par défaut c'est le dernier buffer créé qui est supprimé.

Format : DROPBUF [numéro]
• Numéro : Numéro du buffer à partir duquel la suppression doit se faire. Seront supprimés le buffer portant le numéro spécifié ainsi que tous les buffers créés après lui dans le stack en cours.

Codes retour :
• 0 : Fin normale;
• 1 : Numéro de buffer invalide ;
• 2 : Numéro de buffer non trouvé dans le stack.

MAKEBUF

Cette commande permet de créer un nouveau buffer dans un stack (à l'origine un stack contient un buffer qui porte le numéro 0).
Les données traitées par QUEUE, PUSH ou PULL sont placées et lues dans le nouveau buffer. Lorsque celui-ci est vide le traitement se poursuit avec le buffer précédent. Il est possible de supprimer le buffer en cours par la commande DROPBUF.
La commande MAKEBUF positionne la variable RC avec le numéro du buffer queue ouvre.

Format : MAKEBUF

NEWSTACK

Cette commande permet de créer un stack privé complètement indépendant du stack d'origine. Les éléments du stack d'origine ne peuvent plus être accédés par la procédure REYX ou par les routines qu'elle appelle jusqu'à émission d'une commande DELSTACK.
Les données traitées par QUEUE, PUSH ou PULL sont placées et lues dans le nouveau stack. Lorsque celui-ci est vide, les demandes d'informations sont faites au terminal.
Format : NEWSTACK

PARSE EXTERNAL

Cette instruction permet de forcer une lecture de données au terminal même si le stack est plein.
Format : PARSE EXTERNAL structure-de-réception
• Structure-de-réception : Cette structure peut être composée d'une combinaison des éléments suivants :
• Des variables réceptrices ;
• Des caractères délimiteurs ;
• Des pointeurs numériques permettant de se positionner dans le contenu de la ligne lue ;
• Des points permettant d'ignorer une partie du contenu de la ligne lue.

PULL

Cette instruction permet de lire le contenu du stack. Si le stack est vide, la lecture de données est faite au terminal. Si on souhaite une entrée terminal sans lecture du stack il faut utiliser l'instruction PARSE EXTERNAL.

NOTEZ LE

Les commandes TSO interactives (ALLOC, XMIT,...) lisent aussi le stack avant de demander leurs paramètres au terminal.

Voir "TRAITEMENT CONVERSATIONNEL".

PUSH

Cette instruction permet de stocker des données dans le stack de façon à ce que la relecture se fasse dans l'ordre LIFO.
Format : PUSH [expression]
expression Expression dont l'évaluation est stockée
dans le stack. Si on ne donne pas d'expression, il y a stockage d'une ligne nulle. La longueur d'un élément stocké dans le stack ne peut pas excéder 16 MEG.
Exemple :
x = "LIGNE"
PUSH X 1 --> stockage de "LIGNE 1"
PUSH --> stockage d'une ligne nulle
PUSH TIME() --> stockage de l'heure

QBUF

Cette commande permet de récupérer le nombre de buffers créés dans le stack par MAKEBUF. Ce nombre est positionné dans la variable RC. Si la commande MAKEBUF n'a pas été émise, QBUF positionne la variable RC à 0 (valeur correspondant au buffer 0 du stack).
Format : QBUF

QSTACK

Cette commande permet de connaître le nombre de stacks en cours. Ce nombre est stocké dans la variable RC. Il est égal au nombre de stacks créés par NEWSTACK plus le stack d'origine. Si aucun stack privé n'a été créé, la variable RC est positionnée à la valeur 1 (correspondant au stack d'origine).
Format : QSTACK

QELEM

Cette commande permet de récupérer le nombre d'éléments stockés dans le dernier buffer créé par MAKEBUF. Ce nombre est positionné dans la variable RC. Si ce buffer est vide ou si la commande MAKEBUF n'a jamais été émise la variable RC est positionnée à la valeur 0.
Format : QELEM

NOTEZ LE

Ne pas confondre QELEM avec la fonction QUEUED() qui retourne le nombre d'éléments stockés dans le stack en cours tous buffers confondus.

QUEUE

Cette instruction permet de stocker des données dans le stack de façon à ce que la relecture se fasse dans l'ordre FIFO.
Format : QUEUE [expression]
Expression : Expression dont l'évaluation est stockée dans le stack. Si on ne donne pas d'expression, il y a stockage d'une ligne nulle. La longueur d'un élément stocké dans le stack ne peut pas excéder 16 MEG.
Exemple :
X = "LIGNE"
QUEUE X 1 --> stockage de "LIGNE 1"
QUEUE --> stockage d'une ligne nulle
QUEUE TIME() --> stockage de l'heure

QUEUED

Cette fonction permet de récupérer le nombre de lignes encore stockées dans le stack en cours au moment de son appel.
Format : QUEUED(fonction intégrée)

Gestion des fichiers

Il est possible, dans une procédure REXX, de manipuler des fichiers séquentiels ou partitionnés au moyen de la commande EXECIO.

Cette commande permet la lecture, l'écriture ou la mise à jour.

Les fichiers à manipuler doivent avoir été alloués par la commande TSO "ALLOCATE".
L'ouverture et la fermeture des fichiers sont faites par la commande EXECIO.

Pour un fichier en lecture, EXECIO stocke les enregistrements lus dans le stack ou dans un tableau de variables.
Pour un fichier en écriture, EXECIO récupère les enregistrements à écrire dans le stack ou dans un tableau de variables.

EXECIO est une commande TSO REXX.

EXECIO

Format :

EXECIO lignes/* DISKW ddname [([STEM variable] [FINIS]
DISKR/DISKRU ddname [numligne] [([FINIS] [LIFO/FIFO/SKIP][STEM variable [FINIS]]

Lignes Nombre de lignes à lire ou à écrire ;
* Lecture jusqu'à fin de fichier
Écriture jusqu'à rencontre d'une ligne nulle dans le stack ou d'une variable nulle ou non initialisée dans le tableau de
variables.
DISKW Ouverture du fichier en écriture. Écriture du fichier. Si le fichier a été ouvert en mise à jour, DISKW est utilisé pour
réécrire la dernière ligne lue. Dans ce cas, le paramètre "lignes" doit avoir la valeur 1 ;
DISKR Ouverture du fichier en lecture. Lecture du fichier ;
DISKRU Ouverture du fichier en mise à jour. Lecture du fichier ;
DDNAME DDname du fichier à traiter ;
Numligne Pour un fichier ouvert en lecture ou en mise à jour, numéro de la ligne à partir de laquelle le fichier doit être lu ;
FINIS Fermeture du fichier à la fin de l'opérations EXECIO ;
STEM Variable Stockage des lignes lues dans un tableau de variables ou écriture du fichier à partir d'un tableau de
variables.
Si ce paramètre n'est pas fourni, le fichier est écrit (DISKR ou DISKRU) ou lu (DISKW) dans le stack.
LIFO Pour un fichier ouvert en lecture ou en mise à jour, stockage des enregistrements dans le stack selon l'ordre LIFO.
FIFO Pour un fichier ouvert en lecture ou en mise à jour, stockage des enregistrements dans le stack selon l'ordre FIFO.
SKIP Pour un fichier ouvert en lecture ou en mise à jour, lecture du nombre de lignes spécifiées par "lignes" sans stockage
dans le stack ou dans le tableau de variables.

Codes retour :

•   0 : Fin normale ;
•   1 : Troncation de données pendant une opération DISKW ;
•   2 : Détection de fin de fichier avant lecture de toutes les lignes demandées dans une opération DISKR ou DISKRU ;
• 20 : Erreur grave. Fin d'EXECIO avec émission d'un message.

Exemples :

"ALLOC DD(DDIN) DSN('EXEMPLE.FIC1') SHR REUSE
"ALLOC DD(DDOUT) SYSOUT(X) REUSE"
"IEXECIO * DISKR DDIN (FINIS"
QUEUE ""
"EXECIO * DISKW DDOUT (FINIS"

"ALLOC DD(DDIN) DSN('EXEMPLE.FIC1') SHR REUSE"
"ALLOC DD(DDOUT) SYSOUT(X) REUSE"
"EXECIO 10 DISKR DDIN (FINIS STEM DATA."
QUEUE " "
IF DATA.0=0 THEN DO
SAY "FICHIER DDIN VIDE"
EXIT
END
ELSE,
"EXECIO DISKW DDOUT (FINIS STEM DATA."

"ALLOC DD(DDIN) DSN('EXEMPLE.FIC1') OLD REUSE"
"EXECIO 1 DISKRU DDIN 3"
PULL LIGNE
LIGNE = "ligne modifiée"
PUSH LIGNE
"EXECIO 1 DISKW DDIN"

EXEMPLE DE LECTURE/ECRITURE

L'exemple qui suit lit un fichier en entrée et l'écrit sur un fichier en sortie :

* rexx et execio */
/* allocation du membre FIC01 en lecture */
/* et du membre FIC02 en écriture */
"alloc dd(in) ds('mon.pds.rexx.exec(fic01)') shr reuse'
"alloc dd(out) ds('mon.pds.rexx.exec(fic02)') old reuse"
/* lecture du membre FIC01 */
"EXECIO * DISKR in (FINIS"
queue"
/* écriture dans le membre FIC02 */
"EXECIO * DISKW out (FINIS"
/* libération des fichiers */
"free dd(in)"
"free dd(out)"

Procédures internes

Une procédure interne est une procédure REXX codifiée après une procédure appelante et identifiée par une étiquette.

L'appel d'une procédure interne se fait par l'instruction CALL.

Par défaut, les variables sont parrageables entre procédure, appelante et procédure appelée.

Pour interdire ou limiter le partage de variables on peut utiliser l'instruction PROCEDURE dans la procédure interne.

La sortie d'une procédure interne se fait par RETURN. Si on la demande par EXIT, il n'y a pas de retour dans la procédure appelante.

Après exécution de la procédure interne on revient dans la procédure appelante en séquence derrière le CALL si la sortie est demandée par RETURN.

Les instructions

CALL

Format : CALL étiquette
• Etiquette : Etiquette identifiant la procédure interne à exécuter.

PROCEDURE

Format : PROCEDURE [EXPOSE VAR1 VAR2....]
• Sans paramètres : L' instruction PROCEDURE utilisée sans paramètres permet d'interdire totalement le partage des variables.
• EXPOSE : Permet de donner la liste des variables dont on autorise le partage. On peut donner un radical définissant une collection de variables.

Exemples :

/* REXX */
NBR1 = 10
NBR2 = 20
CALL PROC2
SAY CALCUL
EXIT
PROC2: <------- étiquette
CALCUL = NBR1 + NBR2
RETURN

/* REXX */
NBR1 = 10
NBR2 = 20
NBR3 = "VARIABLE NON PARTAGEABLE"
CALL PROC2
SAY CALCUL
EXIT
PROC2: PROCEDURE EXPOSE NBR1 NBR2 CALCUL
CALCUL = NBR1 + NBR2
RETURN

Portée d'une variable Avec PROCEDURE :

/* REXX */
x = 1
y = 2
z = 3

call subrt1 y

say x /* x -> 1 -inchangé */
say y /* y -> 2 -inchangé */
say z /* z ->3 -modifié (EXPOSE) */
exit /* exit exec principal */

/* REXX sous-programme */
subrt1: PROCEDURE EXPOSE z
parse arg a
say a /* a -> 2 - argument passé */
say x /* x -> X - non initialisé */
say y /* y -> Y - non initialisé */
say z /* z -> 3 - partagé (expose) */
a = 25 /* y inchangée dans exec principal */
x = -1 /* non passée à l'exec principal */
y = -2 /* non passée à l'exec principal */
z = -3 /* change z dans l'exec principal */
return

Portée d'une variable Sans PROCEDURE :

x = 1
y = 2
z = 3

call subrt2 y

say x /* x -> -1 */
say y /* y -> -2 */
say z /* z -> - 3 */
exit /* exit exec principal */

/* REXX sous-programme */
subrt2:
parse arg a
/*a -> 2 - argument passé
x -> 1 - égal à l'exec principal
y -> 2 - égal à l'exec principal
z -> 3 - égal à l'exec appelant */

x = -1 /* changée dans l'exec principal */
y = -2 /* changée dans l'exec principal */
z = -3 /* changée dans l'exec principal */
return

NOTEZ LE

La protection des variables peut aussi se faire en faisant le passage par l'ordre CALL et la réception par l'instruction ARG (en leur donnant un nom différent). Le retour d'informations vers la procédure appelante peut se faire comme pour les procédures externes.

Procédures externes

Une procédure externe est une procédure REXX codifiée dans dans un PDS et appelée par une autre procédure.
Une procédure externe peut récupérer et traiter des donnée. Elle peut aussi fournir un résultat à la procédure appelante.

L'appel d'une procédure externe se fait par l'instruction CALL. Cette instruction sert aussi à passer des paramètres à la procédure appelée.

La récupération des paramètres se fait dans la procédure appelée au moyen de l'instruction ARG.

Le retour d'informations à la procédure appelante se fait au moyen des instructions RETURN ou EXIT. Ces informations sont stockées dans la variable RESULT.

Après exécution de la procédure externe on revient dans la procédure appelante en séquence derrière le CALL.

Les instructions

CALL

Format : CALL "procédure" VAR1 VAR2

• Procédure : Nom de la procédure externe à appeler. Si le nom n'est pas donné entre quotes, REXX recherche d'abord une procédure interne.
• VAR1,VAR2... : Paramètres à passer à la procédure. Ils peuvent être séparés par un blanc ou une virgule.

ARG

Format : ARG VAR1 [,] VAR2 [,] ...
VAR1,VAR2 Variables de réception des paramètres passé par CALL. Elles peuvent être séparées par des blancs ou des virgules. La séparation par des blancs permet un appel direct de la procédure.

RETURN

Format : RETURN [expression]
• Expression : Expression contenant les informations à retourner à la procédure appelante. Ce paramètre est 'facultatif si il n'y a pas d'informations à renvoyer.

EXIT

Format : EXIT [expression]
• Expression : Expression contenant les informations à retourner à la procédure appelante. Ce paramètre est facultatif si il n'y a pas d'informations à renvoyer.
Exemple d'instruction EXIT :

Exemple :

/* REXX routine principale */
"EXEC PROC(REXX1) exec"
SAY 'le code retour est : ' rc

/* REXX 1 utilisant l'EXIT */
SAY 'entrez une valeur 1 ou 0:'
PULL variable
IF variable = 1 then fin = 1
IF variable = 0 then fin = 0
IF variable 0 & variable 1 then fin 2
EXIT fin

Résultat : entrez une valeur 1 ou 0:
0
le code retour est : 0
entrez une valeur 1 ou 0:
1
le code retour est : 1

Les fonctions

Introduction

Les fonctions sont des procédures REXX externes ou internes dont l'appel est fait d'une façon particulière.
L'appel d'une fonction se fait en codant directement son nom dans une expression.

La récupération de ces paramètres se fait dans la fonction au moyen de l'instruction ARG.

Une fonction doit toujours retourner un résultat à la procédure appelante. Ce retour se fait au moyen de l'ordre RETURN. le résultat remplace la fonction à son point d'appel.

Les instructions

FONCTION

Format : FONCTION([VAR1,VAR2,..]
• VAR1,VAR2,... : Paramètres à passer à la fonction. Si on ne passe pas de paramètres, coder simplement les parenthèses.

Exemples

Exemple 1 :

Procédure 1 :

/* REXX */
NBR1 = 10
NBR2 = 20
CALL "PROC2" NBR1 NBR2
SAY RESULT
EXIT

Procédure PROC2 :

/* REXX */
ARG NBR1 NBR2
CALCUL = NBR1 + NBR2
PARSE SOURCE. APPEL.
IF APPEL "COMMAND" THEN DO
SAY CALCUL
EXIT
END
IF APPEL "SUBROUTINE",
THEN RETURN CALCUL

Exemple 2 :

/* Appel fonction et sous-programme rexx */

X = 5
call ma_fonction 20 /* rappel sous-programme */
say 'Variable RESULT:" result
/* RESULT -> 25 */

y = ma_fonction(x) /* appel fonction */
say 'Variable Y:' y /* y -> 10 */
say 'Variable RESULT:' result
/* result -> RESULT non initialisé */
exit ()

ma_fonction: Procedure
/* fonction: Renvoie argument plus 5 */
parse arg arg_in
say 'Argument fonction:' arg_in
return arg_in + 5

Résultat :

Argument fonction: 20
Variable RESULT: 25
Argument fonction: 5
Variable y: 10
Variable RESULT: RESULT

ADDRESS (Fonction)

Cette fonction permet de récupérer le nom de l'environnement de commande actif.
Format : ADDRESS()

ADRESS (Instruction)

Cette instruction permet d'envoyer des commandes à un environnement particulier.
Format : ADDRESS [environnement,[expression]]
• Environnement : Environnement auquel la commande est envoyée.
• Les principaux environnements sont les suivants :
• TSO : Emission de commandes TSO ;
• ISPEXEC : Emission d'ordres ISPF. ADDRESS ISPEXEC permet de ne pas coder le terme ISPEXEC devant chaque ordre ISPF.
• ISREDIT : Emission d'ordres macros éditeur.
• Expression : Commande à émettre. Elle doit être donnée entre quotes.
• ADDRESS environnement expression : Appel de l'environnement pour la commande seulement.
• ADDRESS environnement : Changement d'environnement.
• ADDRESS : Switch entre l'environnement en cours et le dernier utilisé.

Exemples :

/* REXX */
ADDRESS TSO
"ALLOC DD(DD1) DSN('FICHIER.FIC1') SHR REUSE"
"ALLOC DD(DD2) DSN('FICHIER.FIC2') SHR REUSE"

ADDRESS ISPEXEC
'DISPLAY PANEL(PAN01)"

"DISPLAY PANEL(PAN02)"

ARG

Cette fonction permet de récupérer des informations sur les paramètres passés à une procédure.
Format : ARG([n[,option]])
• Pas de paramètres : Récupération du nombre de paramètres passés ;
• N : Récupération du nième paramètre passé. Si il n'existe pas, récupération d'une chaîne nulle.
• Option : Permet de tester l'existence du nième paramètre.
• Les valeurs possibles sont :
• Exist : Retourne la valeur 1 si le paramètre existe, 0 dans le cas contraire ;
• Omitted : Retourne la valeur 1 si le paramètre n'existe pas, 0 dans le cas contraire.

Exemples :

/* REXX */
x = FONCTION(1,23,,00)

EXIT
FONCTION:
ARG V1,V2,V3,V4
SAY ARG() --> 4
SAY ARG(4) --> 00
SAY ARG(2,"E") --> 1
SAY ARG(3,"E") --> 0
RETURN

C2D

Nota : C2D est une fonction utilisée dans pgm C d’analyse de la bande RRPFQ Macro

Cette fonction retourne la valeur décimale de la représentation binaire d'une chaîne alphanumérique.
JLuc : Cette fonction retourne la représentation décimale du contenu binaire d'une chaîne alphanumérique (lui-même représenté en hexadécimal).
Format : C2D(expression)
• Expression : Expression à convertir.
Exemples :
C2D('09'X) --> 9
C2D('81'X) --> 129
C2D('FF81'X) --> 65409

C2X

Cette fonction permet de convertir une expression alphanumérique en hexadécimal.
Format : C2X(expression)
• Expression : Expression à convertir.
Exemples :
C2X('72s') --> F7F2A2
C2X('09'X) --> 09

D2C

Cette fonction permet de convertir une expression décimale en alphanumérique.
Format : D2C(expression)
• Expression : Expression à convertir.
Exemples :
D2C(9) --> '09'X
D2C(129) --> '81'X

D2X

Cette fonction permet de convertir une valeur décimale en hexadécimal.
Format : D2X(expression)
• Expression : Expression à convertir.
Exemples :
D2X(9) '09'
D2X(129) '81'

EXECUTIL

Cette instruction permet :
• D'indiquer si les bibliothèques allouées à SYSEXEC doivent être utilisées pour la recherche des procédures REXX ;
• De déclencher le mode debugging intéractif ;
• D'arrêter l'exécution d'une procédure ;
• De supprimer ou de réactiver les sorties terminal faites dans une procédure.
Cette commande peut être émise dans une procédure, en TSO natif ou sous ISPF.

Format :

EXECUTIL [SEARCHDD(YES/NO)]
[TS]
[TE]
[HT]
[RT]
[HI]

• SEARCHDD(YES) : La recherche des procédures REXX doit se faire en priorité dans les bibliothèques allouées à SYSEXEC ;
• SEARCHDD(NO) : Les bibliothèques allouées à SYSEXEC ne doivent pas être utilisées pour la recherche des procédures REXX ;
• TS : Initialisation du mode debugging intéractif ;
• TE : Arrêt du mode debugging intéractif ;
• HT : Suppression des sorties terminal générées par une procédure REXX ;
• RT : Annulation de la commande EXECUTIL HT ;
• HI : Arrêt de toutes les procédures REXX en cours d'exécution.

INTERPRET

Cette instruction permet d'exécuter une expression après son évaluation.

Format : INTERPRET expression
• Expression : Expression à traiter. REXX commence par évaluer son contenu puis il l'exécute.

Exemple :
/* REXX */
VAR2 = "AB CD EF"
EXPRESSION = "V1 V2 V3"

INTERPRET PARSE VAR "VAR2" EXPRESSION

Substitution de la variable EXPRESSION
PARSE VAR VAR2 V1 V2 V3

Exécution
V1=AB V2=CD V3=EF

LISTDSI

Cette fonction permet de récupérer un certain nombre d'informations relatives à un fichier. Ces informations sont stockées dans des variables spécifiques.

Après exécution, la fonction LISTDSI est remplacée par son code retour.

Format :
LISTDSI( [dsname] [VOLUME(num)/PREALLOC]
[ddname FILE]
[DIRECTORY/NODIRECTORY]
[RECALL/NORECALL])

• Dsname Nom du fichier à traiter. Par défaut, ce fichier est localisé à partir d'un catalogue ;
• VOLUME Volume d'implantation du fichier à traiter. Ce paramètre peut être utilisé avec un dsname si le fichier n'est pas
catalogué.
• PREALLOC Utilisé avec un dsname, indique que le fichier est alloué à l'environnement. La recherche se fera dans la liste
des fichiers alloués.
• Ddname DDNAME du fichier à traiter. Le fichier doit être alloué à l'environnement sous le DDNAME spécifié.
• FILE Ce paramètre est obligatoire si le fichier à traiter est identifié par son DDNAME.
• DIRECTORY Permet d'obtenir les informations directory d'un PDS ;
• RECALL Le fichier doit être rapatrié si il a été migré par HSM. Le système rapatrie le fichier quels que soient son
niveau de migration et le type d'unité utilisé pour la migration ;
• NORECALL Le fichier ne doit pas être rapatrié. Si il a été migré, le système envoie un message d'erreur. Par défaut le
système rapatrie le fichier.
Variables associées à LISTDSI

Variable Contenu
SYSDSNAME Nom du fichier
SYSVOLUME Volume d'implantation
SYSUNIT Unité d'implantation
SYSDSORG Organisation du fichier :
PS Séquentiel
PSU Séquentiel non déplaçable
DA Direct
DAU Direct non déplaçable
IS Séquentiel indexé
ISU Séquentiel indexé non déplaçable
PO Partitionné
POU Partitionné non déplaçable
VS VSAM
??? Inconnue
SYSLRECL Longueur des enregistrements logiques
SYSBLKSIZE Longueur des enregistrements physiques
SYSRECFM Format des enregistrements (combinaison des caractères suivants) :
U Indéfini
F Fixe
V Variable
B Bloqué
S Variable spanné
A Les enregistrements contiennent des caractères de saut ASCII
M Les enregistrements contiennent des caractères de saut machine
? Inconnu
SYSKEYLEN Longueur de la clé
SYSALLOC Espace alloué
SYSUSED Espace utilisé
SYSPRIMARY Taille de l'allocation primaire
SYSSECONDS Taille des allocations secondaires
SYSUNITS Unité d'allocation d'espace :
CYLINDER Allocation en cylindres
TRACK Allocation en pistes
BLOCK Allocation en blocs
???????? Inconnue
SYSEXTENTS Nombre d'allocations utilisées
SYSCREATE Date de création sous la forme AAAA/QQQ
SYSREFDATE Date de dernière référence sous la forme AAAA/QQQ
SYSEXDATE Date d'expiration sous la forme AAA
SYSPASSWORD Informations mot de passe :
NONE Pas de protection
READ Mot de passe en lecture
WRITE Mot de passe en écriture
SYSRACFA Informations RACF :
NONE Pas de protection
GENERIC Protection par profile générique
DISCRETE Protection par profile discret
SYSUPDATED Indicateur de mise à jour :
YES Les données ont été modifiées
NO Les données n'ont pas été modifiées
SYSTRKSCYL Nombre de pistes par cylindre pour l'unité identifiée dans &SYSUNIT
SYSBLKSTRK Nombre de blocs par piste
SYSADIRBLK Nombre de blocs de directory alloués (PDS)
SYSUDIRBLK Nombre de blocs de directory utilisés
SYSMEMBERS Nombre de membres
SYSREASON Code erreur de l'ordre LISTDSI
SYSMSGLVL1 Message d'erreur de niveau 1
SYSMSGLVL2 Message d'erreur de niveau 2

Codes retour associées à LISTDSI

Code retour Signification
0 Fin normale
4 Certaines informations ne sont pas disponibles
16 Erreur grave

Codes erreur associées à LISTDSI

Code erreur Signification
0 Fin normale
1 Erreur à l'analyse de l'instruction
2 Erreur pendant l'allocation dynamique
3 Type de fichier invalide
4 Erreur à la détermination du type d'unité
5 Fichier non catalogué
6 Erreur pendant la recherche du nom en VTOC
7 Erreur pendant la recherche du type d'unité
8 Le fichier n'est pas un fichier disque
9 Fichier migré par DFHSM. le paramètre NORECALL empêche le rappel
11 Autorisations insuffisantes sur une demande «informations directory
12 Fichiers VSAM non supportés
13 Le fichier ne peut pas être ouvert
14 Type d'unité non trouvé dans la table des UCB
17 ABEND système ou utilisateur
18 Obtention d'informations fichier partielles
19 Fichier multi-volumes
20 Type d'unité non trouvé dans la table EDT
21 Erreur catalogue pendant la recherche du fichier
22 Volume non monté
23 Erreur d'E/S permanente sur le volume
24 Fichier non trouvé sur le volume
25 Fichier migré sur une unité autre qu'un disque
27 Pas de numéro de volume attribué au fichier
28 Structure du DDNAME invalide
29 DSNAME ou DDNAME obligatoires.

MSG

Cette fonction, permet de gérer l'affichage des messages émis par les commandes TSO.
Format : MSG([option])
• Sans option : Permet de récupérer l'état d'affichage en cours (ON ou OFF) ;
• Option : La fonction retourne l'état en cours et le positionne avec l'option choisie :
• ON : Affichage des messages émis par les commandes ;
• OFF : Pas d'affichage des messages émis par les commandes.

Exemples :
VAR1 = MSG()
VAR2 = MSG(OFF)

OUTTRAP

Cette fonction permet de stocker le résultat de certaines commandes TSO dans un tableau de variables.
Format : OUTTRAP([OFFI [variable][,[max][,[concat]]])
• OFF : Arrêt de la fonction de stockage ;
• Variable : Identification des variables constituant le tableau de stockage. Si le nom est donné sous la forme "variable.", le tableau sera constitué de variables indicées de 0 à n. Si le nom est donné sous la forme "variable", le tableau sera constitué de variables numérotées de 0 à n.
• Le nombre de lignes stockées dans le tableau sera indiqué dans variable.0 ou variable0.
• Max : Nombre maximum de lignes à stocker. Blanc ou "*" permet de stocker tout le résultat de la commande.
• Concat :
• CONCAT : Concaténation du résultat de commandes TSO successives.
• NOCONCAT : Réutilisation du tableau pour chaque commande TSO.
Variables supplémentaires :
• Variable[.]MAX : Nombre maximum de lignes pouvant être stockées ;
• Variable[.]TRAPPED : Nombre de lignes produites par la commande ;
• Variable[.]CON : Utilisation du tableau de variables (CONCAT/NOCONCAT).
Exemples :
X = OUTTRAP(VAR.,3)
"LISTDS 'MON.PDS.JCL'"

SAY VAR.0 ---> 3
SAY VAR.1 ---> MON.PDS.JCL

SAY VAR.MAX ---> 3
SAY VAR.TRAPPED ---> 5
SAY VAR.CON ---> CONCAT

PARSE SOURCE

Cette instruction permet de connaître l'origine de la procédure en cours d'exécution.

Format : PARSE SOURCE structure-de-réception
• Structure-de-réception : Cette structure peut être composée d'une combinaison des éléments suivants :
• Des variables réceptrices ;
• Des caractères délimiteurs ;
• Des pointeurs numériques permettant de se positionner dans les informations retournées par PARSE SOURCE. Des points permettant d'ignorer une partie du contenu des informations retournées par PARSE SOURCE.

Les informations récupérées seront les suivantes :
1. La chaîne de caractères TSO ;
2. "COMMAND" si la procédure a été appelée en direct ;
3. "FUNCTION" si la procédure a été appelée sous forme de fonction ;
4. "SUBROUTINE" si la procédure a été appelée par CALL.
5. Nom de la procédure en majuscules ou (?) si inconnu ;
6. DDname du fichier à partir duquel la procédure à été chargée ou (?) si inconnu ;
7. DSNAME du fichier à partir duquel la procédure à été chargée ou (?) si inconnu ;
8. Nom de la procédure tel qu'il a été codé à l'appel ou (?) si inconnu ;
9. Environnement de commandes initial (MVS, TSO ou ISPEXEC). ;
10. Environnement d'exécution (MVS, TSO ou ISPF).

Exemple

Procédure 1 :
/* REXX */
NBR1 = 10
NBR2 = 20
CALL "PROC2" NBR1 NBR2
SAY RESULT
EXIT

Procédure PROC2 :
/* REXX */
ARG NBR1 NBR2
CALCUL = NBR1 + NBR2
PARSE SOURCE. APPEL.
IF APPEL "COMMAND" THEN DO
SAY CALCUL
EXIT
END
IF APPEL "SUBROUTINE",
THEN RETURN CALCUL

PROMPT

Cette fonction permet de gérer le mode intéractif pour les commandes TSO.
Format : PROMPT([option])
• Sans option : Permet de récupérer le mode en cours (ON ou OFF).
• Option : La fonction retourne le mode en cours et le positionne avec l'option choisie :
• ON : Activation du mode intéractif ;
• OFF : Désactivation du mode intéractif.

Exemples :
VAR1 = PROMPT()
VAR2 = PROMPT(OFF)
RETURN

Format : RETURN expression
• Expression : Expression contenant les informations à retourner a la procédure appelante. Ce paramètre est obligatoire.

Exemples :

Procédure
/* REXX*/
NBR1 = 10
NBR2 = 20
SAY PROC2(NBR1,NBR2)
EXIT

Fonction PROC2
ARG NBR1,NBR2
CALCUL = NBR1 + NBR2
RETURN CALCUL

SOURCELINE

Format : SOURCELINE([n])
• Sans le paramètre n, la fonction permet de récupérer le numéro de la dernière ligne de la procédure.
• Avec le paramètre n, la fonction permet de récupérer le contenu de la nième ligne de la procédure.

SUBCOM

Cette instruction permet de savoir si un environnement de commandes existe. Elle positionne la variable RC à 0 si l'environnement existe ou à 1 si l'environnement n'existe pas.
Format : SUBCOM environnement

SYSDSN

Cette fonction retourne un message indiquant si un fichier spécifique existe et est utilisable.

Format : SYSDSN(nom de Fichier)
Les messages retournées par la fonction SYSDSN sont les suivants :

OK
MEMBER NOT FOUND
MEMBER SPECIFIED, BUT DATASET IS NOT PARTITIONED
DATASET NOT FOUND
ERROR PROCESSING REQUESTED DATASET
PROTECTED DATASET
VOLUME NOT ON SYSTEM
INVALID DATASET NAME, nom de fichier
MISSING DATA SET NAME
UNAVAILABLE DATASET

X2C

Cette fonction permet de convertir une valeur hexadécimale en alphanumérique.
Format : X2C(expression)
• Expression : Expression à convertir.

Exemples :
X2C('F7F2A2') --> 72s
X2C('f') --> 0f

X2D

Cette fonction permet de convertir une valeur hexadécimale en décimal.
Format : X2D(expression)
• Expression : Expression à convertir.

Exemples :
X2D('0E') --> 14
X2D('F81') --> 369

Gestion des erreurs

Les interruptions

L'interruption d'exécution d'une procédure REXX peut être demandée de 2 façons :
1. Par utilisation de la commande EXECUTIL HI dans la procédure.
2. Par utilisation de la touche ATTN suivie de la commande immédiate HI.

L'interruption d'exécution simule une erreur de syntaxe et provoque la destruction du stack.
Cette interruption provoque l'arrêt de toutes les procédures en cours d'exécution.

Interception des erreurs

L'interception des erreurs peut être faite au moyen des instructions CALL et SIGNAL.
Ces instructions doivent être positionnées avant les instructions ou commandes pouvant se terminer par une erreur.

La fonction CONDITION permet de récupérer un certain nombre d'informations sur l'erreur interceptée.

La variable SIGL contient le numéro de la ligne en erreur.
La variable RC confient le code retour associé à l'erreur.

CALL

Format :

CALL [ON] [ERROR] [NAME nom]
[FAILURE]
[HALT]
[OFF] [ERROR]
[FAILURE]
[HALT]

• ON Activation de l'interception ;
• OFF Désactivation de l'interception ;
• ERROR interception des erreurs à code retour positif sur les commandes ;
• FAILURE Interception des erreurs à code retour négatif sur les commandes ;
• HALT Interception des interruptions externes ;
• Nom Etiquette identifiant le paragraphe de traitement d'erreurs. Si le paramètre NAME n'est pas donné, il y a
recherche d'une étiquette ERROR, FAILURE ou HALT.

NOTEZ LE

La sortie du paragraphe de traitement d'erreurs se fait par RETURN avec retour en séquence derrière l'instruction en erreur. Il n'est pas possible de positionner la variable RESULT à ce niveau.

Une interception d'erreur activée par CALL ON est mise à l'état DELAYED jusqu'à la rencontre d'un CALL OFF pour la même condition et dans la même procédure. Ceci signifie que cette demande d'interception sera utilisée pour toutes les erreurs du même type rencontrées dans la procédure.

Exemples :

/* REXX
CALL ON ERROR NAME ERREUR
"ALLOC DD(DD1) DSN('EXEMPLE.FIC1') SHR REUSE"
"ALLOC DD(DD2) DSN('EXEMPLE.FIC2') SHR REUSE"
EXIT
ERREUR:
SAY "ERREUR LIGNE:" SIGL RETURN

Fonctionnement :
• Si la première commande ALLOC tombe en erreur, branchement automatique à l'étiquette ERREUR, exécution du paragraphe puis retour en séquence à la commande ALLOC suivante ;
• Si la deuxième commande ALLOC tombe en erreur, branchement automatique à l'étiquette ERREUR, exécution du paragraphe puis retour en séquence derrière.la deuxième.ALLOC.

CONDITION

Cette fonction permet de récupérer des informations sur une erreur.

Format : CONDITION([option])
• Option : Type d'information à récupérer. On trouvera :
• Condition : Type d'interception ;
• Description : Elément de la procédure associé à l'erreur ;
• Instruction : Instruction d'appel au paragraphe (CALL/SIGNAL) ;
• Status : Etat de l'interception (ON, OFF, DELAYED).

Exemples :
/* REXX
CALL ON ERROR NAME ERREUR
"ALLOC DD(DDL) DSN('EXEMPLE.FIC1') SHR REUSE"
"ALLOC DD(DD2) DSN('EXEMPLE.FIC2') SHR REUSE"

EXIT
ERREUR:
SAY 'ERREUR LIGNE:" SIGL
SAY CONDITION(C) ---> ERROR
SAY CONDITION(D) ---> "ALLOC DD(DD1)........"
SAY CONDITION(I) ---> CALL
SAY CONDITION(S) ---> DELAYED
RETURN

ERRORTEXT

Cette fonction permet de récupérer le message associé à un code erreur particulier.
Format : ERRORTEXT(code)
• Code : Code de l'erreur dont on veut récupérer le message. Il correspond à un message IRXcodeI.

Exemple :

ERRORTEXT(16) --> Label not found

SIGNAL

L'instruction de branchement sur un label en REXX est SIGNAL.

SIGNAL est un changement anormal de la séquence d'exécution. Il ne doit pas être employé pour sortir d'une boucle d'un sous-programme.

Format :

SIGNAL [ON] [ERROR] [NAME nom]
[FAILURE]
[HALT]
[NOVALUE]
[SYNTAX]
[OFF] [ERROR]
[FAILURE]
[HALT]
[NOVALUE]
[SYNTAX]

• ON Activation de l'interception ;
• OFF Désactivation de l'interception ;
• ERROR interception des erreurs à code retour positif les commandes ;
• FAILURE Interception des erreurs à code retour négatif sur les commandes ;
• HALT Interception des interruptions externes ;
• NOVALUE Interception des erreurs dues aux variables non initialisées ;
• SYNTAX Interception des erreurs de syntaxe ;
• Nom Etiquette identifiant le paragraphe de traitement d'erreurs. Si le paramètre NAME n'est pas donné, il y a
recherche d'une étiquette ERROR, FAILURE ou HALT, NOVALUE ou SYNTAX.

NOTEZ LE

La sortie du paragraphe de traitement d'erreurs se fait par RETURN ou EXIT avec arrêt de la procédure.

Une interception d'erreur activée par SIGNAL ON est remise à l'état OFF au passage dans le paragraphe de traitement d'erreur.

Exemples :

/* REXX */
SIGNAL ON ERROR NAME ERREUR
"ALLOC DD(DD1) DSN('EXEMPLE.FIC1')' SHR REUSE"
"ALLOC DD(DD2) DSN('EXEMPLE.FIC2') SHR REUSE"
EXIT
ERREUR:
SAY "ERREUR LIGNE:" SIGL
RETURN

Fonctionnement :

Si la première commande ALLOC tombe en erreur, branchement automatique à l'étiquette ERREUR, exécution du paragraphe puis arrêt.

TRACE

Cette instruction permet de suivre le déroulement d'une procédure. Un certain nombre de paramètres permettent d'indiquer de quelle façon le suivi doit être fait.

Le mode debugging intéractif permet d'avoir la main au terminal après chaque affichage provoqué par la commande TRACE.

ENTER provoque la reprise d'exécution de la procédure. On peut aussi demander l'exécution de n'importe quelle commande ou instruction REXX en rapport ou non avec la procédure.

Format :

TRACE [?/!] [All]
[Commands]
[Error]
[Failurel
[Intermediates]
[Labels]
[Normal]
[Off]
[Results]
[Scan]
[nombre]
• All  Affichage de toutes les clauses de la procédure avant exécution ;
• Commands Affichage de toutes les commandes (TSO,.ISPF) avant exécution. Affichage du code retour de ces
Commandes en cas d'erreur ;
• Error  Affichage des commandes en erreur (RC > 0) après exécution.
• Failure  Affichage des commandes se terminant par un code retour négatif après exécution. Identique à Normal ;
• Intermediates Affichage de toutes les clauses. Affichage des résultats intermédiaires de substitutions et d'évaluation
d'expressions ;
• Labels  Affichage de toutes les étiquettes par lesquelles passe l'exécution de la procédure ;
• Normal  Identique à Failure. Ce paramètre est pris par défaut ;
• Off  Arrêt de l'affichage.
• Results  Affichage de toutes les clauses avant exécution. Affichage du résultat final des évaluations
d'expressions. Affichage des valeurs affectées aux variables par PULL, ARGE, PARSE ;
• Scan  Affichage de toutes les clauses de la procédure sans exécution ;
• Nombre  Valable uniquement en mode debugging intéractif. Si on fournit un nombre entier positif, ce nombre
indique le nombre d'arrêt après affichage qui ne doivent pas être faits.
Si on fournit un nombre entier négatif, ce nombre indique le nombre de clauses qui ne doivent pas être tracées ;
• ?  Peut être fourni seul ou avec un des paramètres précédents. Permet de travailler en mode debugging
interactif. Ce mode pourra aussi être demandé par EXECUTIL TS ;
• !  Peut être fourni seul ou avec un des paramètres précédents. Permet d'interdire l'exécution des
commandes TSO ou ISPF.

Format de la TRACE

Les clauses tracées sont indentées automatiquement en fonction de leur niveau d'imbrication.

Les résultats sont décalés de 2 caractères vers la droite et fournis entre doubles quotes de façon à faire apparaître les blancs qui figureraient éventuellement en début ou en fin de chaîne.

Les valeurs hexadécimales inférieures à X'40' sont remplacées par (?).
La première clause d'une ligne est précédée par le numéro de cette ligne.

Toutes les lignes affichées pendant la trace sont préfixées par 3 caractères indiquant leur contenu (type de données).

Préfix habituels

*_* Identifie une clause de la procédure ;
+++ Identifie un message de trace ;
>>> Identifie le résultat d'une expression, la valeur affectée à une variable lors d'un PARSE ou le résultat retourné par une
procédure appelée.
>.> Identifie la valeur affectée à un point de remplacement lors d'un PARSE.

Préfix utilisés avec TRACE I
• >C> : La donnée affichée est une variable indicée ;
• >F> : La donnée affichée est le résultat d'un appel de fonction ;
• >L> : La donnée affichée est un littéral ;
• >O> : La donnée affichée est le résultat d'une opération sur 2 éléments ;
• >P> : La donnée affichée est le résultat d'une opération préfixe ;
• >V> : La donnée affichée est le contenu d'une variable.

Rexx en batch

Il est possible de demander l'exécution de procédures REXX dans un espace adresses batch en utilisant les programmes
IKJEFT01 ou IRXJCL.

Utilisation de IKJEFT01

JCL de mise en oeuvre :

//REXX EXEC PGM=IKJEFT01,DYNAMNBR=99
//SYSPROC DD bibliothèques de procédures
//SYSEXEC DD bibliothèques de procédures
//SYSTSPRT DD SYSOUT=classe
//SYSTSIN DD *
Appels de procédures et/ou commandes TSO
/*
//REXBATCH EXEC PGM=IKJEFT01,DYNAMNBR=99,PARM='%PROC paramètres'
//SYSPROC DD bibliothèques de procédures
//SYSTSPRT DD SYSOUT=classe
//SYSTSIN DD *
Données lues par la procédure (PULL, PARSE EXTERNAL, commandes TSO)
/*

Contenu de la procédure

• Instructions REXX ;
• Commandes TSO REXX ;
• Commandes TSO ;
• Fonctions externes TSO.

Code retour

Le code retour émis par l'étape est le code retour positionné en sortie de procédure.
• Si la procédure envoie un code retour positif ou nul, l'étape se termine avec le même ;
• Si la procédure envoie un code retour négatif, l'étape se termine avec un code retour 12.

Utilisation de IRXJCL

JCL de mise en oeuvre :

//REXBATCH EXEC PGM=IRXJCL,PARM='%PROC paramètres'
//SYSPROC DD bibliothèques de procédures
//SYSTSPRT DD SYSOUT=classe
//SYSTSIN DD *
Données lues par la procédure (PULL, PARSE EXTERNAL, commandes TSO)
/*

Contenu de la procédure

• Instructions REXX ;
• Commandes TSO REXX ;

Code retour

REXX - Ober - e galleg