Rexx - Rexx

Rexx

Paradigme	multiparadigme : procédural , structuré
Conçu par	Mike Cowlishaw
Développeur	Mike Cowlishaw, IBM
Première apparition	1979 ; il y a 42 ans ( 1979 )
Version stable	ANSI X3.274 / 1996 ; il y a 25 ans ( 1996 )
Discipline de frappe	Dynamique
Extensions de nom de fichier	.cmd, .bat, .exec, .rexx, .rex, EXEC
Les principales mises en œuvre
VM / SP R3, TSO / E V2, SAAREXX, ARexx , BREXX, Regina, Personal REXX, REXX / imc
Dialectes
NetRexx , Objet REXX , maintenant ooREXX , KEXX
Influencé par
PL/I , ALGOL , EXEC , EXEC 2
Influencé
NetRexx , Objet REXX
Programmation Rexx sur Wikibooks

Rexx ( Restructured Extended Executor ) est un langage de programmation interprété développé chez IBM par Mike Cowlishaw . Il s'agit d'un langage de programmation structuré et de haut niveau conçu pour faciliter l'apprentissage et la lecture. Des interpréteurs Rexx propriétaires et open source existent pour un large éventail de plates-formes informatiques ; des compilateurs existent pour les ordinateurs centraux IBM .

Rexx est utilisé comme langage de script et de macro , et est souvent utilisé pour traiter des données et du texte et générer des rapports ; ces similitudes avec Perl signifient que Rexx fonctionne bien dans la programmation Common Gateway Interface (CGI) et qu'il est en effet utilisé à cette fin. Rexx est le langage de script principal dans certains systèmes d'exploitation, par exemple OS/2 , MVS , VM , AmigaOS , et est également utilisé comme langage macro interne dans certains autres logiciels, tels que SPFPC , KEDIT , THE et l' émulateur de terminal ZOC . De plus, le langage Rexx peut être utilisé pour les scripts et les macros dans n'importe quel programme qui utilise les langages des moteurs de script Windows Scripting Host ActiveX (par exemple VBScript et JScript) si l'un des moteurs Rexx est installé.

Rexx est fourni avec VM/SP Release 3 au dessus, TSO/E Version 2 au dessus, OS/2 (1.3 et ultérieur, où il est officiellement nommé Procedures Language/2 ), AmigaOS Version 2 au dessus, PC DOS ( 7.0 ou 2000 ), ArcaOS et Windows NT 4.0 (Kit de ressources : Regina). Les scripts REXX pour OS/2 partagent l'extension de nom de fichier .cmd avec d'autres langages de script et la première ligne du script spécifie l'interpréteur à utiliser. Les macros REXX pour les applications compatibles REXX utilisent des extensions déterminées par l'application. À la fin des années 1980, Rexx est devenu le langage de script commun pour IBM Systems Application Architecture , où il a été renommé « SAA Procedure Language REXX ».

Un script ou une commande Rexx est parfois appelé EXEC en référence au type de fichier CMS utilisé pour les scripts EXEC , EXEC 2 et REXX sur CP/CMS et VM/370 à z/VM .

Caractéristiques

Rexx a les caractéristiques et fonctionnalités suivantes :

