       \chapter{Déboguage}

  ARexx fournit des moyens d'analyse  et de déboguage au niveau du code "source". La
fonction d'analyse affiche les clauses sélectionnées dans un programme en exécution. Quand
une clause est analysée, son numéro de ligne, le texte "source" et les informations
associées sont affichées sur la console.

 Le système interne d'interruption permet à un programme ARexx de détecter
certains événements synchrones  ou asynchrones et de prendre le cas échéant des
mesures adéquates. Des événements telles qu'une erreur de syntaxe ou une requête
de pause externe qui pourrait conduire le programme à s'arrêter peuvent être
neutralisés pour que des corrections soient apportées.


       \section{Analyse}

 L'analyse permet de sélectionner quelles clauses du code "source" seront
analysées.  Elle possède deux indicateurs de modification qui contrôlent
l'inhibition de contrôle et l'analyse interactive. Les options d'analyse peuvent
être réduites à une lettre, qui peut être une des suivantes~:
\begin{description}
\item ALL

 Toutes les clauses sont analysées.

\item[BACKGROUND]

 Aucune analyse n'est effectuée et le programme peut être forcé en mode analyse
interactive.

\item[COMMANDS]

 Toutes les clauses de commande sont analysées avant d'être envoyées à l'hôte
externe.  Les codes retour non-nuls sont affichés sur la console.

\item[ERRORS]

 Les co mmandes qui génèrent un code retour non-nul sont analysées après  que la
clause ait été exécutée.

\item[INTERMEDIATES]

 Toutes les clauses sont analysées et les résultats intermédiaires affichés
pendant l'évaluation de l'expression. Cela concerne les valeurs extraites pour
les variables, les noms composés en extension et les résultats des appels de
fonction.

\item[LABELS]

 Toutes les clauses d'étiquettes sont analysées pendant leur exécution.  Une
étiquette sera affichée à chaque transfert de contrôle.

\item[NORMAL (Défaut)]

 Les clauses de commande avec un code retour dépassant le niveau  d'erreur en
cours sont analysées après l'exécution et un message d'erreur est affiché.

\item[OFF]

 L'analyse est désactivée.

\item[RESULTS]

 Toutes les clauses sont analysées avant l'exécution et le résultat final de
chaque expression est affiché. Les valeurs assignées aux variables par les
instructions ARG, PARSE ou PULL sont aussi affichées. Cette option est
recommandée pour les tests de vérification générale.

\item[SCAN]

 C'est une option spéciale qui analyse toutes les clauses et vérifie s'il y a
des erreurs, mais qui supprime l'exécution des clauses. Elle est utile pour un
filtrage préliminaire d'un programme nouvellement créé.
\end{description}

 Le mode d'analyse peut être défini en utilisant soit l'instruction TRACE  ou la
fonction intégrée TRACE(). L'analyse peut être sélectivement désactivée de
l'intérieur d'un programme pour éviter les parties déjà testées de ce programme.

 Chaque ligne d'analyse affichée sur la console est indentée pour montrer  le
niveau de contrôle (imbrication) effectif de la clause concernée; celui-ci est
identifié par un code spécial à trois caractères (voir
\textsc{Tab}. \ref{codesspeciaux}). Le code "source" de chaque clause est
précédé par son numéro de ligne dans le programme.

 Les résultats intermédiaires ou finaux d'expressions sont mis entre guillemets
