                      \chapter{Instructions}

  Une clause d'instruction débute avec un mot-clé particulier qui indique à  Arexx
d'effectuer une certaine action. Ce chapitre fournit une liste alphabétique des
instructions disponibles en Arexx.

  Chaque mot-clé d'une instruction peut être suivi d'une ou plusieurs options,
expressions, ou autres informations spécifiques à l'instruction. Les mots-clé d'instruction
et les options sont seulement interprétés dans ce contexte bien précis. Cela permet de les
utiliser dans un contexte différent comme des variables ou des noms de fonction. Un mot-cle
d'instruction ne peut pas être suivi par un deux-points ":" ou un opérateur d'égalité "=".



  \section{Syntaxe}

  La syntaxe de chaque instruction est indiquée à la droite de son mot-clé.  Les
conventions de syntaxe utilisées sont affichées dans le tableau 4-1:


     
       \begin{table}[h~!tpb]  \centering
                \caption{\footnotesize conventions syntaxiques}
                \label{NLLC}
                \begin{tabular}{| l |c|}\hline




  Convention &  Définition       \\    \hline

  MOT CLE     &    Tous les mots-clé et options sont affichés en majuscules     \\    \hline



  | (barre verticale)   & Les différentes alternatives possibles sont séparées par une barre verticale      \\    \hline



  $\{ \}$ (accolades)  &  Les différentes alternatives possibles sont placées entre accolades                \\    \hline



  [ ] (crochets)    &   Les parties optionnelles d'une instruction sont placées entre crochets           \\    \hline

          \end{tabular}
                \end{table}



  \paragraph{Remarque}~:



  Les conventions syntaxiques ne s'appliquent pas aux lignes suivant
l'instruction. Elles   s'appliquent seulement aux termes affichés à la suite du
mot-clé.

  Par exemple, le format de l'instruction CALL est:
                \begin{verbatim}

CALL {symbole | chaîne} [expression] [,expression,...]

                        \end{verbatim}
                          Vous devez fournir un symbole ou une chaîne comme
paramètre.  La barre verticale identifie les différents choix (alternatives)
possibles et les accolades indiquent que l'utilisation d'un paramètre est
requise. La spécification d'une expression est optionnelle, comme l'indiquent
les crochets.

  Des exemples sont présents à la suite de la nomenclature de l'instruction.
Les explications ou évaluations des exemples sont affichées comme des
commentaires ARexx /*...*/.


    \section{Index Alphabétique}

  Cette section contient une liste alphabétique des instructions d'ARexx. .


\paragraph{ADRESS}
  ADDRESS [[symbole | chaîne] |[VALUE][expressions]]  \\ \medskip{}

Cette instruction spécifie une adresse
serveur pour les commandes traitées par l'interpréteur. Une adresse serveur est
le nom du port de message d'une application vers lequel les commandes ARexx sont
envoyées. ARexx gère deux adresses serveurs : une actuelle (courante) et une
précédente (mémoire). Quand une nouvelle adresse serveur est fournie, l'adresse
précédente est effacée et remplacée par l'ex-adresse courante. Ces adresses
serveurs font partie de l'environnement de stockage du programme et sont
préservées pendant les appels de fonctions internes. L'adresse courante peut
être lue par la fonction ADDRESS().

  Le mot-clé ADDRESS seul intervertit les adresses serveurs courante et
précédente.  Un nouvel appel à cette fonction échangera à nouveau ces deux
adresses.
 \begin{verbatim}

ADDRESS {chaîne | symbole]}

       \end{verbatim}
  spécifie que la nouvelle adresse serveur est la chaîne ou le symbole.  La
valeur de la chaîne ou du symbole est le mot lui-même. Les noms de port de
message sont sensibles à la casse (les majuscules sont considérées comme
différentes des minuscules). La syntaxe appropriée d'une commande d'un programme
envoyée vers un port de message nommé "MonPort" est:
                   \begin{verbatim}

  ADDRESS `MonPort`

                    \end{verbatim}
  Si vous omettez les apostrophes encadrant "MonPort", ARexx  recherche le port
de message "MONPORT" et génère une erreur. L'adresse serveur actuelle reprend la
valeur de l'adresse précédente. Une expression placée après une chaîne ou un
symbole est évaluée et le résultat est envoyé au serveur indiqué. Aucun
changement n'est effectué sur les adresses courantes et précédentes. Cela permet
facilement d'envoyer une simple commande vers un serveur externe sans mettre à
jour les adresses serveurs. Le code retour de la commande est traité comme s'il
provenait d'une clause commande.

  Si l'expression ADDRESS [VALUE] est précisée, ARexx utilise  le résultat de
l'expression comme la nouvelle adresse serveur, et l'adresse courante devient
alors l'adresse précédente. Le mot-clé VALUE peut être omis si le premier mot de
l'expression n'est ni un symbole, ni une chaîne. \\Par exemple~:
     \begin{verbatim}

  ADDRESS /*Echange l'adresse serveur courante et l'adresse précédente.*/