• Syntaxe simple
• La possibilité d'acheminer des commandes vers plusieurs environnements
• La capacité de prendre en charge les fonctions, procédures et commandes associées à un environnement d'appel spécifique.
• Une pile intégrée, avec la possibilité d'interagir avec la pile hôte s'il y en a une.
• Petit jeu d'instructions contenant seulement deux douzaines d'instructions
• Syntaxe libre
• Jetons insensibles à la casse, y compris les noms de variables
• Base de chaîne de caractères
• Saisie dynamique des données , aucune déclaration
• Pas de mots - clés réservés , sauf dans le contexte local
• Pas d'installations de fichiers d'inclusion
• Précision numérique arbitraire
• Arithmétique décimale, virgule flottante
• Une riche sélection de fonctions intégrées, en particulier le traitement de chaînes et de texte
• Gestion automatique du stockage
• Protection contre les collisions
• Structures de données adressables par le contenu
• Tableaux associatifs
• Accès simple aux commandes et aux fonctionnalités du système
• Gestion simple des erreurs, traçage et débogueur intégrés
• Peu de limitations artificielles
• Fonctionnalités d'E/S simplifiées
• Opérateurs non conventionnels
• Ne prend en charge que partiellement les paramètres de ligne de commande de style Unix, à l'exception des implémentations spécifiques
• Ne fournit aucun contrôle de terminal de base dans le cadre du langage, à l'exception des implémentations spécifiques
• Ne fournit aucun moyen générique d'inclure des fonctions et des sous-routines à partir de bibliothèques externes, à l'exception des implémentations spécifiques

Rexx n'a que vingt-trois instructions, en grande partie évidentes, (telles que call, parse, et select) avec des exigences minimales de ponctuation et de formatage. Il s'agit essentiellement d'un langage de forme presque libre avec un seul type de données, la chaîne de caractères ; cette philosophie signifie que toutes les données sont visibles (symboliques) et que le débogage et le traçage sont simplifiés.

La syntaxe de Rexx ressemble à PL/I , mais a moins de notations ; cela le rend plus difficile à analyser (par programme) mais plus facile à utiliser, sauf dans les cas où les habitudes PL/I peuvent conduire à des surprises. L'un des objectifs de conception de REXX était le principe du moindre étonnement .

Histoire

avant 1990

Rexx a été conçu et mis en œuvre pour la première fois, en langage assembleur , en tant que projet « propre » entre le 20 mars 1979 et la mi-1982 par Mike Cowlishaw d'IBM, à l'origine en tant que langage de programmation de script pour remplacer les langages EXEC et EXEC 2 . Il a été conçu pour être une macro ou un langage de script pour n'importe quel système. En tant que tel, Rexx est considéré comme un précurseur de Tcl et Python . Rexx a également été conçu par son créateur pour être une version simplifiée et plus facile à apprendre du langage de programmation PL/I . Cependant, certaines différences par rapport à PL/I peuvent faire trébucher les imprudents.

Il a été décrit pour la première fois en public lors de la conférence SHARE 56 à Houston, au Texas, en 1981, où la réaction des clients, défendue par Ted Johnston du SLAC , a conduit à son expédition en tant que produit IBM en 1982.

Au fil des ans, IBM a inclus Rexx dans presque tous ses systèmes d'exploitation ( VM/CMS , MVS TSO/E , IBM i , VSE/ESA , AIX , PC DOS et OS/2 ) et a mis des versions à disposition pour Novell NetWare , Windows , Java et Linux .

La première version non-IBM a été écrite pour PC DOS par Charles Daney en 1984/5 et commercialisée par le Mansfield Software Group (fondé par Kevin J. Kearney en 1986). La première version du compilateur est apparue en 1987, écrite pour CMS par Lundin et Woodruff. D'autres versions ont également été développées pour Atari , AmigaOS , Unix (nombreuses variantes), Solaris , DEC , Windows , Windows CE , Pocket PC , DOS , Palm OS , QNX , OS/2 , Linux , BeOS , EPOC32 / Symbian , AtheOS , OpenVMS , Apple Macintosh et Mac OS X .

La version Amiga de Rexx, appelée ARexx , était incluse avec AmigaOS 2 et était populaire pour les scripts ainsi que pour le contrôle des applications. De nombreuses applications Amiga ont un "port ARexx" intégré qui permet de contrôler l'application depuis Rexx. Un seul script Rexx pourrait même basculer entre différents ports Rexx afin de contrôler plusieurs applications en cours d'exécution.

1990 à aujourd'hui

En 1990, Cathie Dager du SLAC a organisé le premier symposium indépendant Rexx, qui a conduit à la formation de la REXX Language Association. Des colloques sont organisés chaque année.

