Cours gratuits » Cours informatique » Cours programmation » Cours NetRexx » Cours open-source NetRexx gratuitement

Cours open-source NetRexx gratuitement

Problème à signaler:

Télécharger



★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Cours open-source NetRexx avance

...

2.6 Exemples de Programmes

Les exemples suivants illustrent la façon d’utiliser ARexx pour afficher des chaînes de caractères sur votre écran, effectuer des calculs et activer les fonctionnalités de vérification d’erreur.

Les programmes peuvent être saisis dans n’importe quel éditeur de texte, comme ED ou MEmacs, ou traitement de texte. Sauvegardez vos programmes commes des fichiers "texte" au format ASCII si vous utilisez un traitement de texte. ARexx gère la table de caractères ASCII éten

due (Å, Æ, SS). Ces caractères étendus sont interprétés comme des caractères ordinaires et seront passés de minuscules en majuscules.

Les exemples illustrent également l’utilisation des bases de la syntaxe ARexx commeé :

– Les lignes de commentaire

– Les règles d’espacement

– La prise en charge de la casse

– L’utilisation d’apostrophes et de guillemets

Chaque programme ARexx est constitué d’une ligne de commentaire qui décrit le programme, et d’une instruction qui affiche le texte à l’écran. Les programmes ARexx doivent toujours commencer par une ligne de commentaire. Les /* (slash, astérisque) au début de la ligne et les */ (astérisque, slash) à la fin indiquent à l’interpréteur RexxMast qu’il a affaire à un programme ARexx. Sans les /* et * RexxMast ne reconnaîtra pas le fichier comme un programme ARexx. Une fois qu’il a commencé à exécuter le programme, ARexx ignore tous les autres commentaires du fichier. Cependant, les lignes de commentaire sont très utiles pour améliorer la lisibilité du programme. Ils peuvent aider à la structure et à la compréhension du programme.

2.6.1 Amiga.rexx

Ce programme vous montre comment utiliser SAY dans un bloc d’instructions pour afficher des chaînes de caractères à l’écran. Les instructions sont des clauses du langage qui indiquent une certaine action à effectuer. Celles-ci commencent toujours par un mot-clé. Dans l’exemple suivant, le mot-clé est SAY (les mots-clé sont toujours passés en majuscules lors de l’exécution du programme). Le SAY suivant est un exemple de chaîne. Une chaîne est une suite de caractères délimitée par des apostrophes (‘) ou des guillemets (").

Programme 1. Amiga.rexx

/*Un programme tout simple*/

SAY ‘Amiga. The Computer For the Creative Mind.’

Saisissez le programme ci-dessus et sauvegardez-le en "REXX :Amiga.rexx" . Pour lancer ce programme, ouvrez une fenêtre "Shell" et saisissez:

Bien que le chemin d’accès complet et le nom du programme soient "Rexx :Amiga.rexx", vous n’avez pas besoin de saisir le nom du répertoire "REXX :" ou l’extension ".rexx" si le programme a été sauvegardé dans le répertoire "REXX :" .

Vous devrez voir le texte suivant dans votre fenêtre "Shell" :

Amiga. The Computer for the Creative Mind.

2.6.2 Age.rexx

Ce programme vous invite à saisir du texte et lit ce que vous avez saisi. Programme 2. Age.rexx

/*Calcule l’âge en nombre de jours*/ SAY ‘Entrez votre âge:’

PULL age

SAY ‘Vous êtes vieux de ’ age*365 ‘jours.’

Sauvegardez ce programme en "REXX :Age.rexx" et exécutez-le avec la commande: RX age

Le programme commence par une ligne de commentaire qui décrit ce qu’il va faire. Tous les programmes commencent par un commentaire. L’instruction SAY affiche le texte d’invite à l’écran.

L’instruction PULL lit la ligne saisie par l’utilisateur, c’est-à-dire dans ce cas, l’âge de l’uti-lisateur. PULL lit la saisie, la passe en majuscules et la stocke dans une variable. Les variables sont des symboles qui peuvent contenir une valeur. Choisissez des noms de variables parlants. Cet exemple utilise le nom de variable "age" pour mémoriser le nombre saisi.

La dernière ligne multiplie la variable "age" par 365 et utilise l’instruction SAY pour afficher le résultat. La variable "age" ne doit pas être déclarée comme un nombre car sa valeur a été vérifiée quand elle a été utilisée dans l’expression. c’est un exemple de donnée non typée. Pour voir ce qui peut se passer si "age" n’est pas un nombre, essayez de lancer le programe avec une saisie non numérique pour l’âge. Le message d’erreur résultant vous affiche le numéro de ligne et le type d’erreur qui est survenu.

2.6.3 Calc.rexx

Ce programme vous présente l’instruction DO , qui répète l’exécution de lignes d’un programme. Il illustre également l’opérateur exponentiel (**). Saisissez ce programme et sauvegardez-le comme "REXX :Calc.rexx". Pour exécuter ce programme, utilisez la commande "RX calc ".

Programme 3. Calc.rexx

/*Calcule des carrés et des cubes.*/

DO i = 1 to 10 /*Début de la boucle - 10 itérations*/

SAY i i**2 i**3 /*Réalise les calculs*/

END /*fin de la boucle*/

SAY ‘Traitement terminé.’

La commande DO répète l’exécution des lignes de commande placées entre les instructions DO et END . La variable "i " est un indice pour la boucle qui est augmenté d’1 à chaque itération. Le nombre suivant le symbole TO est la limite pour l’instruction DO et pourrait être une variable ou une expression complexe plutôt que la simple constante 10.