ADDRESS edit /*La nouvelle adresse serveur est EDIT.*/
ADDRESS edit `top' /*Se positionne au début.*/
ADDRESS VALUE edit in /*Calcule une nouvelle adresse serveur.*/

    \end{verbatim}

\paragraph{ARG}   ARG [template] [,template...]     \\ \medskip{}


  ARG est une forme abrégée de l'instruction PARSE UPPER ARG.  Elle charge un ou
plusieurs des paramètres du programme et affecte les valeurs aux variables d'un
modèle. Le nombre de paramètres disponibles dépend de la façon dont le programme
a été appelé : comme une fonction ou comme une commande. Les invocations en tant
que commandes nécessitent normalement un seul paramètre alors que les fonctions
peuvent en avoir jusqu'à 15. Les paramètres ne sont pas modifiés par
l'instruction ARG. ARG renvoie un résultat en majuscules. \\Par exemple~:
               \begin{verbatim}

ARG first,second /*Charge les paramètres*/

       \end{verbatim}
  La structure et le fonctionnement des modèles est décrit brièvement lors de la présentation de l'instruction PARSE .

\paragraph{BREAK}      BREAK   \\ \medskip{}

   L'instruction BREAK est utilisée pour sortir d'un bloc DO ou d'une commande
INTERPRETEE.  Elle est valide seulement dans ces deux contextes. Si BREAK est
utilisée dans un bloc DO, elle permet de quitter le niveau le plus imbriqué du
DO qui la contient. Cela s'oppose au fonctionnement de l'instruction similaire
LEAVE, qui permet seulement de quitter une seule boucle (itérative) DO. Par
exemple:

    \begin{verbatim}

  DO /* Début du bloc*/
IF i>3 THEN BREAK /*Terminé ?*/
a = a + 1
y.a = name
END /*Fin du bloc*/

   \end{verbatim}

    \paragraph{CALL}  CALL {symbole | chaîne} [expressions] [,expression, ...]
\\ \medskip{}

   L'instruction CALL est utilisée pour appeler une fonction interne ou externe.
Le nom de la fonction est spécifié par un symbole ou une chaîne de caractères.
Toute expression suivant le CALL est évaluée et devient un paramètre de la
fonction appelée. La valeur retournée par la fonction est affectée à la variable
particulière RESULT. Ce n'est pas une erreur si aucun résultat n'est retourné.
Dans ce cas, la variable RESULT n'est pas prise en compte (elle devient
non-initialisée).

  Le lien à la fonction est établi dynaiquement au moment de l'appel.  ARexx
suit un ordre de recherche spécifique pour réussir à localiser la fonction
appelée. \\Par exemple~:
     \begin{verbatim}

CALL CENTER name, length+4, `+'

         \end{verbatim}
          CENTER est la fonction appelée. Les expressions seront évaluées et
passées  comme des paramètres à CENTER.



  \paragraph{DO}   DO [[var=exp] | [exp] [TO exp] [BY exp]] [FOR exp] [FOREVER]
[WHILE exp | UNTIL exp]    \\ \medskip{}

  L'instruction DO est placée au début d'un groupe d'instructions qui sera
exécuté comme un bloc.  La portée de l'instuction DO inclut toutes les lignes
suivantes jusqu'à une éventuelle instruction END.

  Si aucune option ne suit l'instruction DO, le bloc est exécuté une seule fois.
Les options  peuvent être utilisées pour répéter l'exécution du bloc jusqu'à ce
qu'une condition soit vérifiée. L'instruction DO est quelquefois appelée une
boucle puisque ARexx "réitère" pour exécuter répétivement des instructions. Les
différentes options de l'instruction DO sont:  Une expression d'initialisation
de la forme "variable=expression" définit la variable index de la boucle.
L'expression est évaluée quand l'instruction DO est activée pour la première
fois et le résultat est affecté à l'index. Dans les itérations suivantes, une
expression de la forme "variable = variable + incrément" est évaluée, où la
valeur de l'incrément est déterminé par l'option BY. S'il est spécifié,
l'expression d'initialisation doit précéder toutes les autres options.
L'expression suivant le symbole BY définit l'incrément à ajouter à la variable
index à chaque itération. L'espression doit être un nombre, qui peut être
positif ou négatif et n'est pas nécessairement un entier. L'incrément par défaut
est 1.  La valeur de l'expression TO spécifie la limite supérieure (ou
inférieure) de le la variable index. A chaque itération, l'index est comparé à
la valeur TO. Si l'incrément (valeur BY) est positif et que l'index est
supérieur à la limite, l'instruction DO se termine et le contrôle passe à la
ligne suivant l'instruction END. La boucle se termine également si l'incrément
est négatif et si l'index est inférieur à la limite.  L'expression FOR doit
contenir un nombre entier positif quand elle est évaluée : elle spécifie le
nombre maximum d'itérations. La boucle se termine lorque cette limite est
atteinte, sans tenir compte de la valeur de l'index.  Les expressions BY, TO et
FOR sont évaluées seulement quand l'instruction DO est pour la première fois
activée, si bien que les incréments et les limites sont constants durant
l'exécution de la boucle. La limite n'est pas obligatoire. \\Par exemple,
l'instruction "DO i=1" provoquera une exécution infinie de la boucle.  L'option
FOREVER peut être utilisée si une instruction DO itérative est requise et
qu'aucun index n'est nécessaire. La boucle se terminera par une instruction
LEAVE ou BREAK.  L'expression WHILE est évaluée au début de chaque itération et
doit être une valeur booléenne. L'itération continue si le résultat est 1
(vrai); sinon elle se termine.  L'expression UNTIL est évaluée à la fin de
chaque itération et doit être une valeur booléenne. La prochaine itération est
exécutée si le résultat est 0 (faux), et prend fin sinon. (WHILE et UNTIL ne
peuvent pas être utilisées simultanément.)



  \paragraph{Programme 12. Iteration.rexx}

      \begin{verbatim}

  /*Exemples d'utilisation de l'instruction DO*/