afin que les blancs de début et de fin soient visibles.

       \begin{table}[h~!tpb]    \centering
                \caption{\footnotesize  Codes spéciaux à trois caractères}
                \label{codesspeciaux}
                \begin{tabular}{| l l|}\hline






 Code   &  Valeurs affichées  \\ \hline



 +++  &Erreur de commande ou de syntaxe    \\ \hline



 >C>  &Nom composé étendu              \\ \hline



 >F>    &Résultat d'un appel de fonction         \\ \hline



 >L>    &Clause d'étiquette                                  \\ \hline



 >O>  & Résultat d'une opération sur deux opérandes       \\ \hline



 >P>    &  Résultat d'une opération de préfixe       \\ \hline



 >U>   &  Variable non initialisée                            \\ \hline



 >V>  & Valeur d'une variable                                \\ \hline



 >>>  & Résultat d'expression ou de modèle                 \\ \hline



 >.>   & Valeur de jeton de la "marque de réservation"         \\ \hline

  \end{tabular}
                \end{table}
  


 \subsection{Résultat d'analyse}

 Le résultat d'analyse d'un  programme est toujours dirigé vers un des deux flux logiques.
L'interpréteur vérifie d'abord s'il y a un flux nommé STDERR et s'il existe y dirige le
flux.

 Sinon, le résultat d'analyse est envoyé vers  le flux de sortie standard STDOUT et y sera
intercalé avec la sortie console usuelle du programme. Les flux STDERR et STDOUT peuvent
être ouverts et fermés sous le contrôle du programme, le programmeur a donc le contrôle
total sur la destination du résultat d'analyse.

 Dans certains cas un programme peut ne pas avoir de  flux de sortie prédéfini. Par
exemple, un programme qui a été appelé par une application serveur qui n'a pas fourni de
flux d'entrée/sortie n'aura pas de sortie sur console. Pour fournir une capacité d'analyse
à ces programmes, le processus résident peut ouvrir une console spéciale d'analyse
utilisable par tout programme actif. Quand cette console s'ouvre, l'interpréteur ouvre
automatiquement un flux nommé STDERR pour chaque programme ARexx qui n'a pas de flux STDERR
actuellement défini. Le programme redirige alors ces résultats d'analyse vers le nouveau
flux.

 Une console d'analyse globale peut être ouverte en utilisant l'utilitaire de  commande
TCO. Les programmes ARexx redirigeront automatiquement leur résultat d'analyse vers la
nouvelle fenêtre qui est ouverte comme une console AmigaDOS standard. L'utilisateur peut la
déplacer et la redimensionner à volonté.

 La console d'analyse sert aussi comme flux d'entrée pendant l'analyse  interactive. Quand
un programme attend une entrée d'analyse, celle-ci doit être faite dans la console
d'analyse. Bien que plusieurs programmes puissent utiliser la console d'analyse
simultanément, il est recommandé de n'en analyser qu'un seul à la fois.

 La console globale peut être fermée en utilisant la commande TCC.  La fermeture est
retardée jusqu'à ce que toutes les requêtes d'écriture vers la console aient été
satisfaites. C'est seulement quand tous les programmes actifs indiquent qu'ils n'utilisent
plus la console que celle-ci peut être fermée.


      \subsection{Inhibition de commandes}

 ARexx propose un mode d'analyse appelé inhibition de commandes,  qui supprime
les commandes serveurs. Dans ce mode, les clauses de commande sont évaluées de
manière normale, mais la commande n'est en fait pas envoyée au serveur externe
et le code de retour est mis à zéro. Cela permet de tester des programmes qui
envoient des commandes potentiellement destructrices, comme l'effacement de
fichiers ou le formatage de disques. L'inhibition de commandes ne s'applique pas
aux clauses de commande qui sont entrées interactivement. Ces commandes sont
toujours effectuées mais la valeur de la variable spéciale RC reste inchangée.

 L'inhibition de commandes peut être utilisée en conjonction avec n'importe
quelle option d'analyse. Elle est contrôlée par le caractère "!" qui peut
apparaître seul ou précéder n'importe quelle option alphabétique de TRACE.
Chaque occurrence du caractère "!" fait "basculer" le mode d'inhibition en
utilisation. L'inhibition de commandes est effacée quand l'analyse est
désactivée.

      \subsection{Analyse interactive}

 L'analyse interactive est un outil de déboguage qui permet à l'utilisateur
d'entrer  des instructions "sources" pendant l'exécution d'un programme. Ces
instructions peuvent être utilisées pour examiner ou modifier des valeurs de
variables, envoyer des commandes ou intéragir avec le programme. Toutes les
instructions de commande valides peuvent être entrées interactivement, avec les
mêmes règles et restrictions relatives à l'instruction INTERPRET. En
particulier, les instructions composées, telles DO et SELECT, doivent être
entièrement contenues dans la ligne introduite.

 L'analyse interactive peut être utilisée avec n'importe quelle option
d'analyse. En mode  interactif, l'interpréteur s'arrête après chaque clause
analysée et demande une entrée de l'utilisateur avec le code "+++". A chaque
pause, 3 types de réponses de l'utilisateur sont possibles~:

 \begin{description}
 \item[$\bullet$]Si une ligne vide
est entrée, le programme continue jusqu'au prochain point de pause.
 \item[$\bullet$] Si un
caractère "=" est entré, la clause précédente est exécutée encore une fois.
 \item[$\bullet$]Tout
autre entrée est traitée comme une instruction de déboguage et est analysée et
exécutée.
    \end {description}
 L'interpréteur se met en pause après les clauses analysables. Les options
d'analyse  détermine l'emplacement des pauses. L'interpréteur ne se met pas en
pause après les instructions CALL, DO, ELSE, IF, THEN et OTHERWISE. Quand une
clause génère un message d'erreur, l'interpréteur quitte le programme.

 L'analyse interactive est contrôlée par le caractère "?", seul ou en
combinaison avec  une option d'analyse alphabétique. Il est possible de faire
précéder une option par autant de caractères "?" que désirés. Chaque occurrence
fait alterner le mode en cours. Par exemple, si l'option d'analyse actuelle est
NORMAL, "TRACE ?R" active l'option RESULTS et sélectionne le mode d'analyse
interactive. Un autre appel à "TRACE ?R" désactive l'analyse interactive.

      \subsection{Traitement des erreurs}

 L'interpréteur ARexx permet le traitement des erreurs pendant le déboguage. Les
erreurs trouvées durant le déboguage interactif sont signalées mais n'entraîne
pas la fin du programme. Ce traitement spécial s'applique uniquement aux
instructions entrées interactivement.

 ARexx désactive également les indicateurs d'interruption interne pendant le
déboguag e interactif. Cela évite un transfert de contrôle accidentel dû à une
erreur ou à une variable non initialisée. Cependant, si une instruction "SIGNAL
label" est entrée, le transfert aura lieu et toute entrée interactive restante
sera abandonnée. L'instruction SIGNAL peut encore être utilisée pour modifier
les indicateurs d'interruption et les nouveaux paramètres prennent effet quand
l'interpréteur retourne au mode de traitement normal.

 Chaque tâche ARexx initialise son niveau d'échec en fonction du niveau d'échec
du client  (habituellement 10) pour supprimer l'affichage des erreurs
inopportunes. Le niveau d'échec peut être modifié en utilisant OPTIONS FAILAT.
Les erreurs de commande (RC > 0) et les échecs (RC >= FAILAT) peuvent être
piégés séparément en utilisant SIGNAL ON ERROR et SIGNAL ON FAILURE.

      \subsection{L'indicateur d'analyse externe}

 ARexx possède un indicateur d'analyse externe utilisé pour forcer les
programmes dans le mode d'analyse interactive.  Quand cet indicateur d'analyse
est activé en utilisant l'utilitaire de commande TS, tout programme n'étant pas
déjà en mode d'analyse interactive y entre immédiatement. L'option d'analyse
interne prend la valeur RESULTS à moins qu'elle ne soit déjà définie comme
INTERMEDIATES ou SCAN, auquel cas elle reste inchangée. Les programmes invoqués
pendant que l'indicateur d'analyse externe est activé commenceront leur
exécution en mode d'analyse interactive.

 L'indicateur d'analyse externe offre la possibilité de reprendre le contrôle
sur des programmes en boucle  ou ne répondant plus. Une fois qu'un programme
entre en mode d'analyse interactive, l'utilisateur peut examiner les
instructions une à une et diagnostiquer le problème. L'analyse externe étant un
indicateur global, tous les programmes actifs y sont soumis. L'indicateur
d'analyse reste activé jusqu'à ce qu'il soit supprimé en utilisant l'utilitaire
de commande TE. Chaque programme conserve une copie interne du dernier état de
l'indicateur d'analyse et la désactive quand il observe que l'indicateur
d'analyse a été supprimé. Les programmes en mode d'analyse BACKGROUND ne
répondent pas à l'indicateur d'analyse externe.

         \section{Interruption}

 ARexx gère un système d'interruption interne utilisé pour détecter et piéger
certaines conditions d'erreurs.  Quand une interruption est permise et que sa
condition correspondante est satisfaite, un transfert de contrôle vers
l'étiquette spécifique de cette interruption est effectué. Cela permet au
programme de garder le contrôle dans des circonstances qui pourraient le
conduire à se terminer. Les conditions d'interruption peuvent être causées soit
par des événements synchrones (comme une erreur de syntaxe), soit par des
événements asynchrones (comme une requête d'interruption [Ctrl]+[C]). Remarque:

 Ces interruptions internes sont complétement indépendantes du système
d'interruption  matériel géré par le système d'exploitation EXEC.

 Le nom assigné à chaque interruption est en fait l'étiquette à laquelle le
contrôle sera transféré.  Ainsi, une interruption SYNTAX transmettra le contrôle
vers l'étiquette "SYNTAX:". Les interruptions peuvent être activées ou
désactivées en utilisant l'instruction SIGNAL. Par exemple, l'instruction
"SIGNAL ON SYNTAX" activera l'interruption SYNTAX.

 Les interruptions supportées par ARexx sont les suivantes:
\begin{description}

 \item[BREAK$\_$C]

 Cette interruption intercepte (détecte et traite comme un signal et pas  comme
une sortie normale) une requête d'interruption [Ctrl]+[C] générée par AmigaDOS.
Si l'interruption n'est pas activée, le programme prend fin immédiatement avec
un message d'erreur "Execution halted" (interruption de l'exécution) et retourne
le code d'erreur 2.

  \item[BREAK$\_$D]

 Cette interruption intercepte une demande d'interruption [Ctrl]+[D] émise  par
AmigaDOS. La requête d'interruption est ignorée si l'interruption n'est pas
activée.

  \item[BREAK$\_$E]

 Cette interruption intercepte une demande d'interruption [Ctrl]+[E] émise  par
AmigaDOS. La requête d'interruption est ignorée si l'interruption n'est pas
activée.

  \item[BREAK$\_$F]

 Cette interruption intercepte une demande d'interruption [Ctrl]+[f] émise
  \item[ERROR]

 Cette interruption est générée par toute commande serveur qui retourne  un code
d'erreur non-nul.

  \item[HALT ]

 Une requête d'arrêt externe est interceptée si cette interruption est activée.
Autrement,  le programme prend fin immédiatement avec un message d'erreur
"Execution halted" (interruption de l'exécution).

  \item[IOERR]

 Les erreurs détectées par le système d'entrée/sortie  sont interceptées si
cette interruption est activée.

 \item[ NOVALUE]

 Une interruption intervient si une variable  non initialisée est utilisée
pendant que cette condition est activée. L'utilisation peut être à l'intérieur
d'une expression, dans l'instruction UPPER ou avec la fonction intégrée VALUE().

  \item[SYNTAX]

 Une erreur de syntaxe ou d'exécution  est générée par cette interruption.
Toutes les erreurs de ce type ne peuvent pas être interceptées. Certaines
erreurs arrivent avant qu'un programme ne soit exécuté et celles détectées par
l'interface externe d'ARexx ne peuvent pas être interceptées par l'interruption
SYNTAX.

 Quand une interruption impose  un transfert de contrôle, toutes les boucles de
contrôle actives sont démantelées et l'interruption qui a causé le transfert est
désactivée. Cette désactivation prévient une possible boucle d'interruption
récursive. Seules les structures de contrôle de l'environnement actuel sont
affectées, une interruption générée à l'intérieur d'une fonction n'affectera pas
l'environnement du programme d'appel.

  Deux variables spéciales sont   affectées quand une interruption intervient:

  \item[SIGL]

 Prend toujours le numéro de  ligne courant avant que le transfert de contrôle
ait lieu. Ceci permet de savoir quelle ligne du code "source" est exécutée.

  \item[RC]

 Prend la valeur du code  d'erreur à l'origine de la condition. Pour les
interruptions d'ERROR, cette valeur sera un code retour de commande et peut
habituellement être interprétée comme un niveau de gravité d'erreur. La valeur
des interruptions de SYNTAX est toujours un code d'erreur ARexx.

 Les interruptions sont  utiles pour la résolution des erreurs. Cela comprend
d'informer les programmes externes qu'une erreur est arrivée ou de donner
d'autres diagnostics permettant d'isoler le problème. Le programme 15 envoie une
commande "message" à un serveur externe appelé "MyEdit" chaque fois qu'une
erreur de syntaxe est détectée.   \end{description}

\paragraph{Programme 15.} Interrupt.rexx
 \begin{verbatim}

 /*Un programme macro pour `MyEdit`*/
SIGNAL ON SYNTAX /*Activer interruption*/
(processus normal)
EXIT
SYNTAX: /*Erreur de syntaxe détectée*/`
ADDRESS `MyEdit'
`message' `error' RC errortext (RC)
EXIT 10
\end{verbatim}