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é :
- d'exécuter le programme au pas
à pas avec le bouton sst qui inscrit la commande
sst() dans la ligne de commande,
- de mettre des points d'arrêts (breakpoint) avec
break (ou la commande breakpoint),
- d'aller directement aveccont à une ligne
précise marquée par un point d'arrêt (ou la commande cont),
- de voir avec watch les
variables que l'on désire surveiller (ou la commande watch),
- d'exécuter au pas à pas
les instructions d'une fonction utilisateur avec dans qui
inscrit la commande sst_in() dans la ligne de commande, ou encore
- de sortir brutalement du débuggeur avectuer (ou la commande kill).
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.
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