Quand vous développez, faîtes une pause au bon moment !

Et non ! Ce n'est pas une pause pour vous, mais pour WinDev® Aujourd'hui, nous allons étudier les différentes mécaniques qui permettent de faire des points d'arrêt dans votre code.

tl;dr

Avec WinDev, il est possible de déclencher des points d'arrêt de plusieurs manières. Il y a bien sûr le point d'arrêt traditionnel (la petite pastille rouge) qui est paramétrable ainsi que la commande STOP qui permet de déclencher un point d'arrêt dans le code.

On peut activer ou désactiver des points d'arrêts via la recherche, on peut aussi désactiver ou lister tous les points d'arrêts en quelques clics.

Je décris une méthode permettant de faire un stop conditionnel (très pratique lorsqu'on passe énorménent dans le même code) et je rappelle que yLogger permet aussi de déclencher des STOP personnalisés en fonction des logs.

Il faut aussi savoir qu'il existe des attributs d'extensions qui permettent de modifier le comportement des points d'arrêt. Ce comportement peut aussi être modifié lorsque le point d'arrêt est déclenché. On peut alors faire du pas à pas, ignorer des lignes de codes et exécuter le code jusqu'à la ligne souhaitée.

Enfin, la meilleure manière de faire une pause, c'est d'éviter d'utiliser les points d'arrêt et la pratique de TDD permet de s'en passer.

Les points d'arrêts dans WinDev

Si vous ne connaissez pas, les points d'arrêts sont un outil très pratique de WinDev (et des langages de programmation en général) qui permettent de faire une pause dans un traitement à la demande du développeur.

Lorsque le traitement s'arrête, on retourne dans l'éditeur de code et on obtient la vue suivante :

La flèche jaune nous indique à quelle ligne le code s'est arrêtée.

Là, nous voyons l'affichage du débogueur. La partie de gauche (point 1) correspond à la pile des appels de procédures et la partie droite (point 2) est un espion qui permet de voir la valeur de certaines variables. Il est d'ailleurs possible de saisir toute sorte d'expression pour en obtenir la valeur (point 3). Enfin, la colonne Stop (point 4) nous permet d'activer un point d'arrêt qui se déclenche lorsqu'une expression change de valeur. Utilisée habilement, on peut déclencher des points d'arrêts très précis avec le debugger.

Les actions lorsque l'exécution est arrêtée

Lorsque le point d'arrêt est activé et que l'exécution s'est arrêté, on se retrouve donc dans la fenêtre de code. Là, plusieurs possibilités s'offrent aux développeurs.

• Continuer (raccourci : F5) : On continue l'exécution du code. L'application reprend la main.
• Terminer le test : On met fin au mode test. L'application s'arrête prématurément.
• Exécuter pas à pas (raccourci : F7) : on exécute la ligne en cours et l'exécution s'arrête à la prochaine ligne de code à exécuter.
• Sauter les fonctions (raccourci : F8) : idem que le pas à pas, sauf que l'on ne descend pas dans le code des fonctions.
• Sortir du code en cours (racourci : Alt + Fin) : idem que le pas à pas, sauf que l'on exécute tout le code de la fonction en cours avant de refaire un stop.
• Exécuter jusqu'au curseur : L'exécution se poursuit jusqu'à ce qu'on arrive sur la ligne où se trouve le curseur.
• Définir l'instruction suivante : Je vais en reparler un peu plus loin.
• Ignorer les points d'arrêts intermédiaires : Si vous avez plusieurs points d'arrêts, cela permet de ne vous arrêter qu'au point d'arrêt actuel et d'ignorer les suivants.

Cas particulier : Définir l'instruction suivante

Lorsque l'exécution est en pause, vous pouvez sauter l'exécution d'une ou plusieurs lignes de code en utilisant l'action Définir l'instruction suivante. La ligne ayant le curseur devient la prochaine ligne qui sera exécutée.

Cette technique est très pratique, mais peut aussi faire planter l'exécution de votre programme. En effet, si vous n'exécutez pas tout le code, votre programme peut faire des actions incohérentes et inattendues.

Mettre en place les points d'arrêts

Il existe plusieurs méthodes pour mettre en place des points d'arrêts. Nous allons les voir une par une.

En cours d'exécution

La première méthode est d'utiliser la combinaison Ctrl + Pause. Cette combinaison déclenche un point d'arrêt dans le programme en cours d'exécution.

L'utilisation est peu précise car si un traitement est en cours, on ne sait pas sur quelle ligne de code on va tomber. Mais si aucun traitement n'est en cours, en règle général, on va s'arrêter au prochain événement (clic sur un bouton par exemple) ou dans une procédure automatisée (thread ou timer) s'il y en a.

Cette technique est très utile lorsqu'on se trouve dans une boucle infinie. Cela permet de repérer plus facilement ce qui provoque cette boucle.

Un point d'arrêt simple

Vous pouvez mettre en place un point d'arrêt en cliquant sur le petit bandeau jaune à gauche du code. Un point rouge devrait apparaître. Il indique la ligne qui contient le point d'arrêt.

Le raccourci équivalent est Ctrl + B. Cela rajoute le point d'arrêt sur la ligne ayant le curseur.

Un point d'arrêt via la recherche

Vous pouvez effectuer une recherche de texte dans le code.

Un clic droit sur le résultat de la rechercher affiche le menu contextuel et le menu Ajouter un point d'arrêt place un point d'arrêt sur les lignes sélectionnées.

Ici aussi, vous pouvez utiliser le raccourci Ctrl + B.

Un point d'arrêt par programmation

Le mot clé STOP vous permet de déclencher un point d'arrêt. Vous pouvez encadrer ce mot clé par une condition pour permettre au point d'arrêt de ne se déclencher qu'à certaines conditions.

Il faut noter que ce mot clé ne fait rien lorsqu'on est dans un exécutable. Et heureuseument, parce qu'on pourrait l'oublier.

Il faut aussi savoir qu'il ne provoque par d'arrêt dans du code compilé dynamiquement ni dans un composant externe (expérience vécue).

Lors d'un plantage

Lors d'un plantage (exception), WinDev stop l'exécution et vous permet d'aller voir le code au point d'arrêt. Malheureusement, l'exécution ne peut pas reprendre. Mais cela reste tout de même un point d'arrêt.

Un point d'arrêt dans la colonne Stop du débogueur

J'en ai parlé plus haut, il est possible de déclencher un point d'arrêt en espionnant les changements de valeur d'une expression

Être précis avec un point d'arrêt

Le problème avec les points d'arrêts, c'est qu'il sont parfois peu pratiques.

Voici quelques exemples :

• Dans le cas d'une boucle avec énormément d'éléments et que l'on souhaite s'arrêter sur l'une des dernières itérations. On subit alors plusieurs points d'arrêt avant d'arriver sur l'itération qui nous intéresse.
• Lorsqu'on travaille avec des threads et que l'on exécute pas à pas. Il arrive parfois qu'un thread prenne la main sur le thread que l'on débogue.
• Lorsqu'on a plusieurs fonctions qui s'enchaînent et qu'on loupe le moment où il faut s'arrêter.

Mais rassurez-vous, il y a des outils pour simplifier la gestion des points d'arrêt.

Les propriétés du point d'arrêt

En faisant un clic droit sur le point d'arrêt (pastille rouge dans le ruban jaune), vous arrivez sur cette fenêtre qui vous permet de mettre des conditions d'arrêt.

• Toujours : indique que l'on s'arrête toujours sur ce point d'arrêt
• Quand le nombre de passages sur le point d'arrêt est : permet d'activer le point d'arrêt en fonction du nombre de fois que la ligne a été exécutée.
• Quand l'expression ci-dessous est vérifiée : (cette option est disponible à partir de WinDev 24) déclenche le point d'arrêt si une condition est vérifiée

Les actions permettent de faire différentes choses :

• Interrompre l'exécution : notre point d'arrêt ne serait pas un point d'arrêt s'il n'interromp pas l'exécution.
• Ajouter un message dans la trace du débogueur : on peut mettre une expression. Cette expression doit être valide au niveau du wlangage. Par exemple, si vous souhaitez mettre une chaîne, il faut l'encadrer par des guillemets.

Stop sur une expression à partir du débogueur

En mettant un stop dans le déboggeur, on peut s'arrêter chaque fois qu'une variable change de valeur. Mais en mettant une condition, on peut s'arrêter chaque fois que la variable ne respecte plus la condition.

Par exemple, j'ai le code suivant :

FOR i = 1 TO 100
    do_something()
END

Je rajoute la variable i dans le débogueur et je met un stop dessus. Je vais m'arrêter à chaque itération, au niveau du FOR.

Par contre, si j'indique l'expression i > 5, je vais m'arrêter une fois dès que i sera égale à 5 car i > 5 passera de faux à vrai.

Utiliser l'attribut extension <sans pas à pas>

Cet attribut d'extension vous permet de sauter certaines procédures quand vous faîtes du pas à pas.

Cette extension s'appelle <sas pas à pas> ( en anglais).

PROCEDURE faire_quelquechose() <sans pas à pas>
Trace("...")

Mettre une condition autour du STOP

Lorsque vous utilisez le mot clé STOP, vous pouvez l'encadrer par une condition. Cela vous permet de déclencher l'arrêt quand vous le souhaitez.

FOR i = 1 TO 100
        STOP IF i = 10
END

Utiliser yLogger

yLogger vous permet aussi de déclencher des points d'arrêts en vous servant des logs que vous avez mis en place.

La meilleure manière d'utiliser les points d'arrêts...

C'est tout simplement de ne pas les utiliser. Personnellement, depuis que j'utilise la méthode TDD, j'utilise beaucoup moins le débogueur. Mais ça, c'est une autre histoire...

Conclusion

J'espère que cet article vous a plu et que vous avez pu apprendre de nouvelles choses.

Les points d'arrêt sont très utiles au développeur et savoir s'en servir correctement est une des conditions indispensables dans notre métier.

Et vous ? Comment vous en servez-vous ?