 \chapter{Premiers Pas - Chapitre 2}

  Ce chapitre vous montre comment:  \begin{itemize}

  \item Démarrer ARexx
  \item    Sauvegarder des Programmes
  \item Stocker    des Programmes
  \item Lancer des Programmes d'exemple
        \end{itemize}
      \section{Démarrer ARexx}

  Pour commencer à utiliser ARexx, vous devez exécuter le programe RexxMast. Celui-ci peut
être lancé automatiquement  ou manuellement. Chaque fois qu'ARexx est démarré ou arrêté,
une fenêtre d'information apparaît.

  \section{Démarrer ARexx Automatiquement}
       Il y a deux méthodes pour démarrer ARexx automatiquement~:

 placer  l'icône de RexxMast
dans le répertoire "WBStartup" ou éditer le fichier "S:User-Startup" .

  Placer RexxMast dans le répertoire "WBStartup":
     \begin{enumerate}

  \item
   Ouvrez le répertoire "System".
   \item Faites
glisser l'icône "RexxMast" dans le répertoire "WBStartup".
\item Redémarrez votre Amiga.
       \end{enumerate}
        Editer le fichier "S:User-Startup"~:
             \begin{enumerate}
\item Ouvrez un éditeur   de  texte.
\item Ouvrez le fichier "S:User-Startup".
\item Saisissez "REXXMAST>NIL:".
\item Sauvegardez le fichier.
\item Redémarrez votre Amiga.
                       \end{enumerate}

    \section{Démarrer ARexx Manuellement}

  Il y a deux façons de démarrer RexxMast  manuellement : double-cliquez sur
l'icône "RexxMast" dans le Workbench ou lancez-le à partir du Shell. Les
utilisateurs de systèmes sans disque dur peuvent économiser de l'espace disque
en démarrant ARexx seulement quand ils en ont besoin.

  Démarrer RexxMast à partir du Workbench:
  \begin{enumerate}

  \item Ouvrez le répertoire "System".
  \item Double-cliquez
sur l'icône "RexxMast".

        \end{enumerate}

  Démarrer RexxMast à partir du Shell~:
    \begin{enumerate}

   \item Ouvrez un Shell.
    \item Saisissez  "REXXMAST>NIL:"  et appuyez sur [Entrée]
        \end{enumerate}



     Editer le fichier "S:User-Startup" :

       \begin{enumerate}

       \item Ouvrez un éditeur de texte.
       \item   Ouvrez le fichier
"S:User-Startup".
\item  Saisissez "REXXMAST>NIL:".
\item Sauvegardez le fichier.
\item  Redémarrez votre
Amiga.
        \end{enumerate}

     \section{A propos des Programmes ARexx}

  Les programmes ARexx sont habituellement stockés dans le répertoire "REXX:" (qui est
souvent assigné au répertoire "SYS:S").Bien que les programmes puissent être stockés dans
n'importe quel répertoire, les placer dans "REXX:"  présente plusieurs avantages:
\begin{description}

\item[$\bullet$] Vous pouvez exécuter les programmes sans avoir à saisir leurs
chemins d'accès complets.
\item[$\bullet$]  Tous les programmes ARexx sont placés au même endroit.
\item[$\bullet$] La plupart des applications cherchent
les programmes ARexx dans "REXX:".

\end{description}

  Comme vous pouvez placer un programme ARexx n'importe où, vous pouvez également le nommer
à votre convenance. Cependant, adopter une simple nomenclature rendra la gestion des
programmes plus facile . Les programmes exécutés à partir du Shell doivent avoir
l'extension ".rexx" pour les distinguer des fichiers lancés par d'autres applications.

\section{Exécuter des Programmes ARexx}

  La commande RX est utilisée pour exécuter un programme ARexx. Si  un chemin d'accès
complet précède le nom du programme, ce dernier est seulement recherché dans le répertoire
mentionné. Si aucun chemin d'accès n'est mentionné, le programme est recherché dans le
répertoire courant et dans "REXX:" .

  Tant que les programmes sont stockés dans le répertoire "REXX:" ,  vous n'aurez pas
besoin de mentionner l'extension ".rexx" dans le nom du programme. Autrement dit, saisir:

  \begin{center}
 \begin{verbatim}