Plusieurs versions gratuites de Rexx sont disponibles. En 1992, les deux ports open source les plus utilisés sont apparus : REXX/imc de Ian Collier pour Unix et Regina d'Anders Christensen (adopté plus tard par Mark Hessling) pour Windows et Unix. BREXX est bien connu pour les plates-formes WinCE et Pocket PC, et a été « rétroporté » sur VM/370 et MVS .

OS/2 dispose d'un système de développement visuel de Watcom VX-REXX . Un autre dialecte était VisPro REXX de Hockware.

Portable Rexx de Kilowatt et Personal Rexx de Quercus sont deux interpréteurs Rexx conçus pour DOS et peuvent également être exécutés sous Windows à l'aide d'une invite de commande. Depuis le milieu des années 1990, deux nouvelles variantes de Rexx sont apparues :

• NetRexx : compiles à Java byte-code via le code source Java; celui-ci n'a aucun mot-clé réservé et utilise le modèle objet Java, et n'est donc généralement pas compatible avec le Rexx « classique ».
• Object REXX : une version orientée objet généralement compatible vers le haut de Rexx.

En 1996, l' American National Standards Institute (ANSI) a publié une norme pour Rexx : ANSI X3.274–1996 « Information Technology – Programming Language REXX ». Plus de deux douzaines de livres sur Rexx ont été publiés depuis 1985.

Rexx a célébré son 25e anniversaire le 20 mars 2004, qui a été célébré lors du 15e Symposium international REXX de la REXX Language Association à Böblingen, en Allemagne, en mai 2004.

Le 12 octobre 2004, IBM a annoncé son intention de publier les sources de son implémentation Object REXX sous la Common Public License . Les versions récentes d'Object REXX contiennent un moteur de script ActiveX Windows Scripting Host (WSH) implémentant cette version du langage Rexx.

Le 22 février 2005, la première version publique d'Open Object Rexx (ooRexx) a été annoncée. Ce produit contient un moteur de script WSH qui permet la programmation du système d'exploitation Windows et des applications avec Rexx de la même manière que Visual Basic et JScript sont implémentés par l'installation WSH par défaut et les moteurs de script tiers Perl , Tcl et Python .

En janvier 2017, REXX figurait dans l' index TIOBE comme l'une des cinquante langues de son top 100 n'appartenant pas au top 50.

En 2019, le 30e Symposium de la Rexx Language Association a marqué le 40e anniversaire de Rexx. Le symposium s'est tenu à Hursley, en Angleterre, où Rexx a été conçu et mis en œuvre pour la première fois.

Boîtes à outils

Rexx/Tk, une boîte à outils pour les graphiques à utiliser dans les programmes Rexx de la même manière que Tcl/Tk est largement disponible.

Un IDE Rexx, RxxxEd, a été développé pour Windows. RxSock pour la communication réseau ainsi que d'autres add-ons et implémentations de Regina Rexx ont été développés, et un interpréteur Rexx pour la ligne de commande Windows est fourni dans la plupart des kits de ressources pour différentes versions de Windows et fonctionne sous chacune d'entre elles ainsi que DOS.

Orthographe et majuscule

À l'origine la langue s'appelait Rex ( Reformed Executor ); le "X" supplémentaire a été ajouté pour éviter les collisions avec les noms d'autres produits. REX était à l'origine entièrement en majuscules car le code du mainframe était orienté en majuscules. Le style à l'époque était d'avoir des noms en majuscules, en partie parce que presque tout le code était encore en majuscules à l'époque. Pour le produit, il est devenu REXX, et les deux éditions du livre de Mike Cowlishaw utilisent des majuscules. L'extension à REstructured eXtended eXecutor a été utilisée pour le produit système en 1984.

Syntaxe

Bouclage

La structure de contrôle de boucle dans Rexx commence par un DOet se termine par un ENDmais se décline en plusieurs variétés. NetRexx utilise le mot-clé LOOPau lieu de DOfor en boucle, tandis que ooRexx traite LOOPet DOcomme équivalent lors de la boucle.

