next up previous contents index
suivant: Avoir un arrêt momentané monter: Le debuggeur précédent: Le debuggeur   Table des matières   Index


Ouvrir le débuggeur : debug

debug a comme argument une fonction et ses arguments.
debug ouvre l'écran de la fenêtre de mise au point (ou débugger) avec sa barre de boutons. On a la possibilité : On tape par exemple :
debug(pgcd(15,25)).
Il faut bien sûr que le programme pgcd existe. Par exemple on a tapé :
pgcd(a,b):={
local r;
while(b!=0) {
r:=irem(a,b);
a:=b;
b:=r;
}
return a;
}
\begin{verbatim}
Puis si on veut observer les variables {\tt a} et {\tt b}, on clique sur 
{\tt watch} : {\tt watch(} s'inscrit dans la ligne {\tt eval} et on compl\'ete
cette ligne en {\tt watch(a)} puis {\tt enter}, puis on clique sur 
{\tt watch} et on compl\'ete {\tt watch(} en {\tt watch(b)} puis {\tt enter}.\\
Ensuite on clique sur {\tt sst}, et on voit \`a chaque \`etape (la ligne qui 
est ex\'ecut\'ee est en surbrillance) les valeurs de 
{\tt a} et {\tt b} dans la zone situ\'ee en dessous de la barre des boutons.
\subsection{Instruction du debuggeur : {\tt watch}}\index{watch}
\noindent{\tt watch} a comme argument le nom des variables que l'on d\'esire 
surveiller.\\
On tape par exemple :
\begin{center}{\tt watch(a,b)}\end{center}
On obtient :
\begin{center}{\tt l'\'evolution de a et de b lors du d\'eroulement du programme}\end{center}
\subsection{Instruction du debuggeur : {\tt rmwatch}}\index{rmwatch}
\noindent{\tt rmwatch} a comme argument le nom des variables que l'on ne
d\'esire plus surveiller.\\
On tape par exemple :
\begin{center}{\tt rmwatch(a,b)}\end{center}
On obtient :
\begin{center}{\tt l'\'evolution de a et de b lors du d\'eroulement du programmen'est plus visible}\end{center}
\subsection{Instruction du debuggeur : {\tt breakpoint}}\index{breakpoint}
\noindent{\tt breakpoint} a comme argument le num\'ero de la ligne o\`u l'on 
veut un point d'arr\^et.\\
On tape par exemple :
\begin{center}{\tt breakpoint(4)}\end{center}
On obtient :
\begin{center}{\tt cont() provoquera le d\'eroulement du programme et un arr\^et \`a la ligne 4}\end{center}
\subsection{Instruction du debuggeur : {\tt rmbreakpoint}}\index{rmbreakpoint}
\noindent{\tt rmbreakpoint} a comme argument le num\'ero de la ligne o\`u l'on 
ne veut plus un point d'arr\^et.\\
On tape par exemple :
\begin{center}{\tt rmbreakpoint(4)}\end{center}
On obtient :
\begin{center}{\tt le point d'arr\^et \`a la ligne 4 a \'et\'e effac\'e}\end{center}
\subsection{Instruction du debuggeur : {\tt cont}}\index{cont|textbf}
\noindent{\tt cont} n'a pas d'argument.\\
{\tt cont()}  est une instruction du debuggeur et permet de continuer un 
programme arr\^et\'e, par un point d'arr\^et, dans le debuggeur.\\
On tape :
\begin{center}{\tt cont()}\end{center}
On obtient :
\begin{center}{\tt le d\'eroulement du programme jusqu'au prochain point d'arr\^et}\end{center}
\subsection{Instruction du debuggeur : {\tt kill}}\index{kill|textbf}
\noindent{\tt kill} n'a pas d'argument.\\
{\tt kill()} est une instruction du debuggeur et permet de sortir du debuggeur.\\
On tape :
\begin{center}{\tt kill()}\end{center}
On obtient :
\begin{center}{\tt on sort du d\'ebuggeur}\end{center}
\subsection{Instruction en vue d'un debugage : {\tt halt}}\index{halt|textbf}
\noindent{\tt halt} n'a pas d'argument.\\
{\tt halt()} est une instruction dans un programme pour 
programmer un point d'arr\^et dans le debuggeur.\\
On tape dans un programme :
\begin{center}{\tt halt();}\end{center}
On obtient lors du debogage de ce programme :
\begin{center}{\tt un arr\^et du d\'eroulement du programme \`a cet endroit}\end{center}
\subsection{Utilisation des instructions du debuggeur : {\tt cont halt kill}}\index{cont}\index{halt}\index{kill}
\noindent{\tt cont halt kill} n'ont pas d'arguments.\\
{\tt cont halt kill} sont des instructions du debuggeur.\\
{\tt cont()} et {\tt kill()} s'utilisent uniquement dans une session de 
debogage, 
quand le programme est arr\^et\'e. Typiquement, {\tt kill()} s'utilise quand on
 a vu o\`u se trouve l'erreur, et que on va savoir corriger le programme, et 
qu'il est donc inutile de continuer l'ex\'ecution du programme  buggu\'e.\\
{\tt  cont()} s'utilise pour atteindre le point d'arr\^et suivant.\\
{\tt halt()} peut \^etre mis comme instruction dans le programme pour 
programmer un point d'arr\^et (cela \'evite de faire une commande 
{\tt breakpoint} avec un num\'ero de ligne)
Par exemple on tape :
\begin{verbatim}
testhalt(x):={
  local y; 
  y:=x;  
  halt();  
  return(y);  
}
On tape :
debug(testhalt(5))
On obtient :
l'ouverture du debuggeur et l'arrêt du programme
On tape :
cont() pour continurer le debugage ou kill() pour l'arrêter
Attention
Si on tape juste testhalt(5) sans mettre debug, le debuggeur s'ouvre mais, la liste des instructions formant le programme n'est pas affichée donc il vaut mieux faire debug(testhalt(5)) puis enlever les halt() quand le programme est au point.
next up previous contents index
suivant: Avoir un arrêt momentané monter: Le debuggeur précédent: Le debuggeur   Table des matières   Index
Documentation de giac écrite par Renée De Graeve