RX Program.rexx

\end{verbatim}
 \end{center}

  est équivalent à:

      \begin{center}
   \begin{verbatim}

RX Program

\end{verbatim}
\end{center}

  Un petit programme peut directement être saisi sur une ligne de  commande en encadrant la
ligne du programme par des guillemets. Par exemple, le programme suivant enverra cinq
fichiers nommés myfile.1, ..., myfile.5 vers l'imprimante.

      \begin{center}
  \begin{verbatim}

verb RX "DO i=1 to
ADDRESS command `copy myfile.' | | i `prt:'; END"

  \end{verbatim}
        \end{center}

  Quand une application est compatible ARexx, vous pouvez exécuter les
programmes ARexx à partir des applications en sélectionnant une option de menu
ou en spécifiant une option de commande. Référez-vous à la documentation du
logiciel pour des informations supplémentaires.

  Les programmes ARexx peuvent être exécutés à  partir du Workbench en leur créant une
icône "projet" ou "outil". Vous devez donc préciser la commande RX comme outil par défaut
de votre icône. Dans la fenêtre d'information de l'icône, saisissez~:


           \begin{center}
\begin{verbatim}

Default Tool: SYS:Rexxc/RX

\end{verbatim}
        \end{center}


  Lorsque l'icône est activée, RX lance  RexxMast (si celui-ci n'est pas déjà actif). Il
exécute le fichier associé à l'icône comme un programme ARexx.

  ARexx gère deux types d'outils: "Console",  qui spécifie une fenêtre et "CMD", qui
indique une commande. Vous saisissez ces types d'outils dans la fenêtre d'information de
l'icône de la façon suivante:
                \begin{center}
\begin{verbatim}

Console=CON:0/0/640/200/Example/Close
CMD=rexxprogram

     \end{verbatim}
        \end{center}

   \section{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 étendue (Å, Æ, ß). 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é:
\begin{itemize}
\item Les lignes de commentaire
\item  Les règles d'espacement
\item La prise en
charge de la casse
\item L'utilisation d'apostrophes et de guillemets

\end{itemize}

  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.



 \subsection{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 (").

 \paragraph{ Programme 1. Amiga.rexx}

\begin{center}
\begin{verbatim}

  /*Un programme tout simple*/
SAY `Amiga. The Computer For the Creative Mind.'


\end{verbatim}
  \end{center}

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


          \begin{center}
  \begin{verbatim}

RX Amiga

        \end{verbatim}
        \end{center}

  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"~:
  \begin{verbatim}

 Amiga. The Computer for the Creative Mind.

  \end{verbatim}

                  \subsection{Age.rexx}

  Ce programme vous invite à saisir du texte et lit ce que vous avez saisi.

  \paragraph{Programme 2. Age.rexx}

      \begin{center}
  \begin{verbatim}

   /*Calcule l'âge en nombre de jours*/
SAY `Entrez votre âge:'
PULL age
SAY `Vous êtes vieux de ' age*365 `jours.'

        \end{verbatim}
        \end{center}


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

      \begin{center}
  \begin{verbatim}

RX age

        \end{verbatim}
        \end{center}


  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'utilisateur. 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.

                          \subsection{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 ".

  \paragraph{Programme 3. Calc.rexx}

      \begin{center}
  \begin{verbatim}

    /*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é.'

        \end{verbatim}
        \end{center}


  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
caractè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.

                   \subsection{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.

 \paragraph{Programme 4. Even.rexx}

      \begin{center}
  \begin{verbatim}

    /*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*/

        \end{verbatim}
        \end{center}


  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.


\subsection{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.

  \paragraph{Programme 5. Square.rexx}

      \begin{center}
  \begin{verbatim}

    /*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*/

        \end{verbatim}
        \end{center}


  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.

\subsection{Results.rexx}

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

  \paragraph{Programme 6. Results.rexx}

      \begin{center}
  \begin{verbatim}

    /*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

        \end{verbatim}
        \end{center}


  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.

   \subsection{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.

 \paragraph{Programme 7. Grades.rexx}

      \begin{center}
  \begin{verbatim}

    /*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

        \end{verbatim}
        \end{center}