LIMIT = 20; number = 1
DO i=1 to LIMIT for 10 WHILE number < 20
number = 1 * number
SAY "Iteration" i "number=" number
END
number = number/3.345; i = 0
DO number for LIMIT/5
i = i + 1
SAY "Iteration" i "number=" number
END
     \end{verbatim}

  Le source est accompagné de commentaires explicatifs. Ceux-ci n'apparaitront pas à l'écran lors de l'exécution.
       \begin{verbatim}

  Iteration 1 number = 1 /*1 * 1 = 1*/
Iteration 2 number = 2 /*2 * 1 = 2*/
Iteration 3 number = 6 /*3 * 2 = 6*/
Iteration 4 number = 24 /*4 * 6 = 24*/
Iteration 1 number = 7.17488789 /*24/3.345 = 7.17488789*/
Iteration 2 number = 7.17488789 /*number ne change pas*/
Iteration 3 number = 7.17488789 /*limit/5 = 20/5 = 4*/
Iteration 4 number = 7.17488789 /*L'opération est répétée 4 fois*/

      \end{verbatim}


  \paragraph{Remarque}~:



  Si une limite FOR est aussi précisée, l'expression initiale est toujours évaluée, mais le résultat ne doit pas nécessairement être un entier positif.



     \paragraph{DROP}   DROP variable [variable ...]        \\ \medskip{}

  Les variables spécifiées redeviennent à l'état non-initialisée, dans lequel la valeur de la variable est le nom de la variable elle-même. DROPer une variable déjà à l'état non-initialisée ne provoque pas d'erreur. DROPer une racine équivaut à à DROPer toutes les valeurs des symboles composés associés. \\Par exemple~:
              \begin{verbatim}

a = 123 /*Affecte une valeur à la variable a */
DROP a b /*DROPe (efface) les valeurs des variables A et B*/
SAY a b /*Résultats dans A B.*/

       \end{verbatim}




     \paragraph{ ECHO}     ECHO [expression]      \\ \medskip{}

   L'instruction ECHO est similaire à l'instruction SAY. Il affiche à l'écran l'expression passée en paramètre. \\Par exemple~:
          \begin{verbatim}

 ECHO "tu ne dis rien"

      \end{verbatim}


   \paragraph{ ELSE}   ELSE [;] [instruction conditionnelle]  \\ \medskip{}



  L'instruction ELSE fournit une "branche" conditionnelle alternative pour une
instruction IF.  Elle est valide seulement si elle est associée à l'instruction
IF et elle doit suivre la "branche" THEN. Si la branche THEN n'est pas exécutée,
alors l'instruction suivant la clause ELSE est exécutée.

  Les clauses ELSE sont toujours liées à la clause IF précédente la plus proche.
Il peut être nécessaire de fournir des clauses ELSE factices pour des IF
imbriqués afin de pouvoir utiliser des branches conditionnelles de différent
niveau d'imbrication. Faire suivre la clause ELSE par un point-virgule ou une
clause vide ne suffit pas. Utilisez plutôt l'instruction NOP (no-operation). Par
exemple:

              \begin{verbatim}

IF i > 2 THEN SAY `Really?'
ELSE SAY `I thought so'

               \end{verbatim}


\paragraph{END}   END [variable]             \\ \medskip{}


  END est la dernière instruction d'une boucle DO ou SELECT. Si le  symbole de
variable facultatif est fourni, il est comparé à la variable d'index de
l'instruction DO (qui doit par conséquent être itérative). Une erreur est
générée si les symboles ne correspondent pas. \\Par exemple~:

\begin{verbatim}

  DO i=1 to 5 /*La variable d'index est i*/
SAY i
END i /*Fin de la boucle "i"*/

        \end{verbatim}


      \paragraph{EXIT}   EXIT [expression]          \\ \medskip{}

   L'instruction EXIT met fin à l'exécution d'un programme. Elle est valide
n'importe où dans un programme.  L'expression évaluée est renvoyée au programme
d'appel comme résultat de la fonction ou de la commande.

  Le traitement des résultats EXIT varie si une chaîne de résultats a été
requise par le programme d'appel et si l'appel en cours est le résultat d'un
appel de commande ou de fonction.  Si une chaîne de résultats a été requise, le
résultat de l'expression est copié sur un bloc de mémoire alloué et un pointeur
du bloc est renvoyé comme second résultat de l'appel.  Si un programme d'appel
n'a pas requis de chaîne de résultats et que le programme a été appelé comme
commande, la conversion du résultat de l'expression en nombre entier est alors
tentée. Cette valeur est ensuite renvoyée en tant que résultat principal (0 est
le résultat secondaire). Ceci permet à l'expression EXIT d'être interprétée
comme un code retour par l'appelant. \\



  Par exemple~:
                   \begin{verbatim}

EXIT /*Pas de résultat nécessaire*/
EXIT 10 /*Retour d'erreur*/

              \end{verbatim}


   \paragraph{IF}    IF expression [THEN] [;] [instruction conditionnelle]  \\ \medskip{}

  L'instruction IF est utilisée conjointement avec les instructions THEN et
ELSE pour réaliser une exécution conditionnelle d'une instruction. Le résultat
de l'expression doit être une valeur booléenne. Si le résultat est 1 (Vrai),
l'instruction qui suit le symbole THEN est exécutée. Sinon, le contrôle passe à
l'instruction suivante. Le mot-clé THEN ne doit pas nécessairement suivre
l'expression IF, mais il peut apparaître en tant que clause séparée.

  L'instruction est analysée comme "IF expression; THEN; instruction".