Généralement, les programmes ARexx utilisent un seul espace entre les chaînes de carac-tères alphanumériques. Dans le programme 3, cependant, l’espacement n’est pas mentionné entre les caractères d’exponention (**) et les variables (i et 2, i et 3).

Les lignes d’instructions à l’intérieur de la boucle ont été indentées (décalées). Ce n’est pas requis par le langage, mais cela améliore la lisibilité du programme, parce que vous pouvez facilement visualiser où la boucle commence et où elle prend fin.

2.6.4 Even.rexx

L’instruction IF permet à des lignes de commande d’être exécutées conditionnellement. Dans cet exemple, les nombres de 1 à 10 sont classés comme paires ou impaires en les divisant par 2 et en analysant le reste. L’opérateur arithmétique // calcule le reste après une division.

Programme 4. Even.rexx

/*Paire ou impaire?*/

DO i = 1 to 10 /*Début de la boucle - 10 itérations*/

IF 1 // 2 = 0 THEN type = ‘even’

ELSE type = ‘odd’

SAY i ‘is’ type

END /*Fin de la boucle*/

La ligne IF indique que si le reste de la division de la variable "i " par 2 est égal à 0, alors on initialise la variable "type " à paire. Sinon, le programme n’exécutera pas la clause THEN et traitera la clause ELSE , initialisant la variable "type" à impaire.

2.6.5 Square.rexx

Cet exemple introduit le concept de fonction, un ensemble d’instructions exécutées dans un environnement adéquat en mentionnant le nom de la fonction. Les fonctions vous permettent de créer de grands programmes complexes à paritr de modules plus petits. Les fonctions permettent aussi d’utiliser le même code pour des opérations similaires dans différents programmes.

Les fonctions sont spécifiées dans une expression, un nom suivi d’une parenthèse ouvrante. (il n’y a pas d’espace entre le nom et la parenthèse.) Une ou plusieurs expressions, appelées paramètres, peuvent suivre la parenthèse. Le dernier paramètre doit être suivi d’une parenthèse fermante. Ces arguments passent des informations nécessaires à la fonction pour le traitement.

Programme 5. Square.rexx

/*Définir et appeler une fonction.*/

DO i = 1 to 5

SAY i square (i) /*Appelle la fonction "square"*/

END

EXIT

square: /*Nom de la fonction*/

ARG x /*Lit le paramètre*/

RETURN x**2 /*Renvoie le carré du paramètre*/

Démarrant avec DO et finissant avec END, une boucle est initialisée avec un index "i", qui sera augmenté d’1. La boucle sera répétée cinq fois. Elle contient une instruction qui appelle la fonction "square " quand l’expression est évaluée. Le résultat de la fonction est affiché en utilisant l’instruction SAY.

La fonction "square ", définie par les instructions ARG et RETURN , calcule le carré du paramètre. ARG charge la valeur du paramètre "i " et RETURN renvoie le résultat de la fonction à l’instruction SAY .

Une fois que le programme est appelé par la boucle, il recherche le nom de la fonction "square ", charge le paramètre "i ", réalise le calcul et retourne à la ligne suivante de la boucle DO/END . L’instruction EXIT arrête le programme après la dernière itération de la boucle.

2.6.6 Results.rexx

L’instruction TRACE active les caractéristiques de vérification d’erreur d’ARexx.

Programme 6. Results.rexx

/*Illustre la trace du programme "results" */

TRACE results

sum = 0 ; sumsq = 0;

DO i = 1 to 5

sum = sum + 1

sumsq = sumsq + i**2

END

SAY ‘sum=’ sum ‘sumsq=’ sumsq

L’écran affiche les lignes du source exécutées, chaque passage dans la boucle DO/END , et le résultat final de l’expression. En enlevant l’instruction TRACE vous afficherez seulement le résultat final: sum = 15 sumsq = 55.

2.6.7 Grades.rexx

Ce programme calcule la note finale d’un étudiant donné en se basant sur quatres essais et une participation en classe. La moyenne des essais 1 et 2 compte pour 30% de l’évaluation, la moyenne des essais 3 et 4 pour 45% et la participation pour 25%.

Une fois que la note est affichée, une option permettant de continuer avec un autre calcul est affichée. La réponse est "Chargée " (PULL) : si elle est différente de Q (quitter), la boucle continue. Si la réponse est égale à Q , le programme quitte la boucle et se termine.

Programme 7. Grades.rexx

/*Programme de notation*/

SAY "Bonjour, Je vais calculer la note finale pour toi."

Response = 0

DO while response ~ = "Q "/*On boucle tant que la réponse n’est pas Q*/

SAY "Saisis toutes les notes de l’étudiant."

SAY "Essai 1:"

PULL es1

SAY "Essai 2:"

PULL es2

SAY "Essai 3:"

PULL es3

SAY "Essai 4:"

PULL es4

SAY "Participation:"

PULL p

Final = (((es1 + es2)/2*.3) + ((es3 + es4)/2*.45) + (p*.25))

 SAY "La note finale de cet étudiant est " Final SAY "Veux-tu recommencer? (Q pour arrêter.)" PULL response

END EXIT

 Chapitre 3

Les Eléments de l’ARexx

Ce chapitre présente les règles et concepts qui fondent le langage de programmation ARexx et explique comment ARexx interprète les caractères et mots utilisés dans les programmes. Les différents éléments expliqués sont:

Le Mot -Le plus petit élément du langage ARexx