Boucles conditionnelles

Rexx prend en charge une variété de boucles de programmation structurée traditionnelles tout en testant une condition avant ( do while) ou après ( do until) l'exécution de la liste d'instructions :

 do while [condition]
 [instructions]
 end

 do until [condition]
 [instructions]
 end

Boucles répétitives

Comme la plupart des langages, Rexx peut boucler en incrémentant une variable d'index et s'arrêter lorsqu'une limite est atteinte :

 do index = start [to limit] [by increment] [for count]
 [instructions]
 end

L'incrément peut être omis et la valeur par défaut est 1. La limite peut également être omise, ce qui fait que la boucle continue indéfiniment.

Rexx autorise les boucles comptées, où une expression est calculée au début de la boucle et les instructions dans la boucle sont exécutées autant de fois :

 do expression
 [instructions]
 end

Rexx peut même boucler jusqu'à la fin du programme :

 do forever
 [instructions]
 end

Un programme peut sortir de la boucle actuelle avec l' leaveinstruction, ce qui est le moyen normal de sortir d'une do foreverboucle, ou peut la court-circuiter avec l' iterateinstruction.

Boucles combinées

Le plus inhabituel, Rexx permet à des éléments conditionnels et répétitifs d'être combinés dans la même boucle :

 do index = start [to limit] [by increment] [for count] [while condition]
 [instructions]
 end

 do expression [until condition]
 [instructions]
 end

Conditionnels

Conditions de test avec IF:

 if [condition] then
 do
 [instructions]
 end
 else
 do
 [instructions]
 end

La ELSEclause est facultative.

Pour les instructions simples, DOet ENDpeut également être omis :

 if [condition] then
 [instruction]
 else
 [instruction]

L'indentation est facultative, mais elle contribue à améliorer la lisibilité.

Tester plusieurs conditions

SELECTest la structure CASE de Rexx , comme beaucoup d'autres constructions dérivées de PL/I . Comme certaines implémentations de constructions CASE dans d'autres langages dynamiques, les WHENclauses de Rexx spécifient des conditions complètes, qui n'ont pas besoin d'être liées les unes aux autres. En cela, ils ressemblent plus à des ensembles de IF-THEN-ELSEIF-THEN-...-ELSEcode en cascade qu'à l' switchinstruction C ou Java .

 select
 when [condition] then
 [instruction] or NOP
 when [condition] then
 do
 [instructions] or NOP
 end
 otherwise
 [instructions] or NOP
 end

L' NOPinstruction n'exécute "aucune opération", et est utilisée lorsque le programmeur souhaite ne rien faire à un endroit où une ou plusieurs instructions seraient nécessaires.

La clause OTHERWISE est facultative. S'il est omis et qu'aucune condition WHEN n'est remplie, alors la condition SYNTAX est levée.

Variables simples

Les variables dans Rexx sont sans type et sont initialement évaluées comme leurs noms, en majuscules. Ainsi le type d'une variable peut varier avec son utilisation dans le programme :

 say hello /* => HELLO */
 hello = 25
 say hello /* => 25 */
 hello = "say 5 + 3"
 say hello /* => say 5 + 3 */
 interpret hello /* => 8 */
 drop hello
 say hello /* => HELLO */

Variables composées

Contrairement à de nombreux autres langages de programmation, le Rexx classique ne prend pas directement en charge les tableaux de variables adressés par un index numérique. Au lieu de cela, il fournit des variables composées . Une variable composée se compose d'une tige suivie d'une queue. UNE . (point) est utilisé pour joindre la tige à la queue. Si les queues utilisées sont numériques, il est facile de produire le même effet qu'un tableau.

 do i = 1 to 10
 stem.i = 10 - i
 end

Ensuite, les variables suivantes avec les valeurs suivantes existent : stem.1 = 9, stem.2 = 8, stem.3 = 7...