L'expression qui suit l'instruction IF établit la condition de test qui
détermine si les clauses THEN et ELSE suivantes seront exécutées. Toute
instruction valide peut suivre le symbole THEN. En particulier, un groupe "DO
... END;" permet d'exécuter une série d'instructions de façon conditionnelle.
\\Par exemple~:

\begin{verbatim}

  IF result < 0 THEN exit /*Terminé?*/

\end{verbatim}

    \paragraph{INTERPRET} INTERPRET expression        \\ \medskip{}

  La commande INTERPRET traite l'expression comme s'il s'agissait d'un bloc
d'instructions "source" de votre programme. L'expression est évaluée et le
résultat est exécuté comme une ou plusieurs instructions de programme. Les
instructions sont considérées comme un groupe, comme si elles étaient encadrées
par les instructions "DO ... END". Toute instruction peut être insérée dans la
source INTERPRETEE, y compris les instructions DO ou SELECT. L'instruction BREAK
peut être utilisée pour mettre fin au traitement des instructions INTERPRET.

  Lors de son exécution, INTERPRET place des limites de contrôle qui servent  de
frontières aux instructions LEAVE et ITERATE. Ces instructions ne peuvent par
conséquent être utilisées qu'avec des boucles DO définies à l'intérieur
d'INTERPRET. Même si inclure des clauses contenant des étiquettes à l'intérieur
de la chaîne interprétée n'est pas une erreur, seules les étiquettes définies
dans le code source sont recherchées au cours d'un transfert de contrôle.

  L'instruction INTERPRET peut être utilisée pour construire des programmes de
façon dynamique  et pour les exécuter. Des fragments de programmes peuvent être
passés comme paramètres à des fonctions qui les interprètent (INTERPRET). Par
exemple:   \begin{verbatim}

  inst = `SAY' /*Une instruction*/
INTERPRET inst hello /*. . . "DIRE HELLO"*/

      \end{verbatim}


    \paragraph{ITERATE}  ITERATE [variable]        \\ \medskip{}

  L'instruction ITERATE met fin à l'itération en cours  d'une instruction DO et
commence l'itération suivante. En effet, le contrôle passe à une instruction
END, puis (en fonction du résultat de l'expression UNTIL) le contrôle revient à
l'instruction DO. En principe, l'instruction ITERATE n'a d'effet que sur la
boucle d'itération qui la contient et qui est la plus imbriquée. Il y a erreur
si une instruction ITERATE ne se trouve pas à l'intérieur d'une boucle itérative
DO.

  Le symbole de variable optionnel spécifie la boucle DO que vous pouvez quitter
si plusieurs boucles  sont imbriquées. La variable est considérée comme
constante et elle doit correspondre à la variable d'index d'une instruction DO
active. Il y a erreur si une telle instruction DO est introuvable. \\Par exemple~:
\begin{verbatim}

  DO i=1 to 5
IF i = 3 THEN ITERATE i
SAY i
END

          \end{verbatim}


   \paragraph{LEAVE}      LEAVE [variable]  \\ \medskip{}

  LEAVE oblige à quitter immédiatement la boucle DO qui contient l'instruction.
Une erreur se produit si l'instruction LEAVE ne se trouve pas à l'intérieur
d'une boucle itérative DO. Le symbole de variable optionnel spécifie la boucle
DO que vous pouvez quitter si plusieurs boucles sont imbriquées. La variable est
considérée comme constante et elle doit correspondre à la variable d'index d'une
instruction DO active. Il y a erreur si une telle instruction DO est
introuvable. \\Par exemple~:

           \begin{verbatim}

  DO i = 1 to limit
IF i > 5 THEN LEAVE /*Iterations maximales*/
END

        \end{verbatim}

  \paragraph{NOP}     NOP \\ \medskip{}

   L'instruction NOP (NO-oPeration, c'est-à-dire pas d'opération)  permet de
contrôler la liaison de clauses ELSE dans les instructions IF composées. Par
exemple:           \begin{verbatim}

  IF i = j THEN /*Premier IF externe*/
IF j = k THEN a = 0 /*IF interne*/
ELSE NOP /*Liée à la boucle IF interne*/
ELSE a = a + 1 /*Liée à la boucle IF externe*/

       \end{verbatim}


   \paragraph{NUMERIC}   NUMERIC {DIGITS | FUZZ} expression NUMERIC FORM
{SCIENTIFIC | ENGINEERING}   \\ \medskip{}

L'instruction NUMERIC définit les options
concernant la précision numérique et le format. Les options numériques sont
maintenues lorsqu'une fonction interne est appelée.  L'option "DIGITS
expression" spécifie le nombre de chiffres significatifs pour les calculs
arithmétiques. L'expression doit correspondre à un nombre entier positif.
L'option "FUZZ expression" indique le nombre de décimales qui seront ignorées
lors des opérations de comparaison numérique. Il doit s'agir d'un nombre entier
positif inférieur au paramètre DIGITS en cours.  L'option "FORM SCIENTIFIC"
spécifie que les nombres nécessitant une notation exponentielle doivent être
exprimés en notation scientifique. L'exposant est ajusté afin que la mantisse
(pour les nombres différents de zéro) soit comprise entre 1 et 10. C'est la
syntaxe par défaut.  L'option "FORM ENGINEERING" sélectionne le format
ENGINEERING (technique) pour les nombres nécessitant une notation exponentielle.
Le format technique normalise un nombre afin que son exposant soit un multiple
de trois et que la mantisse (si elle est différente de 0) soit comprise entre 1
et 1000.


           \begin{verbatim}

  NUMERIC DIGITS 12 /*Précision de 12 chiffres*/
NUMERIC FORM SCIENTIFIC /*Résultat en notation scientifique*/

                 \end{verbatim}


  \paragraph{OPTIONS}
  OPTIONS [FAILAT expression] \\ \medskip{}
OPTIONS [PROMPT expression]  \\ \medskip{}
OPTIONS [RESULTS]                    \\ \medskip{}
OPTIONS [CACHE]                         \\ \medskip{}


  L'instruction OPTIONS est utilisée pour définir différentes valeurs internes
par défaut.  L'expression FAILAT détermine la limite à laquelle ou au-dessus de
laquelle les codes retour de commandes seront signalés comme des erreurs. Elle
doit avoir un nombre entier pour valeur. L'expression PROMPT vous permet de
disposer d'une chaîne que vous utiliserez en guise d'invite avec l'instruction
PULL (ou PARSE PULL). Le mot-clé RESULTS indique que l'interpréteur doit
demander une chaîne de résultats lorsqu'il envoie des commandes à un serveur
externe.

  Les options internes contrôlées par cette instruction sont maintenues d'un
appel  de fonction à un autre de façon à ce qu'une instruction OPTIONS puisse
être générée à l'intérieur d'une fonction interne sans affecter l'environnement
du programme d'appel. Si aucun mot-clé n'est spécifié avec l'instruction
OPTIONS, toutes les options contrôlées reprennent leurs valeurs par défaut.
L'instruction OPTIONS gère également un mot-clé NO qui permet de redonner à une
option sélectionnée sa valeur par défaut, ce qui facilite la redéfinition de
l'attribut RESULTS pour une seule commande sans avoir à redéfinir les options
FAILAT et PROMPT.

  OPTIONS gère également un mot-clé CACHE qui peut être utilisé pour activer  ou
désactiver un code interne de mise en mémoire cache de l'instruction. La mémoire
cache est généralement activée. \\Par exemple~:
       \begin{verbatim}

  OPTIONS FAILAT 10
OPTIONS PROMPT "Oui Chef?"
OPTIONS RESULTS

        \end{verbatim}




 \paragraph{OTHERWISE}   OTHERWISE [;] [instruction conditionnelle]      \\ \medskip{}

  Cette instruction n'est valide que si elle se trouve dans la boucle d'une
instruction  SELECT; elle doit faire suite à toutes les instructions "WHEN ...
THEN" . Si aucune des clauses WHEN précédentes n'a abouti, l'instruction qui
suit OTHERWISE est exécutée. L'instruction OTHERWISE n'est pas obligatoire dans
une boucle SELECT. Cependant, une erreur se produit si la clause OTHERWISE est
omise et qu'aucune des instructions WHEN n'aboutit. \\Par exemple~:

       \begin{verbatim}

  SELECT
WHEN i=1 THEN say `un'
WHEN i=2 THEN say `deux'
OTHERWISE SAY `autre'
END

  \end{verbatim}

  \paragraph{PARSE}   PARSE [UPPER] inputsource [modèle] [,modèle ...]  \\ \medskip{}

  L'instruction PARSE vous permet de disposer d'un mécanisme qui sert à extraire