La Clause - la plus petite unité exécutable, semblable à des phrases L’Expression - un ensemble de mots interprétés

L’Interface de Commande - le processus par lequel les programmes ARexx communiquent avec les applications compatibles-ARexx

Ce chapitre inclut également une réflexion sur l’environnement d’exécution d’ARexx. Celle-ci est destinée aux utilisateurs de l’Amiga les plus expérimentés et présente des détails techniques sur la communication entre les processus..

3.1 Les mots

Les mots, les entités distinctes les plus petites du langage ARexx, peuvent être un simple caractère ou une suite de caractères. Il y a cinq catégories de mots :

– Les Commentaires

– Les Symboles

– Les Chaînes

– Les Opérateurs

– Les Caractères Spéciaux

3.2 Les Commentaires

Un commentaire est un groupe de caractères commençant par /* (slash, astérisque) et se terminant avec */ (astérisque, slash). Chaque programme ARexx doit commencer par un commentaire. Chaque /* doit être suivi d’un */ . Par exemple:

 /*C’est un commentaire ARexx*/

 Les commentaires peuvent être placés n’importe où dans un programme et peuvent même être inclus dans d’autres commentaires. Par exemple:

/*Un /*commentaire*/ inutile*/

N’hésitez pas à insérer des commentaires dans vos programmes. Ils vous rappellent les buts du programme, que ce soit ceux que vous avez fixés ou ceux définis par d’autres personnes. Comme l’interpréteur ignore les commentaires quand il exécute vos programmes, ceux-ci n’en sont pas ralentis lors de l’exécution.

3.3 Les Symboles