Contrairement aux tableaux, l'index d'une variable radicale n'a pas besoin d'avoir une valeur entière. Par exemple, le code suivant est valide :

 i = 'Monday'
 stem.i = 2

Dans Rexx, il est également possible de définir une valeur par défaut pour une tige.

 stem. = 'Unknown'
 stem.1 = 'USA'
 stem.44 = 'UK'
 stem.33 = 'France'

Après ces devoirs le terme stem.3produirait 'Unknown'.

La tige entière peut également être effacée avec l'instruction DROP.

 drop stem.

Cela a également pour effet de supprimer toute valeur par défaut définie précédemment.

Par convention (et non dans le cadre du langage), le composé stem.0est souvent utilisé pour garder une trace du nombre d'éléments dans une racine, par exemple une procédure pour ajouter un mot à une liste peut être codée comme ceci :

 add_word: procedure expose dictionary.
 parse arg w
 n = dictionary.0 + 1
 dictionary.n = w
 dictionary.0 = n
 return

Il est également possible d'avoir plusieurs éléments dans la queue d'une variable composée. Par exemple:

 m = 'July'
 d = 15
 y = 2005
 day.y.m.d = 'Friday'

Plusieurs éléments de queue numériques peuvent être utilisés pour fournir l'effet d'un tableau multidimensionnel.

Des fonctionnalités similaires aux variables composées Rexx se trouvent dans de nombreux autres langages (y compris les tableaux associatifs dans AWK , les hachages en Perl et les Hashtables en Java ). La plupart de ces langages fournissent une instruction pour parcourir toutes les clés (ou queues en termes Rexx) d'une telle construction, mais cela fait défaut dans le Rexx classique. Au lieu de cela, il est nécessaire de conserver des listes auxiliaires de valeurs de queue, le cas échéant. Par exemple, dans un programme de comptage de mots, la procédure suivante peut être utilisée pour enregistrer chaque occurrence d'un mot.

 add_word: procedure expose count. word_list
 parse arg w .
 count.w = count.w + 1 /* assume count. has been set to 0 */
 if count.w = 1 then word_list = word_list w
 return

puis plus tard :

 do i = 1 to words(word_list)
 w = word(word_list,i)
 say w count.w
 end

Au prix d'une certaine clarté, il est possible de combiner ces techniques en une seule tige :

 add_word: procedure expose dictionary.
 parse arg w .
 dictionary.w = dictionary.w + 1
 if dictionary.w = 1 /* assume dictionary. = 0 */
 then do
 n = dictionary.0+1
 dictionary.n = w
 dictionary.0 = n
 end
 return

et ensuite:

 do i = 1 to dictionary.0
 w = dictionary.i
 say i w dictionary.w
 end

Rexx ne fournit aucun filet de sécurité ici, donc si l'un des mots se trouve être un nombre entier inférieur, dictionary.0cette technique échouera mystérieusement.

Les implémentations récentes de Rexx, y compris l'Object REXX d' IBM et les implémentations open source comme ooRexx incluent une nouvelle construction de langage pour simplifier l'itération sur la valeur d'un radical ou sur un autre objet de collection tel qu'un tableau, un tableau ou une liste.

 do i over stem.
 say i '-->' stem.i
 end

Instructions relatives aux mots clés

PARSER

L' PARSEinstruction est particulièrement puissante ; il combine quelques fonctions utiles de gestion des chaînes. Sa syntaxe est :

 parse [upper] origin [template]

où origine spécifie la source :