des sous-chaînes d'une chaîne et à les affecter à des variables. La chaîne
d'entrée peut provenir de différentes sources, y compris de chaînes de
paramètres, d'une expression ou encore de la console.

  L'analyse syntaxique est contrôlée par un modèle qui peut se composer  de
symboles, de chaînes, d'opérateurs et de parenthèses. Le modèle fournit les deux
variables auxquelles des valeurs vont être attribuées, ainsi que la façon de
déterminer les chaînes de valeurs. Au cours de l'opération d'analyse syntaxique,
la chaîne d'entrée est divisée en sous-chaînes affectées aux symboles de
variables du modèle. Le traitement continue jusqu'à ce que toutes les variables
du modèle aient reçu une valeur. Lorsque la chaîne d'entrée est "épuisée",
toutes les variables restantes reçoivent des valeurs nulles.

  Lorsqu'une variable du modèle est suivie immédiatement d'une autre variable,
la chaîne  de valeurs est déterminée en divisant la chaîne d'entrée en mots
séparés par des espaces. Les espaces de début et de fin ne sont pas permis.
Chaque mot du modèle est affecté à une variable du modèle. En principe, la
dernière variable du modèle reçoit le reste de la chaîne d'entrée qui n'a pas
été affecté par les mots puisqu'elle n'est pas suivie par un symbole. Un symbole
de marque de réservation - un point (.) - oblige la variable avec le point à se
terminer au premier espace rencontré dans le flux d'entrée. Les marques de
réservation se comportent comme des variables, à la différence près qu'elles ne
reçoivent jamais de valeur effective.

  Le modèle peut être omis si l'instruction n'est censée créer que la chaîne
d'entrée.  Les modèles sont décrits au chapitre 7.

  Le but d'une opération d'analyse syntaxique est d'associer des positions
actuelle et ultérieure à chaque symbole de variable du modèle. La sous-chaîne
comprise entre ces positions est alors donnée comme valeur à la variable.

  Les différentes options de l'instruction sont décrites ci-dessous.   Le