Un symbole est un groupe de caractères a-z, A-Z, 0-9, et point (.), point d’exclamation (!), point d’interrogation (?), signe dollar ($), et tiret-souligné (J. Les symboles sont passés en majuscules quand l’interpréteur exécute le programme, si bien que le symbole "MyName" est équivalent à "MYNAME". Les quatre types de symboles reconnus sont:

Les Symboles Fixes C’est une suite de caractères numériques qui commencent avec un chiffre (0-9) ou un point (.). La valeur d’un symbole fixe est toujours le nom du symbole lui-même, passé en majuscules. 12345 est un exemple de symbole fixe.

Les Symboles Simples C’est une suite de caractères alphabétiques qui commence avec une lettre A-Z. "MyName" est un exemple de symbole simple.

Les Racines C’est une suite de caractères alphanumériques qui se terminent avec un point. "A." et "Racine9." sont des exemples de racines.

Les Symboles Composés C’est une suite de caractères alphanumériques qui inclut un ou plusieurs points. "A.1.Index" est un exemple de symbole composé.

Les symboles simples, composés et les racines sont appelés variables et peuvent recevoir une valeur pendant l’exécution du programme. Si aucune valeur n’a été affectée à la variable, elle n’est pas initialisée. La valeur d’une variable non initialisée est le nom de la variable lui-même (passé en majuscules si cela est possible).

Les racines et symboles composés ont des propriétés spéciales qui les rendent utiles pour créer des tableaux et des listes. Les racines fournissent un moyen d’initialiser entièrement un symbole composé. Un symbole composé peut être considéré comme une structure de racines racine.n1.n2...nk, où le premier nom est une racine et chaque élément le suivant est un symbole simple ou fixe.

Quand une affectation est faite à une racine, la valeur est affectée à tous les symboles composés dérivés de celle-ci. La valeur d’un symbole composé dépend donc de sa première affectation ou de celle de sa racine associée.

Quand un symbole composé apparaît dans un programme, son nom est mis à jour en rem-plaçant chaque élément le composant par leur valeur courante. La valeur résultante peut être composée de n’importe quel caractère, dont des blancs, et ne sera pas passée en majuscules. Le résultat de la mise à jour est un nouveau nom qui sera utilisé à la place du symbole composé. Par exemple, si J a la valeur 3 et K la valeur 7, alors le symbole composé A.J.K deviendra A.3.7.

Les symboles composés peuvent être considérés comme un genre de mémoire associative ou adressable. Par exemple, supposons que vous ayez besoin de stocker et charger un ensemble de noms et de numéros de téléphone. Une approche conventionnelle serait d’initialiser deux tableaux NAME et NUMBER, chacun étant indexé par un entier allant de un au nombre d’oc-curences. Un numéro serait recherché via le tableau NAME jusqu’à ce que le nom donné soit trouvé, disons dans NAME.12, et puis en lisant NUMBER.12. Avec les symboles composés, le symbole NAME pourrait contenir le nom recherché, et NUMBER.NAME remplacerait le numéro associé, par exemple, NUMBER.CBM.

Les symboles composés aussi être utilisés comme des tableaux indexés conventionnels, avec l’avantage d’une seule affectation (de la racine) requise pour initialiser complêtement le tableau.

Par exemple, le programme ci-dessous utilise les racines "number." et "addr." pour créer un répertoire téléphonique électronique.

Programme 8. Phone.rexx

/*Un répertoire téléphonique pour illustrer les symboles composés.*/

IF ARG () ~ = 1 THEN DO

SAY "USAGE: rx phone name"

EXIT 5

END

/*Ouvre une fenêtre pour afficher les numéros de téléphones/adresses.*/

CALL OPEN out, "con:0/0/640/60/ARexx Phonebook"

IF ~ result THEN DO

SAY "L’ouverture a échoué ... désolé"

EXIT 10

END

/*Définitions de Number*/

number. = ‘(not found)’

number.wsh = ‘(555) 001-0001’

addr. = ‘(not found)’

number.CBM = ‘(555) 002-0002’

addr.CBM = ‘1200 Wilson Dr., West Chester, PA, 19380’

/*(Le traitement est effectué ici)*/

ARG name /*Le nom*/

CALLWRITELN out, name             " ‘s number est" number.name

CALL WRITELN out,name             " ‘s address est" addr.name

CALL WRITELN out, "Apppuyez sur [Entrée] pour quitter." CALL READLN out

EXIT

Pour exécuter le programme, activez une fenêtre "Shell" et saisissez:

RX Phone cbm

Une fenêtre affichera le nom et l’adresse affectés à CBM.

3.4 Les Chaînes

Une chaîne est n’importe quel groupe de caractères débutant et finissant par un apostrophe (‘) ou un guillemet ("). Le même délimiteur doit être utilisé aux deux extrémités de la chaîne. Pour inclure le caractère délimiteur dans la chaîne, doublez celui-ci (‘ ‘ ou ""). Par exemple:

"Le moment est venu."

Un exemple de chaîne standard. ‘L“image est chargée‘

Un exemple de chaîne comportant une apostrophe

La valeur d’une chaîne est la chaîne elle-même. Le nombre de caractères d’une chaîne est appelée sa longueur. Si la chaîne ne contient aucun caractère, elle est appelée chaîne vide.

Les chaînes qui sont terminées par un X ou un B sont respectivement identifiées comme des chaînes hexadécimales ou binaires qui doivent être composées de chiffres hexadecimaux (0-9, A-F) ou de chiffres binaires (0,1). Par exemple:

‘4A 3B C0’X

‘00110111’B

Les blancs sont autorisés dans les chaînes binaires pour améliorer la lisibilité. Les chaînes hexadécimales et binaires sont pratiques pour spécifier des caractères non ASCII et l’informa-tion spécifique à une machine, comme les adresses. Elles sont converties immédiatement dans une forme interne compressée propre à la machine.

3.5 Les Opérateurs

Les opérateurs sont une combinaison des caractères suivants :

~ + - * / = > < & | ^,

comme expliqué dans cette partie. Il y a quatre types d’opérateurs : Les opérateurs arith-métiques nécessitent une ou deux opérandes numériques et produisent un résultat numérique. Les opérateurs de concaténation joignent deux chaines de caractères en une. Les opérateurs de comparaison nécessitent deux opérandes et produisent un résultat booléen (0 :faux ou 1 :vrai). Les opérateurs logiques nécessitent une ou deux opérandes booléennes et produisent un résultat booléen.

Chaque opérateur a une priorité qui détermine l’ordre dans lequel les opérations sont exé-cutées dans une expression. Les opérateurs avec une priorité plus importante (8) sont exécutées avant ceux qui ont une priorité plus faible (1).

3.5.1 Arithmétiques

Une partie importante des opérandes représentent des nombres. Les nombres sont composés de caractères 0_9, de point (.), du signe plus (+), du signe moins (-), et de blancs. Pour indiquer une notation exponentielle, un nombre pourra être suivi "e" ou "E" et un entier (signé).

Les chaines et les symboles peuvent être utilisés pour spécifier des nombres. Puisque le langage est "non typé", les variables n’ont pas besoin d’être déclarées comme numériques avant de les utiliser dans des opérations arithmétiques. En effet, chaque variable est examinée quand elle est utilisée pour vérifier qu’elle représente bien un nombre. Les exemples suivants montrent tous des nombres valides :

" 12.3 " 0.321e12

‘ + 15. ‘

Les blancs situés au début ou en fin sont autorisés. Les blancs peuvent être insérés entre un signe plus (+) ou moins (-) et le nombre, mais pas dans le nombre lui-même.

Vous pouvez modifier la précision standard utilisée pour les calculs arithmétiques lors de l’exécution d’un programme. Le nombre de chiffres significatifs utilisé dans les opérations arithmétiques est déterminé par la valeur des chiffres et peut être modifié en utilisant l’instruction NUMERIC décrite dans le chapitre 4.

Le nombre de décimales utilisées dans un résultat dépend de l’opération et du nombre de décimales dans les opérandes. ARexx prend en compte les zéros de fin pour indiquer la précision du résultat. Si le nombre total de chiffres requis pour exprimer une valeur dépasse la précision actuelle des nombres, le nombre est affiché sous forme exponentielle. Qui sont : La notation Scientifique - l’exposant est initialisé de façon à ce que seul un chiffre soit placé à gauche du point décimal. La notation ingénieur - le nombre est modifié de façon à ce que l’exposant soit un multiple de 3 et les chiffres à gauche du point décimal soient compris entre 1 et 999.

TAB. 3.1 – Les opérateurs arithmétiques

Opérateur          Priorité Exemple              Résultat

+ (conversion du préfixe)           8             ‘3.12’     3.12

- (préfixe de négation) 8             -"3.12 " -3.12

** (exponentiation)      7             0.5**3  0.125

* (multiplication)             6             1.5*1.50              2.250

/ (division)          6             6 / 3       2

(division entière)            6             -8 % 3    -2

// (reste)            6             5.1//0.2               7.15

+ (addition)        5             3.1+4.05              7.15

-(soustraction) 5             5.55 - 1 4.55

3.5.2 Opérateurs de Concaténation

ARexx définit deux opérateurs de concaténation. Le premier, identifié par la séquence d’opérateurs || (deux barres verticales), joint deux chaines en une seule sans insérer de blancs. Ce type de concaténation peut être spécifié implicitement. Quand un symbole et une chaine sont saisis sans être séparés par des blancs, ARexx l’interprète comme si l’opérateur || avait été spécifié. La seconde opération de concaténation est le blanc inséré entre deux chaines qui les joint en une.

La priorité de toutes les opérations de concaténation est 4. Le tableau (??) résume les différentes opérations.

TAB. 3.2 – Les opérateurs de concaténation

Opérateur          Opération           Exemple              Résultat

||           Concaténation  ‘pourquoi moi, ‘||’Maman ?’    pourquoi moi, Maman?

Blanc     Concaténation de Blancs             ‘bon"temps’      bon temps

aucun   Concaténation implicite               un’deux’trois    UNdeuxTROIS

3.5.3 Comparaison

ARexx supporte trois types de comparaisons:

Comparaison totale - comparaison caractère par caractère.

Comparaison de chaînes - ignore les blancs en début de chaîne et ajoute des blancs à la fin de la chaîne la plus petite.

Comparaison Numérique - convertit les opérandes en représentations numériques internes

en utilisant la précision décimale définie puis effectue une comparaison numérique..

Les comparaisons renvoient toujours une valeur booléenne. Les nombres 0 et 1 sont utilisés pour représenter les valeurs booléennes "faux" et "vrai". L’utilisation d’une valeur autre que 0 et 1 pour une opération booléenne provoquera une erreur. Tout nombre équivalent à 0 ou 1 comme par exemple 0.000 ou 0.1E1, est aussi identifié comme une valeur booléeenne.

Tous les opérateurs de comparaison déterminent dynamiquement si une comparaison de nombres ou de chaînes de caractères va être réalisée, sauf pour les opérateurs d’égalité (==) ou d’inégalité ( ==). Une comparaison numérique est effectuée si les deux opérandes sont des nombres valides. Sinon les opérandes sont comparées en tant que chaînes.

Tous les opérateurs de comparaison ont une priorité de 3. Le tableau (3.3) répertorie les opérateurs de comparaison disponibles.

TAB. 3.3 – Les opérateurs de comparaison

Operateur          Opération           Mode

==          Egalité totale     Totale

==          Inégalité totale Totale

=             Egalité  Chaîne/Nombre

=             Inégalité              Chaîne/Nombre

>             Supérieur à        Chaîne/Nombre

>= ou < Supérieur ou égale à     Chaîne/Nombre

<             Inférieure à       Chaîne/Nombre

<= ou > Inférieur ou égale à       Chaîne/Nombre

3.5.4 Opérateurs logiques (booléens)

ARexx gère quatre opérations logiques, NOT, AND, OR, et OR exclusif, qui nécessitent toutes des opérandes booléens et produisent un résultat booléen. Toute tentative d’exécution d’une opération logique avec un opérande non booléen provoquera une erreur. Le tableau (3.4) affiche les opérateurs logiques créés.

TAB. 3.4 – Les opérateurs logiques

Opérateur          Priorité Opération

                8             NOT (Inversion)

&            2             AND

|             1             OR

or &&    1             OR exclusif

3.6 Caractères Spéciaux

 Caractères particuliers

:) Deux-points Les deux-points définissent une étiquette quand ils suivent un symbole (qui peut être un caractère alphanumérique ou . ! ? $).

( ) Parenthèses Les parenthèses sont utilisées pour grouper des opérateurs et opérandes dans des sous-expressions afin de changer les priorités classiques des opérateurs. Une paren-thèse ouvrante sert aussi à identifier une fonction à l’intérieur d’une expression. Un sym-bole ou une chaîne suivi imédiatement d’une parenthèse ouvrante définit un nom de fonction. Les parenthèses doivent toujours être couplées.

(;) Point-virgule Un point-virgule agit comme un symbole de terminaison. Des clauses courtes peuvent être regroupées sur la même ligne; elles doivent alors être séparées par des points-virgule.

(,) Virgule Une virgule agit comme caractère de continuation pour des instructions réparties sur plusieurs lignes et comme séparateur de paramètres dans l’appel des fonctions.

3.6.1 Les clauses

Les éléments les plus petits du langage pouvant être exécutés comme des instructions, sont formés par regroupement de mots.

Quand un programme est lu, l’interpréteur du langage divise le programme en groupes de clauses. Ces groupes d’une ou plusieurs clauses sont ensuite "cassées" en plusieurs mots et classées selon un type particulier. Attention, de légères différences syntaxiques peuvent changer complètement le contenu sémantique d’une instruction. Par exemple :

SAY ‘Hello, Bill’

est une instruction qui affichera "Hello, Bill" à l’écran, mais : ‘ ‘SAY ‘Hello, Bill’

est une commande "SAY Hello, Bill" qui sera envoyée à un programme externe. La présence d’une chaîne vide (‘ ‘) change la classification de la clause qui, étant une instruction, devient une commande.

La fin d’une ligne indique la fin implicite d’une clause. Une clause peut être continuée sur la ligne suivante en terminant la ligne avec une virgule. Celle-ci est ignorée par le programme et la ligne suivante est considérée comme la suite de la clause. Une clause peut être répartie sur autant de lignes que l’on souhaite, la seule limite étant la taille du tampon (buffer) de commande.

Les chaînes de caractères et les commentaires sont automatiquement prolongés si une ligne se termine avant que le délimiteur de fin ne soit trouvé et le caractère permettant de passer à la ligne (i.e., "Entrée") n’est pas considéré comme faisant parti du mot.

Clauses Vides Les clauses vides sont des lignes de blancs ou des commentaires qui peuvent apparaître n’importe où dans un programme. Elles n’ont pas de rôle dans l’exécution d’un pro-gramme à part améliorer sa lisibilité et augmenter le compteur de ligne.

Clauses "Etiquette" Une clause "étiquette" est un symbole suivi par un deux-points(:). Une étiquette est considérée comme un repère dans le programme mais il ne déclenche aucune action lors de son exécution. Les deux-points sont considérés implicitement comme fin de clause, donc chaque étiquette est une clause à part entière. Les clauses "étiquette" peuvent apparaître n’importe où dans un programme. Par exemple:

start: /*Début de l’exécution*/ syntax: /*Traitement d’erreur*/

Clauses d’Affectation Les clauses d’affectation sont identifiées par une variable suivie d’un opérateur "=". (Dans ce cas, la signification normale de l’opérateur "=", c’est-à-dire l’égalité, est ignorée.) Les mots à droite du "=" sont évalués comme une expression et le résultat est affecté à la variable. Par exemple :

When = ‘Le moment est venu’ answ = 3.14 * fact (5)

Le signe égal "=" affecte la valeur "Le moment est venu" à la variable "when", et affecte le résultat de "3.14 * fact(5)" à la variable "answ".

Clauses d’Instruction Les clauses d’instruction commencent avec le nom de l’instruction qui indique à ARexx d’effectuer une action. Les noms d’instruction sont décrits dans le chapitre 4. Par exemple :

DROP a b c SAY ‘please’

IF j > 5 THEN LEAVE;

Clauses de Commandes Les clauses de commande sont n’importe quelle expression ARexx qui ne peut être classée comme l’un des précédents types de clauses. L’expression est évaluée et le résultat est considéré comme une commande vers un hôte externe. Par exemple :

‘delete’ ‘myfile’ /*commande AmigaDOS*/ ‘jump’ current+10 /*commande d’un éditeur*/

La commande "delete" n’est pas reconnue comme une commande ARexx, elle est donc en-voyée à un serveur externe, en l’occurence l’AmigaDOS. La commande "jump" dans le second exemple est également interprétée par un serveur externe, en l’occurence un éditeur de texte.

3.7 Expressions

Les expressions sont un groupe de mots évalués. La plupart des lignes contiennent au moins une expression. Celles-ci sont composées de :

Chaînes - La valeur d’une chaîne est la chaîne elle-même.

Symboles - La valeur d’un symbole fixe est le symbole lui-même, passé en majuscules. Les symboles peuvent être utilisés comme des variables et peuvent se faire affecter une valeur.

Opérateurs - Les opérateurs ont une priorité qui détermine quand ils seront exécutés.

Parenthèses - Les parenthèses peuvent être utilisées pour modifier l’ordre d’évaluation dans une expression, ou pour identifier les appels de fonctions.

Un symbole ou une chaîne de caractères suivi immédiatement par une parenthèse ouvrante définit le nom de la fonction et les mots situés entre les parenthèses forme la liste des paramètres de celle-ci. Par exemple, l’expression :

J ‘factorial is’ fact (J)

                est composée de :

un symbole - J

un opérateur blanc

une chaîne - factorial is

un autre blanc

un symbole

fact

une parenthèse ouvrante

un symbole - J

une parenthèse fermante

 Dans cet exemple, FACT est le nom d’une fonction et "J" est sa liste de paramètre, la simple expression "J".

Avant l’évaluation d’une expression, ARexx doit obtenir une valeur pour chacun des sym-boles. Pour les symboles fixes, la valeur est le nom du symbole lui-même mais les symboles de variables doivent être recherchés dans la table courante des symboles. Dans l’exemple ci-dessus, si la valeur 3 avait été affectée au symbole "J", l’expression, après la correspondance des symboles, serait :

3 ‘factorial is’ FACT (3)

Pour éviter les ambiguités d’affectation des valeurs aux symboles pendant la phase de résolution, ARexx garantit un ordre strict de résolution allant de gauche à droite. La résolution des symboles s’effectue sans tenir compte de la priorité des opérateurs ou du regroupement par parenthèses. Si un appel de fonction est détecté, la résolution est suspendue pendant l’évaluation de la fonction. Un même symbole peut avoir plusieurs valeurs dans une expression.

Si l’exemple précédent a été revu ainsi :

FACT(J) ‘is’ J ‘factorial’

la seconde occurence du symbole "J" serait-elle toujours 3 ? En général, les appels de fonc-tion peuvent avoir des "effets de bord" qui permettent de modifier les valeurs de variables. Si l’exemple était revu, la valeur de "J" pourrait être modifiée par l’appel à

(1 = 2) & (FACT(3) = 6)

Après que toutes les valeurs de symboles soient résolues, l’expression est évaluée selon la priorité et les sous-expressions. ARexx ne garantit pas un ordre d’évaluation parmi les opéra-teurs de même priorité et n’utilise pas une évaluation "raccourcie" des opérations booléennes. Par exemple, dans l’expression :

(1 = 2) & (FACT(3) = 6)

l’appel de la fonction FACT sera effectuée même si le premier opérande de l’opération AND (&) est 0. Cet exemple met en valeur le fait qu’ARexx continuera à lire de gauche à droite, même si l’exemple donné est faux et retourne une valeur 0.

 3.8 L’interface de Commande

L’interface de commande ARexx est un port public de message. Les applications compatiblesARexx doivent avoir ce port de message. Les programmes ARexx délivrent des commandes en plaçant des chaines de caractères dans un message et en envoyant celui-ci vers le port de message du serveur. Le programme suspend son exécution tant que le serveur exécute les commandes et reprend dès que ce dernier lui renvoie un acquittement.

3.8.1 Les Adresses du Serveur

ARexx gère deux valeurs implicites du serveur : la valeur actuelle et la valeur précédente qui font partie de l’environnement de stockage du programme. Ces valeurs peuvent être modi-fiées à tout moment en utilisant l’instruction ADDRESS (ou son équivalent, SHELL). L’adresse courante du serveur peut être lue avec la macro-fonction ADDRESS(). La valeur par défaut de l’adresse serveur est REXX, mais celle-ci peut être mise à jour lors de l’appel d’un programme. La plupart des applications serveurs fourniront le nom de leur port public quand ils invoqueront un macro-programme, pour que celui-ci puisse automatiquement leur retourner des commandes.

Une adresse serveur particulière existe. La chaine COMMAND indique que la macro doit communiquer directement avec l’AmigaDOS. Toutes les autres adresses serveurs sont sensées se référer à un port public de message. Une tentative d’envoi d’une commande vers un port de message inexistant génèrera l’erreur de syntaxe " Host environment not found" (Environnement du serveur non trouvé).

Le programme 9 montre l’intéraction entre ARexx et l’éditeur d’AmigaDOS, ED. Le pro-gramme regarde si ED est en train de s’exécuter, détermine le nom du port de message, et initialise quelques variables de stockage.

Programme 9. ED status.rexx

/* Affiche l’état d’ ED. ED doit s’exécuter avant que ce programme ne soit lancé. les ports d’ED sont nommés ‘Ed’, ‘Ed_ 1’,

‘Ed_2’, et ainsi de suite.*/

DEFAULT_ED = "Ed "/*Ce nom est sensible à la casse*/

/*Procédure à suivre si ED ne s’exécute pas, ou si une seconde (ou plus) instance d’ED est en train de s’exécuter.*/

DO WHILE ~ SHOW (‘p’,DEFAULT_ED) /*Recherche du port*/

SAY "N’a pas pu trouvé le port nommé" DEFAULT_ED

SAY "Ports disponibles:"

SAY SHOW (‘P’) ‘0a’X

SAY "Entrez un nouveau nom de port, ou QUIT pour sortir

"/*Laissons l’utilisateur choisir le port si on ne peut pas le trouver*/

DEFAULT_ED = READLN(stdout)IF STRIP(UPPER(DEFAULT_ED)) =

‘QUIT’ then exit 10 /*L’utilisateur veut quitter l’application*/

END

SAY "Utilisation du port de ED " DEFAULT_ED

/*Maintenant que le port est trouvé, ARexx soit lui envoyer des données.*/

ADDRESS VALUE DEFAULT_ED

/* Initialise quelques variables racines bien utiles*/

STEM.0 = 15 /*Nombre de variables ARexx d’ED */

STEM.1 = ‘LEFT’ /*Marge gauche (SL)*/

STEM.2 = ‘RIGHT’ /*Marge droite (SR)*/

STEM.3 = ‘TABSTOP’ /*Réglage du pas des tabulations (ST)*/

STEM.4 = ‘LMAX’ /*Nombre maximum de lignes visibles à l’écran*/

STEM.5 = ‘WIDTH’ /*Largeur de l’écran en nombre de caractères*/

STEM.6 = ‘X’ /*Position horizontale X à l’acran (à partir de 1)*/

STEM.7 = ‘Y’ /*Position verticale Y à l’écran (à partir de 1)*/

STEM.8 = ‘BASE’ /*Position de la fenêtre*/

/*Base est 0 à moins que l’écran ne soit déplacé vers la droite*/

STEM.9 = ‘EXTEND’ /*Valeur de la marge supplémentaire (EX)*/

STEM.10 = ‘FORCECASE’ /*Indicateur de respect de la casse*/

STEM.11 = ‘LINE’ /*Numéro de ligne courant*/

STEM.12 = ‘FILENAME’ /*Fichier édité en ce moment*/

STEM.13 = ‘CURRENT’ /*Texte de la ligne courante*/

STEM.14 = ‘LASTCMD’ /*Dernière commande étendue*/

STEM.15 = ‘SEARCH’ /*Dernière chaine de recherche*/

/*Demande à ED de stocker ses valeurs dans la racine "STEM"*/

‘RV’ ‘/STEM/’ /*RV est une commande ED utilisée pour transférer de l’information d’ED vers ARexx*/

/*STEM.1 vaut LEFT, et STEM.LEFT contient maintenant une valeur issue de l’éditeur ED. C’est une façon d’afficher cette information.*/

DO i = 1 to STEM.0

ED_VAR = STEM.1

SAY STEM.1 "=" STEM.ED_VAR /*Affiche la valeur/variable de ED */ END

3.8.2 Créer une Macro

ARexx peut être utilisé pour écrire des programmes pour n’importe qu’elle application ser-veur contenant une interface de commande compatible. Des programmes sont développés avec un langage de macros encapsulées et peuvent intégrer plusieurs macro-commandes prédéfinies.

Identifiez les commandes "raccourcies" dans votre macro- programme. Certains programmes peuvent contenir des fonctions puissantes qui ont été conçues spécialement pour les utiliser dans les macro-programmes

 L’interprétation des commandes reçues dépend entièrement de l’application serveur. Dans le cas le plus simple, les chaines de commandes correspondront exactement aux commandes qui peuvent être saisies directement par un utilisateur. Par exemple, les commandes de contrôle du positionnement du curseur (haut/bas) d’un éditeur de texte auront probablement des inter-prétations identiques. Les autres commandes seront valides seulement si elles ont été générées à partir d’un macro-programme. Une commande de simulation d’une opération de menu ne sera probablement pas saisie par l’utilisateur. Dans le programme 10, le programme ARexx est appelé par ED pour inverser deux caractères.

/*La chaine à traiter est ‘123’, si le curseur est sur le 3,

la macro convertit la chaine en ‘213’.*/

HOST = ADDRESS() /*Détermine quel ED nous a appelé*/

ADDRESS VALUE HOST /*. . . et dialogue avec lui.*/

‘rv’ ‘/CURR/’ /*ED a mis l’information dans la racine CURR*/

/*Nous aurons besoin de deux informations:*/

currpos = CURR.X /*La position du curseur sur la ligne*/

currling = CURR.CURRENT /*Le contenu de la ligne courante*/

IF (currpos >2) /*Doit travailler sur la ligne courante*/

THEN currpos = currpos - 1

ELSE DO /*Notifie l’erreur et sort*/

‘sm /Le curseur doit être au moin en 2e position/’

EXIT 10

END

/*Doit inverser les caractères en position CURRPOS et

CURRPOS-1 et remplace la ligne courante avec la nouvelle.*/

DROP CURR. /*la racine CURR n’est plus nécessaire; on

libère de la mémoire*/

‘d’ /*Indique à ED de supprimer la ligne courante*/

currlin = swapch (currpos,currlin) /*Inverse les 2 caractères*/

‘i /’| |currlin| |’/ /*Insère la ligne modifiée*/

DO i = 1 to currpos /*Repositionne le curseur au début de la

ligne*/

‘cr’ /*la commande‘cursor right’ d’ED*/

END

EXIT /*Fin*/

/*Fonction d’inversion de deux caractères*/

swapch: procedure

PARSE ARG cpos,clin

chl = substr (clin, cpos, 1) /*Lit la caractère*/

clin = delstr (clin, cpos, 1) /*Le supprime de la chaine*/

clin = insert (chl,clin,cpos-2,1) /*Insérer pour créer l’inversion*/

RETURN clin /*Retour de la chaine modifiée*/

 Program 10. Transpose.rexx Pour lancer cet exemple à partir d’ ED, appuyez sur [Echapp] puis saisissez :

RX "transpose.rexx"

Vous pouvez également associer cette commande à une touche de fonction.

3.8.3 Codes Retour

Une fois qu’il a fini de traiter une commande, le serveur renvoie un code retour qui indique l’état de la commande. La documentation de l’application serveur doit décrire les différents codes retour pour chaque commande. Ces codes peuvent être utilisés pour déterminer si l’opé-ration exécutée par la commande l’a été correctement.

Le code retour est placé dans la variable spéciale RC d’Arexx pour qu’il puisse être examiné par la macro. Une valeur 0 indique que la commande s’est exécutée correctement. Le retour d’une entier positif indique une erreur. Plus celui-ci est élevé, plus l’erreur est grave. Le code retour permet au macro-programme de déterminer si la commande a réussi ou non et d’effectuer le traitement nécessaire.

3.8.4 Les Commandes Shell

Bien qu’ARexx a été conçu pour travailler efficacement avec des programmes qui supportent son interface spécifique de commandes, il peut être utilisé avec tout programme qui utilise des mécanismes standards d’entrée/sortie pour obtenir ses données. Une façon d’utiliser ARexx est de créer un fichier de commandes dans la Ram et de le passer directement au Shell. Le programme 11 ouvre un nouveau Shell pour exécuter un script standard EXECUTE.

Programme 11. Shell.rexx

/*Lancer un nouveau Shell*/

ADDRESS command

conwindow = "CON:0/0/640/100/NewOne/Close"

/*Créer un fichier de commandes*/

CALL OPEN out, "ram:temp",write

CALL WRITELN out, ‘echo "C”est un test"’

CALL CLOSE out

/*Ouvre une nouvelle fenêtre "Shell"*/

‘newshell’ conwindow quot;ram:temp"

EXIT

 3.9 L’Environnement d’Exécution

Remarque : Le contenu de cette partie est destinée aux utilisateurs expérimentés de l’Amiga. Cette information nécessite une bonne connaissance du système d’exploitation de l’Amiga et une habitude des manuels "ROM Kernel" de l’Amiga.

L’interpréteur ARexx, RexxMast, fournit un environnement d’exécution uniforme en lan-çant chaque programme comme un processus à part entière dans le système d’exploitation multitâche de l’Amiga. Cela fournit une interface souple entre un programme serveur externe et RexxMast. Le programme du serveur peut s’exécuter simultanément ou attendre la fin du programme interprété ARexx. chaque programme ARexx a non seulement un environnement interne mais aussi un environnement externe.

3.9.1 L’Environnement Externe

L’environnement externe englobe la structure du processus lui-même, ses flots d’entrée/sortie et le répertoire courant. Quand un processus ARexx est créé, il hérite des flots d’entrée/sortie et du répertoire courant de son client, le programme externe qui l’a invoqué. Par exemple, si un programme ARexx a été lancé depuis le Shell, il héritera du flot d’entrée/sortie et du répertoire courant de ce Shell. Le répertoire sera utilisé comme point de départ de toute recherche d’un programme ou de données. Les fonctions externes gèrent au plus 15 paramètres.


42