• arg (arguments, à la queue de niveau supérieur de la ligne de commande)
• linein (entrée standard, par exemple clavier)
• pull (file d'attente de données Rexx ou entrée standard)
• source (informations sur la façon dont le programme a été exécuté)
• value(une expression) with: le mot with- clé est obligatoire pour indiquer où se termine l'expression
• var (une variable)
• version (numéro de version/version)

et le modèle peut être :

• liste de variables
• délimiteurs de numéro de colonne
• délimiteurs littéraux

upperest facultatif ; si spécifié, les données seront converties en majuscules avant l'analyse.

Exemples:

Utiliser une liste de variables comme modèle

 myVar = "John Smith"
 parse var myVar firstName lastName
 say "First name is:" firstName
 say "Last name is:" lastName

affiche les éléments suivants :

 First name is: John
 Last name is: Smith

Utilisation d'un délimiteur comme modèle :

 myVar = "Smith, John"
 parse var myVar LastName "," FirstName
 say "First name is:" firstName
 say "Last name is:" lastName

affiche également les éléments suivants :

 First name is: John
 Last name is: Smith

Utilisation des délimiteurs de numéro de colonne :

 myVar = "(202) 123-1234"
 parse var MyVar 2 AreaCode 5 7 SubNumber
 say "Area code is:" AreaCode
 say "Subscriber number is:" SubNumber

affiche les éléments suivants :

 Area code is: 202
 Subscriber number is: 123-1234

Un modèle peut utiliser une combinaison de variables, de délimiteurs littéraux et de délimiteurs de numéros de colonne.

INTERPRÉTER

L'instruction INTERPRET évalue son argument et traite sa valeur comme une instruction Rexx. Parfois, INTERPRET est le moyen le plus clair d'effectuer une tâche, mais il est souvent utilisé lorsqu'un code plus clair est possible en utilisant, par exemple, value().

D'autres utilisations d'INTERPRET sont l'arithmétique de précision arbitraire (décimale) de Rexx (y compris les comparaisons floues), l'utilisation de l'instruction PARSE avec des modèles de programmation, des tableaux à racines et des tableaux clairsemés.

 /* demonstrate INTERPRET with square(4) => 16 */
 X = 'square'
 interpret 'say' X || '(4) ; exit'
 SQUARE: return arg(1)**2

Cela affiche 16 et sort. Étant donné que les contenus variables dans Rexx sont des chaînes, y compris des nombres rationnels avec des exposants et même des programmes entiers, Rexx propose d'interpréter les chaînes comme des expressions évaluées.

Cette fonctionnalité peut être utilisée pour transmettre des fonctions en tant que paramètres de fonction , telles que passer SIN ou COS à une procédure pour calculer des intégrales.

Rexx n'offre que des fonctions mathématiques de base telles que ABS, DIGITS, MAX, MIN, SIGN, RANDOM et un ensemble complet de conversions hexadécimales et binaires avec des opérations sur les bits. Des fonctions plus complexes comme SIN ont été implémentées à partir de zéro ou obtenues à partir de bibliothèques externes tierces . Certaines bibliothèques externes, généralement celles implémentées dans les langages traditionnels, ne prenaient pas en charge la précision étendue.

Les versions ultérieures (non classiques) prennent en charge les CALL variableconstructions. Avec la fonction intégrée VALUE, CALL peut être utilisé à la place de nombreux cas de INTERPRET. C'est un programme classique :

 /* terminated by input "exit" or similar */
 do forever ; interpret linein() ; end

Une "calculatrice Rexx" un peu plus sophistiquée :

 X = 'input BYE to quit'
 do until X = 'BYE' ; interpret 'say' X ; pull X ; end

PULLest un raccourci pour parse upper pull. De même, ARGest un raccourci pour parse upper arg.

Le pouvoir de l'instruction INTERPRET avait d'autres usages. Le progiciel Valor s'appuyait sur la capacité d'interprétation de Rexx pour implémenter un environnement POO . Une autre utilisation a été trouvée dans un produit Westinghouse inédit appelé Time Machine qui a pu récupérer complètement après une erreur fatale.

NUMÉRIQUE

 say digits() fuzz() form() /* => 9 0 SCIENTIFIC */
 say 999999999+1 /* => 1.000000000E+9 */
 numeric digits 10 /* only limited by available memory */
 say 999999999+1 /* => 1000000000 */

 say 0.9999999999=1 /* => 0 (false) */
 numeric fuzz 3
 say 0.99999999=1 /* => 1 (true) */
 say 0.99999999==1 /* => 0 (false) */

 say 100*123456789 /* => 1.23456789E+10 */
 numeric form engineering
 say 100*123456789 /* => 12.34567890E+9 */

 say 53 // 7   /* => 4   (rest of division)*/

 numeric digits 50
 n=2
 r=1
 do forever /* Newton's method */
 rr=(n/r+r)/2
 if r=rr then leave
 r=rr
 end
 say "sqrt" n ' = ' r

 numeric digits 50
 e=2.5
 f=0.5
 do n=3
 f=f/n
 ee=e+f
 if e=ee then leave
 e=ee
 end
 say "e =" e

SIGNAL

L'instruction SIGNAL est destinée aux changements anormaux dans le flux de contrôle (voir la section suivante). Cependant, elle peut être mal utilisée et traitée comme l' instruction GOTO trouvée dans d'autres langages (bien qu'elle ne soit pas strictement équivalente, car elle termine les boucles et autres constructions). Cela peut produire un code difficile à lire.