mot-clé UPPER facultatif peut être utilisé avec toutes les sources d'entrée et
il spécifie que la chaîne d'entrée doit être mise en majuscules avant d'être
analysée. Ce doit être le premier mot immédiatement après PARSE.  Les sources
utilisées pour les chaînes d'entrée sont spécifiées par les symboles de mot-clé
décrits ci-dessous. Lorsque plusieurs modèles sont disponibles, chaque modèle
reçoit une nouvelle chaîne d'entrée, même si, pour certaines options "source",
la nouvelle chaîne est identique à la précédente. La chaîne "source" d'entrée
est copiée avant d'être analysée, si bien que les chaînes d'origine ne sont
jamais modifiées par le processus d'analyse.  L'option d'entrée ARG extrait les
chaînes de paramètres fournies lorsque le programme a été appelé. En principe,
les appels de commande ne disposent que d'une seule chaîne de paramètres, mais
les fonctions peuvent avoir jusqu'à 15 chaînes de paramètres.  La chaîne
d'entrée EXTERNAL est lue à partir du flux STDERR (cf. le chapitre 6) afin de ne
pas désorganiser les données traitées par les instructions PUSH et QUEUE. Si
plusieurs modèles sont fournis, chaque modèle lira une nouvelle chaîne. Cette
option "source" est la même que PULL.  L'option d'entrée NUMERIC place les
options numériques en cours dans une chaîne dans cet ordre: DIGITS, FUZZ et
FORM; elles sont séparées par un seul espace.  L'option d'entrée PULL lit une
chaine à partir de la console d'entrée. Si plusieurs modèles sont fournis,
chacun d'eux correspondra à une nouvelle chaîne.  L'option d'entrée SOURCE
récupère la chaîne "source" pour le programme. Cette chaîne est formatée de la
façon suivante~:\\ \medskip{}

  {COMMAND | FUNCTION} {0 | 1} CALLED RESOLVED EXT HOST  \\ \medskip{}

  où: \begin{description}
\item[$\{$COMMAND | FUNCTION$\}$] indique si le programme a été
appelé en tant que commande ou en tant que fonction.
\item[ $\{$0 | 1$\}$] est un indicateur
booléen qui détermine si une chaîne de résultats a été requise par le programme
d'appel.
\item[CALLED] est le nom utilisé pour appeler ce programme.
\item[RESOLVED] est le
nom final du programme converti.
\item[EXT] est l'extension qui sera utilisée pour la
recherche (la valeur par défaut est "REXX").
\item[HOST] est l'adresse serveur
initiale pour les commandes.
                     \end{description}
                     \medskip


  L'option SOURCE affiche désormais le chemin d'accès complet du fichier
programme ARexx.  Auparavant, seul un fichier d'accès relatif était donné, ce
qui ne suffisait pas pour localiser le fichier "source" du programme.

  La chaîne d'entrée "VALEUR expression WITH" est le résultat de l'expression
fournie. le mot-clé  WITH est nécessaire pour séparer l'expression du modèle. Le
résultat de l'expression peut être analysé plusieurs fois avec différents
modèles, mais l'expression n'est pas réévaluée.

  L'option d'entrée "VAR variable" utilise la valeur de la variable spécifiée
comme chaîne d'entrée.  Lorsque plusieurs modèles sont fournis, chaque modèle
utilise la valeur en cours de la variable. Cette valeur peut changer si la
variable est incluse dans un modèle en tant qu'objet d'affectation.

  L'option d'entrée VERSION de la configuration actuelle de l'interpréteur ARexx est fournie sous la forme suivante::
    \begin{verbatim}

 ARexx VERSION CPU MPU VIDEO FREQ

 \end{verbatim}

  où:

  VERSION correspond au numéro de version de l'interpréteur, formaté comme
la version 1.14.
  \begin{description}
\item[CPU] indique le processeur actuellement utilisé pour
l'exécution du programme; ce doit être l'une des valeurs suivantes: 68000,
68010, 68020, 68030 ou 68040.
\item[MPU] peut être NONE, 68881, ou 68882, selon qu'il
existe ou non un coprocesseur arithmétique.
\item[VIDEO] va indiquer NTSC ou PAL.
\item[FREQ] donne la fréquence de l'horloge: 60Hz or 50Hz.

     \end{description}


  Par exemple~:

  \begin{verbatim}

  /*Chaîne numérique: "9 0 SCIENTIFIC"*/
PARSE NUMERIC DIGITS FUZZ FORM .
SAY Digits /*9*/
SAY fuzz /*0*/
SAY form /*SCIENTIFIC*/
mavariable = 1234567890
PARSE VAR mavariable 1 a 3 b +2 c 1 d
SAY a
SAY b
SAY c
SAY d


  \end{verbatim}

  Voici le résultat:

  \begin{verbatim}

12
34
567890
1234567890

\end{verbatim}

   \paragraph{PROCEDURE}  PROCEDURE [EXPOSE variable [variable...]] \\ \medskip

 L'instruction PROCEDURE est utilisée avec une fonction interne pour créer une
nouvelle table de symboles.  Cette opération empêche les symboles définis dans
l'environnement du programme d'appel d'être modifiés par l'exécution de la
fonction. PROCEDURE est généralement la première instruction de la fonction,
bien qu'elle puisse être placée n'importe où dans le corps de la fonction.
L'exécution de deux instructions PROCEDURE dans la même fonction produit une
erreur.

  Le sous-mot clé EXPOSE fournit un mécanisme sélectif d'accès à la table des
symboles du programme d'appel et  de transmission des variables globales à une
fonction. Les variables qui suivent le mot-clé EXPOSE sont utilisées comme
références aux symboles de la table du programme d'appel. Toutes les
modifications apportées par la suite seront prises en compte dans
l'environnement du programme d'appel.

  Les variables de la liste EXPOSE peuvent comprendre des symboles racines ou