Gestion des erreurs et exceptions

Il est possible dans Rexx d'intercepter et de traiter les erreurs et autres exceptions, en utilisant l'instruction SIGNAL. Il existe sept conditions système : ERROR, FAILURE, HALT, NOVALUE, NOTREADY, LOSTDIGITS et SYNTAX. La gestion de chacun peut être activée et désactivée dans le code source à volonté.

Le programme suivant s'exécutera jusqu'à ce qu'il soit terminé par l'utilisateur :

 signal on halt;
 do a = 1
	 say a
	 do 100000 /* a delay */
	 end
 end
 halt:
 say "The program was stopped by the user"
 exit

Une instruction intercepte les utilisations de variables non définies, qui obtiendraient autrement leur propre nom (en majuscule) comme valeur. Quel que soit l'état de la condition, l'état d'une variable peut toujours être vérifié avec la fonction intégrée renvoyant VAR pour les variables définies. signal on novalueNOVALUESYMBOL

La VALUEfonction peut être utilisée pour obtenir la valeur des variables sans déclencher de NOVALUEcondition, mais son objectif principal est de lire et de définir des variables d' environnement , comme POSIX getenv et putenv.

Conditions

ERROR

RC positif à partir d'une commande système

FAILURE

RC négatif pour une commande système (par exemple, la commande n'existe pas)

HALT

Résiliation anormale

NOVALUE

Une variable non définie a été référencée

NOTREADY

Erreur d'entrée ou de sortie (par exemple, tentatives de lecture au-delà de la fin du fichier)

SYNTAX

Syntaxe de programme non valide ou autre condition d'erreur

LOSTDIGITS

Les chiffres significatifs sont perdus (ANSI Rexx, pas dans la deuxième édition TRL)

Lorsqu'une condition est gérée par SIGNAL ON, les variables système SIGLet RCpeuvent être analysées pour comprendre la situation. RC contient le code d'erreur Rexx et SIGL contient le numéro de ligne où l'erreur est survenue.

À partir de la version 4 de Rexx, les conditions peuvent obtenir des noms, et il existe également une CALL ONconstruction. C'est pratique si les fonctions externes n'existent pas forcément :

 ChangeCodePage: procedure /* protect SIGNAL settings */
 signal on syntax name ChangeCodePage.Trap
 return SysQueryProcessCodePage()
 ChangeCodePage.Trap: return 1004 /* windows-1252 on OS/2 */

Voir également

• ISPF
• XEDIT
• Comparaison des coques d'ordinateur
• Comparaison des langages de programmation

Les références

Lectures complémentaires

Liens externes

• La page d'accueil de Mike Cowlishaw
• Page de langue REXX chez IBM
• Association linguistique REXX
• Langage de programmation Rexx à Open Hub