composés,  auxquels cas l'ordre des variables est important. La liste EXPOSE est
traitée de gauche à droite et les symboles composés sont étendus, en prenant
comme base les valeurs en vigueur dans la nouvelle génération. \\Par exemple,
supposons que la valeur du symbole "J" de la génération précédente soit fixée à
123 et que "J" ne soit pas initialisé dans la nouvelle génération. Alors,
PROCEDURE EXPOSEA.J exposera "J" et "A.123", tandis que PROCEDUREJ exposera
"A.J" et "J". Le fait d'exposer une racine a pour effet d'exposer tous les
symboles composés possibles à partir de cette souche, c'est-à-dire que PROCEDURE
EXPOSE A. expose "A.I", "A.J", "A.J.J", "A.123", etc. \\Par exemple~:

\begin{verbatim}

  fact: PROCEDURE /*Fonction récursive*/
ARG i
IF i = 1
THEN RETURN 1
ELSE RETURN i * fact (i-1)

\end{verbatim}

  \paragraph{PULL}     PULL [modèle] [,modèle...] \\ \medskip



  PULL est une abréviation de l'instruction PARSE UPPER PULL.  Elle lit une
chaîne à partir de la console d'entrée, la convertit en majuscules et l'analyse
à l'aide du modèle. Plusieurs chaînes peuvent être lues en ajoutant des modèles
supplémentaires. L'instruction sera lue à partir de la console, même si aucun
modèle n'est spécifié. La description détaillée des modèles se trouve au
chapitre 7. \\Par exemple~:


\begin{verbatim}

PULL first last . /*Lire les noms*/

\end{verbatim}

  \paragraph{PUSH}   PUSH [expression] \\ \medskip

  L'instruction PUSH permet de préparer un flux de données  devant être lu par
une commande Shell ou par un autre programme. Elle permet d'ajouter une
'nouvelle ligne' au résultat de l'expression, puis de l'empiler ou de la
"pousser" dans le flux STDIN. Les lignes empilées sont placées dans le flux,
dans l'ordre "dernier entré, premier sorti (LIFO)" ; elles sont alors prêtes à
être lues comme si elles avaient été entrées en mode interactif. \\Par exemple,
après avoir généré les instructions suivantes:


\begin{verbatim}

PUSH line 1
PUSH line 2
PUSH line 3

\end{verbatim}

  le flux sera lu dans l'ordre ligne 3, ligne 2 et ligne 1..

  PUSH permet d'utiliser le flux STDIN comme brouillon pour préparer les données
destinées à un traitement ultérieur.  \\Par exemple, il est possible de concaténer
plusieurs fichiers à l'aide de caractères de séparation en lisant simplement les
fichiers d'entrée, en poussant (PUSH) la ligne dans le flux et en insérant un
caractère de séparation à l'endroit voulu. \\Par exemple~:
\begin{verbatim}

DO i=1 to 5
PUSH `echo "Ligne `i'"'
END

\end{verbatim}

    \paragraph{QUEUE}  QUEUE [expression]   \\ \medskip

   L'instruction QUEUE est utilisée pour préparer un flux de données qu'un shell
ou un autre programme devront lire.  Cette instruction ressemble beaucoup à
l'instruction PUSH, à ceci près que les lignes de données sont placées dans le
flux STDIN dans l'ordre "premier entré, premier sorti (FIFO)". En l'occurence,
les instructions suivantes:

 \begin{verbatim}

QUEUE line 1
QUEUE line 2
QUEUE line 3

\end{verbatim}
  seront lues dans l'ordre ligne 1, ligne 2 et ligne 3. Les lignes mises en
attente (QUEUE) précèdent  toutes les lignes entrées en mode interactif et se
trouvent toujours après les lignes "poussées" (PUSH) ou empilées.

  \begin{verbatim}

  DO i=1 to 5
QUEUE `echo "Line `i'"'
END

\end{verbatim}

 \paragraph{RETURN}  RETURN [expression]    \\ \medskip

  RETURN sert à abandonner une fonction et  à rendre le contrôle au point de
l'appel de fonction précédent. L'expression évaluée est affichée en tant que
résultat de la fonction. Si une expression est omise, une erreur peut se
produire dans l'environnement du programme d'appel. Les fonctions appelées à
partir d'une expression doivent produire une chaîne de résultats et provoqueront
une erreur si aucun résultat n'est disponible. Les fonctions appelées par
l'instruction CALL ne doivent pas nécessairement donner un résultat.

  Une instruction RETURN produite par l 'environnement de base d'un programme
n'est pas une erreur et équivaut à une instruction EXIT. Reportez-vous à cette
instruction si vous souhaitez obtenir une description de la façon dont les
chaînes de résultats sont transmises à un programme d'appel externe. Par
exemple:
\begin{verbatim}

        RETURN 6*7 /*Donne 42*/

\end{verbatim}

  \paragraph{SAY}    SAY [expression]           \\ \medskip

  Le résultat de l'expression évaluée  apparaît sur la console de sortie,
assorti d'un caractère "newline" (nouvelle ligne). Si l'expression est omise,
une chaîne nulle est envoyée à la console. \\Par exemple~:

    \begin{verbatim}

  SAY `La réponse est ` value

\end{verbatim}

 \paragraph{ SELECT}  SELECT                          \\ \medskip

  SELECT est la première d'un groupe d'instructions contenant une ou plusieurs clauses WHEN et éventuellement une clause OTHERWISE , chacune d'elles étant suivie d'une instruction conditionnelle. Une seule des instructions conditionnelles du groupe SELECT sera exécutée. Chaque instruction WHEN est exécutée à tour de rôle jusqu'à ce que l'une d'entre elles aboutisse. Si elles échouent toutes, l'instruction OTHERWISE est exécutée. La boucle SELECT doit se terminer par une instruction END. \\Par exemple~:
     \begin{verbatim}

  SELECT
WHEN i=1 THEN SAY `un'
WHEN i=2 THEN SAY `deux'
OTHERWISE SAY `autre'
END

\end{verbatim}

 \paragraph{ SHELL}    SHELL [symbole 1 chaîne | [[VALEUR] [expression]]
\\ \medskip

  L'instruction SHELL est identique à l'instruction ADDRESS. \\Par exemple~:
        \begin{verbatim}

SHELL edit /*Fixer le serveur sur `EDIT'*/

\end{verbatim}

  \paragraph{SIGNAL}    SIGNAL {ON | OFF} condition SIGNAL [VALEUR] expression
\\ \medskip

  SIGNAL {ON | OFF} contrôle  l'état des indicateurs d'interruption interne. Les
interruptions permettent à un programme de détecter et de conserver le contrôle
lorsque certaines erreurs se produisent. Sous cette forme, SIGNAL doit être
suivi de l'un des mots-clé ON ou OFF, et de l'un des mots-clé donnés ci-dessous.
L'indicateur d'interruption spécifié par le symbole de condition est alors fixé
à l'état indiqué. Les conditions de signal valides sont les suivantes:

\begin{description}

\item BREAK$\_$C

 Une interruption [Ctrl]+[C] "Break" a été détectée.



\item  BREAK$\_$D



  Une interruption [Ctrl]+[D] "Break" a été détectée.



\item  BREAK$\_$E



  Une interruption [Ctrl]+[E] "Break" a été détectée.



\item  BREAK$\_$F



  Une interruption [Ctrl]+[F] "Break" a été détectée.



\item  ERROR



  Une commande serveur a affiché un code différent de zéro.



\item  HALT



  Une demande d'ARRET (HALT) externe a été détectée.



\item  IOERR



  Une erreur a été détectée par le système d'E/S (Entrées/Sorties).



\item  NOVALUE



  Une variable non initialisée a été utilisée..



\item  SYNTAX



  Une erreur de syntaxe ou d'exécution a été détectée.

 \end{description}
  Les mots-clé de la condition sont interprétés comme des étiquettes auxquelles
le  contrôle est transféré si la condition sélectionnée a lieu. \\Par exemple, si
l'interruption ERROR est activée et qu'une commande donne un code différent de
zéro, l'interpréteur transmettra le contrôle à l'étiquette ERROR:. L'étiquette
de condition doit bien évidemment être définie dans le programme. Dans le cas
contraire, une erreur de SYNTAXE (SYNTAX) immédiate a lieu et le programme
s'interrompt.

  Dans l'expression SIGNAL [VALEUR], les mots qui suivent SIGNAL sont évalués
comme des expressions.  Une interruption immédiate est générée et elle transmet
le contrôle à l'étiquette spécifiée par le résultat de l'expression.
L'instruction agit ainsi en tant que "computed goto". (Goto traîté)

  A chaque interruption, toutes les boucles de contrôle actives (IF, DO, SELECT,
INTERPRET ou TRACE interactif)  sont démantelées avant le transfert de contrôle.
Ainsi, le transfert ne peut pas être utilisé pour se brancher dans une boucle DO
ou dans une autre structure de contrôle. Seules les structures de contrôle de
l'environnement en cours sont affectées par une condition SIGNAL. Il n'y a donc
pas de risque lorsque vous utilisez l'instruction SIGNAL à partir d'une fonction
interne sans affecter l'état de l'environnement du programme d'appel.

  La variable spéciale SIGL est fixée au numéro de ligne en cours à chaque
transfert de contrôle. Le  programme peut inspecter SIGL pour déterminer la
ligne qui était exécutée au moment du transfert. Si une condition ERROR ou
SYNTAX provoque une interruption, la variable spéciale RC est fixée au code
d'erreur qui a déclenché l'interruption. Pour la condition ERROR, ce code
correspond généralement à un niveau de gravité d'erreur. Pour plus de détails
sur les codes d'erreur et les niveaux de gravité, reportez-vous à l'annexe A. La
condition SYNTAX indiquera toujours un code d'erreur "ARexx". \\Par exemple~:
  \begin{verbatim}

SIGNAL on error /*Interruption autorisée*/
SIGNAL off syntax /*SYNTAX Dévalidé*/
SIGNAL start /*Branchement à START*/

\end{verbatim}

\paragraph{WHEN}    WHEN expression [THEN [;] [instruction conditionnelle]]
\\ \medskip

  L'instruction WHEN est similaire à l'instruction IF, mais n'est valide qu'à
l'intérieur  d'un bloc SELECT. Chaque expression WHEN est évaluée
séquentiellement et doit donner un résultat booléen. Si le résultat est 1,
l'instruction conditionnelle est exécutée puis le contrôle passe à l'instruction
END qui termine le bloc SELECT. Comme avec l'instruction IF, THEN peut ne pas
faire partie de la même clause. \\Par exemple~:
    \begin{verbatim}

  SELECT
WHEN i<j THEN SAY `plus petit'
WHEN i=j THEN SAY `égal'
OTHERWISE SAY `plus grand'
END

\end{verbatim}


