Commandes de flux du programme

Les numéros de ligne informent un programme ABasiC de la séquence dans laquelle traiter les instructions. L'exécution normale passe par les numéros de ligne, du plus petit au plus grand. Il existe un certain nombre de raisons d'interrompre ou de détourner le traitement séquentiel, selon les circonstances. Les commandes suivantes décrivent comment vous pouvez le faire.

Certaines des commandes de flux du programme nécessitent que vous spécifiiez un numéro de ligne. Le numéro de ligne peut être n'importe quel nombre entier compris entre 0 et 65529. Si vous utilisez un nombre fractionnaire, il est tronqué. Les nombres en dehors de l'intervalle ou les références à des lignes n'étant pas dans le programme génèrent une erreur.

END

La commande END interrompt l'exécution du programme en cours et ramène l'ordinateur en mode immédiat. END diffère de STOP en ce sens que END ne renvoie pas de message d'interruption. Lorsque ABasiC rencontre END, il arrête le programme et affiche :

END ferme tous les fichiers ouverts. Les valeurs des variables restent telles quelles.

Les premières versions de BASIC nécessitaient END comme dernière instruction d'un programme pour que l'ordinateur sache où s'arrêter. En ABasiC, l'ordinateur s'arrête automatiquement à la dernière instruction.

Cependant, END est utile pour séparer les sous-programmes (voir GOSUB) à la fin d'un programme du corps principal. Sans l'instruction END, le premier sous-programme s'exécute sans commande GOSUB, de sorte que la commande RETURN à la fin du sous-programme déclenche une erreur.

Lorsque vous exécutez le programme, le résultat est :

Sans l'instruction END, le résultat est :

RETURN sans GOSUB à la ligne 120.

FOR...TO...[STEP]

La commande FOR...TO marque le début d'une boucle de programme. Une boucle est une suite d'instructions de programme répétée plusieurs fois. La commande FOR...TO est toujours associée à une commande NEXT, marquant la fin de la boucle. FOR...TO et son extension facultative, STEP, sont utilisés pour configurer une variable de compteur, des nombres de début et de fin pour le comptage et un incrément de pas. La commande NEXT, étant la dernière instruction de la boucle, utilise la variable et les valeurs pour suivre les répétitions de la boucle.

Lorsque l'ordinateur exécute la commande FOR...TO, il définit la variable de compteur à la valeur de départ. Lorsque l'exécution du programme atteint la commande NEXT, elle incrémente la variable du compteur de la valeur STEP. Ensuite, il compare le compteur à la valeur limite.

Remarque : À moins que vous ne spécifiiez une variable entière comme compteur de boucle, ABasiC traite la variable compteur comme une virgule flottante simple précision. Vous devez spécifiquement utiliser une variable à virgule flottante lorsque vous spécifiez des valeurs STEP fractionnaires.

Si le compteur n'a pas dépassé la valeur limite, l'exécution du programme revient à la commande suivant immédiatement la dernière commande FOR...TO et les instructions de boucle répètent l'exécution. Si le compteur a dépassé la valeur limite, la boucle se termine et l'exécution normale du programme se poursuit à l'instruction suivant NEXT.

Lorsque le programme rencontre FOR...TO, il affecte la valeur de départ à la variable de compteur et entrepose les valeurs de limitation et d'incrémentation. Il entrepose également le numéro de ligne de la commande FOR...TO.

Si vous omettez STEP et la valeur d'incrémentation l'accompagnant, le programme utilise une valeur d'incrément par défaut de 1. Si vous spécifiez STEP avec une valeur d'incrémentation supérieure à un (ou une valeur d'incrémentation fractionnaire), le compteur de boucle augmente de cet incrémentation à chaque répétition. Les valeurs d'incrémentation négatives vous permettent de compter à rebours si votre valeur de départ est supérieure à votre valeur limite. Vous pouvez déterminer le nombre d'exécutions d'une boucle à l'aide de cette formule :

(Voir la commande NEXT pour une description de l'imbrication des boucles et un exemple de programmation).

GOSUB

La commande GOSUB fait passer l'exécution du programme à un sous-programme. Un sous-programme est une section du programme s'exécutant jusqu'à ce qu'une commande RETURN soit trouvée. La commande RETURN retransfère le contrôle à l'instruction suivant immédiatement la commande GOSUB. Si GOSUB est sur une ligne à part, l'exécution revient à la ligne suivante. Si elle fait partie d'une ligne d'instructions multiples et qu'une autre instruction la suit, l'exécution du programme revient à l'instruction suivante de la ligne.

Un sous-programme est un groupe de lignes de programme pouvant être répété plusieurs fois dans un programme. Pour économiser de l'espace et du temps de saisie, faites d'une procédure répétée une sous-routine et placez-la à la fin d'un programme. Chaque fois que vous souhaitez utiliser cette procédure, utilisez une commande GOSUB suivie du numéro de la première ligne du sous-programme. Vous devez séparer les sous-programmes du corps principal du programme avec une commande END.

Vous pouvez imbriquer des sous-programmes ; c'est-à-dire que vous pouvez placer un sous-programme dans un autre jusqu'à plusieurs niveaux. L'ABasiC garde une trace des niveaux de sous-programme par la séquence de GOSUB qu'il trouve. Lorsque le programme rencontre des commandes RETURN, il renvoie l'exécution à l'endroit qu'il a enregistré pour le GOSUB le plus récent.

Assurez-vous qu'il y a une commande RETURN pour chaque GOSUB que vous utilisez dans un programme afin qu'ABasiC ne confonde pas l'ordre d'exécution. Avoir trop peu de commandes RETURN ne ramène pas l'exécution du programme au premier emplacement GOSUB. Avoir trop de commandes RETURN provoque une erreur.

Lorsque vous exécutez le programme, le résultat est :

GOTO

Vous pouvez utiliser la commande GOTO pour avancer dans un programme en spécifiant un numéro de ligne plus grand que celui contenant l'instruction GOTO. Si vous demandez au programme d'aller à un numéro de ligne n'étant pas dans le programme, une erreur se produit.

Vous pouvez également utiliser GOTO pour créer une boucle sans fin en spécifiant le numéro de ligne de la commande GOTO ou un numéro de ligne plus petit. Ce type de boucle continue de s'exécuter jusqu'à ce que vous rompiez en appuyant sur Ctrl+C.

Lorsque vous exécutez le programme, le résultat est :

Un autre exemple :

Lorsque vous exécutez le programme, le résultat (partiellement affiché) est :

et ainsi de suite, jusqu'à ce que vous appuyiez sur Ctrl+C.

IF...GOTO

IF...GOTO est une forme de IF...THEN. Pour plus d'informations sur IF...GOTO, lisez la description de IF...THEN.

IF...THEN...[ELSE]

IF...THEN est une commande de branchement conditionnel. Il teste la vérité d'une relation; selon le résultat, il se ramifie ensuite, ou bifurque, vers différentes parties du programme. IF... THEN donne à un ordinateur la capacité de prendre des décisions et de réagir différemment selon les circonstances.

Une instruction IF...THEN contient généralement une relation entre IF et THEN. Une action conditionnelle suit THEN ; cette action peut être une commande, une série de commandes ou un numéro de ligne. Un numéro de ligne doit être seul ou avec uniquement GOTO, comme dans la première forme de la syntaxe. Toutes les instructions appartenant à l'action conditionnelle doivent tenir sur la ligne de programme avec l'instruction IF...THEN. La condition n'affecte pas les lignes de programme qui suivent.

Vous pouvez éventuellement utiliser le mot clef ELSE pour répertorier les instructions s'exécutant si la relation spécifiée n'est pas vraie. Par exemple, l'instruction suivante :

teste la valeur de A. Si A est égal à zéro, le contrôle du programme passe à la ligne 40. Si A n'est pas zéro, la valeur de B est augmentée de 15.

Quand ABasiC exécute une commande IF...THEN, il évalue la relation comme vraie ou fausse. Si la relation est vraie, les actions conditionnelles sont exécutées et le programme continue. Si la relation est fausse, l'exécution du programme passe à la ligne suivante et ABasiC ignore toutes les actions conditionnelles restant sur la ligne de programme IF...THEN.

Si l'action conditionnelle suivant "THEN" est un numéro de ligne et que la relation est vraie, l'exécution du programme saute à cette ligne. Si la relation est fausse, le programme continue avec la ligne suivant immédiatement IF...THEN.

Pour rendre le saut conditionnel plus apparent, vous pouvez substituer "GOTO" à l'élément "THEN" pour créer une instruction IF...GOTO. IF...GOTO fonctionne exactement comme une instruction IF...THEN, sauf qu'après GOTO, vous ne pouvez pas utiliser les commandes comme activité conditionnelle. Vous ne pouvez indiquer qu'un numéro de ligne.

Lorsqu'une instruction IF...THEN évalue une relation, elle substitue -1 à la relation si elle est vraie et 0 si elle est fausse. Il exécute ensuite l'activité conditionnelle si le résultat est une valeur différente de zéro. Vous pouvez placer une expression numérique, telle que :

au lieu d'une relation entre "IF" et "THEN". IF...THEN teste l'expression pour vrai (non nul) ou faux (0) et procède en conséquence.

Lorsque vous exécutez le programme, le résultat peut être :

Lorsque vous l'exécutez à nouveau, le résultat peut être :

NEXT

La commande NEXT marque la fin d'une boucle de programme. La commande FOR...TO établit simplement une variable de comptage et définit les limites de la boucle. La commande NEXT effectue en fait tout le comptage et le bouclage. Si l'ordinateur rencontre un NEXT sans commande FOR...TO, il génère une erreur.

La variable compteur est facultative ; si vous l'omettez, ABasiC connecte la commande NEXT à la dernière instruction FOR...TO rencontrée. Cependant, votre code est plus lisible lorsque vous incluez le nom de la variable.

Vous pouvez imbriquer des boucles FOR...TO...NEXT, l'une dans l'autre, jusqu'à une profondeur maximale de neuf boucles. Chaque boucle commence par une commande FOR...TO et se termine par une commande NEXT. Une variable de compteur différente doit être utilisée pour chaque boucle.

Vous pouvez terminer plusieurs boucles imbriquées avec une commande NEXT en répertoriant les compteurs dans l'ordre, de la boucle la plus interne à la plus externe. Par exemple, si une boucle utilisant le compteur K est à l'intérieur d'une boucle utilisant le compteur J, vous pouvez terminer les deux boucles avec la commande suivante :

Un autre exemple :

Lorsque vous exécutez le programme, le résultat est :

L'exemple suivant illustre deux boucles imbriquées, avec des commandes NEXT combinées :

Lorsque vous exécutez le programme, le résultat est :

ON ERROR GOSUB

Utilisez cette forme de l'instruction ON ERROR... pour envoyer l'exécution à un sous-programme. Sinon, cette forme de commande fonctionne comme la commande ON ERROR GOTO (voir ci-dessous).

ON ERROR GOTO

Utilisez la commande ON ERROR pour empêcher ABasiC d'arrêter l'exécution en raison d'une erreur. Vous pouvez utiliser cette commande pour filtrer les entrées incorrectes pendant l'exécution du programme. Faites suivre ON ERROR d'un GOTO et d'un numéro de ligne. (Vous pouvez également utiliser la commande GOSUB.)

Lorsque ABasiC rencontre une instruction ON ERROR GOTO, il note le GOTO et le numéro de ligne. Si une erreur se produit pendant l'exécution du programme, le programme ne s'arrête pas et imprime un message d'erreur ; à la place, il transfère le contrôle au numéro de ligne que vous avez spécifié.

Une fois ON ERROR... déclenché, une autre erreur arrête le programme et produit un message d'erreur. Vous pouvez désactiver ON ERROR... en saisissant :

Si votre programme contient plus d'une instruction ON ERROR..., seule la dernière exécutée reste effective.

Lorsque vous exécutez le programme, vous pouvez obtenir le résultat suivant :

Notez l'utilisation de la variable ERR à la ligne 1000. ERR est le mot réservé ABasiC contenant le numéro de la dernière erreur survenue.

ERL est une autre variable de mot réservé ; sa valeur est le numéro de ligne de l'erreur la plus récente. (Voir l'exemple de programmation de la commande RESUME pour voir comment ERL est utilisé.)

ON...GOSUB

ON...GOSUB est similaire à la commande ON...GOTO, sauf que les numéros de ligne se branchent sur les sous-programmes. Ensuite, ABasiC revient à l'exécution normale du programme. Chaque numéro de ligne doit être la première ligne d'un sous-programme. Lorsque l'exécution du programme reprend, elle reprend à la première commande suivant ON.

Lorsque vous exécutez le programme, le résultat peut être :

ON...GOTO

ON...GOTO est une commande de branchement multiple ; il peut se ramifier sur de nombreuses lignes différentes à l'aide d'une seule instruction. Le nombre de branches qu'il utilise est limité par le nombre de numéros de ligne tenant sur une seule ligne de programme.

La valeur de la variable numérique suivant ON détermine à quel numéro de ligne la commande se branche. Les numéros de ligne après GOTO sont les différentes branches. Vous devez affecter la valeur de la variable avant que le programme n'atteigne la commande ON...GOTO.

Lorsqu'un ON...GOTO s'exécute, ABasiC arrondit la valeur de la variable à une valeur entière, si nécessaire. ON...GOTO utilise cette valeur pour passer au numéro de ligne souhaité. Si la valeur est 1, ON...GOTO envoie le contrôle au premier numéro de ligne répertorié. Si la valeur est 2, il envoie le contrôle au deuxième numéro de ligne, et ainsi de suite.

ABasiC ignore la commande ON...GOTO si la valeur de la variable est inférieure à 1 ou supérieure au nombre de branches. Il continue avec l'instruction suivante.

Vous pouvez remplacer GOTO dans la commande ON...GOTO par GOSUB (voir ci-dessous). ON...GOTO et ON...GOSUB peuvent faire le travail de plusieurs commandes IF...THEN. L'astuce pour bien les utiliser est de réduire la valeur de la variable à un entier dans la plage appropriée. Cela resserre votre programme, économise de la mémoire et accélère l'exécution du programme.

Lorsque vous exécutez le programme, le résultat peut être :

RESUME

Utilisez la commande RESUME pour poursuivre l'exécution du programme après qu'une erreur a été interceptée (c'est-à-dire, interceptée par votre programme au lieu d'arrêter l'exécution) à l'aide de la commande ON ERROR GOTO/GOSUB. Vous ne pouvez utiliser RESUME que dans une routine d'interception d'erreurs ; sinon, une erreur est générée qui arrête votre programme.

Lorsque vous utilisez RESUME seul ou avec un argument de 0, il renvoie le contrôle du programme à la première instruction de la ligne dans laquelle l'erreur s'est produite.

L'exemple de programmation de la commande ON ERROR GOTO illustre cela.

Lorsque RESUME est suivi du mot clef NEXT, le contrôle est transféré à la ligne suivant immédiatement celle ayant provoqué l'erreur. Si un numéro de ligne suit RESUME, l'exécution du programme est transférée à la ligne spécifiée.

RETURN

Utilisez la commande RETURN pour marquer la fin d'un sous-programme dans un programme. RETURN est toujours associé à une commande GOSUB correspondante, pointant vers le début du sous-programme. Lorsque l'ordinateur rencontre un RETURN, il renvoie l'exécution du programme à l'instruction suivant immédiatement le GOSUB le plus récent. Si ABasiC trouve une commande RETURN sans commande GOSUB précédente, il génère une erreur. Voir la description de la commande GOSUB pour un exemple de programme utilisant RETURN.

STOP

Utilisez la commande STOP pour arrêter l'exécution d'un programme et remettre l'ordinateur en mode immédiat. Quand ABasiC rencontre une commande STOP dans un programme, il répond :

où n est le numéro de la ligne de programme contenant la commande STOP. ABasiC conserve toutes les valeurs des variables lorsque le STOP se produit. Il conserve également tous les fichiers ouverts tels quels. Ils ne sont ni effacés ni fermés lorsque STOP s'exécute.

Vous pouvez reprendre l'exécution du programme après la commande STOP en tapant :

L'ordinateur se souvient de l'endroit où il a arrêté l'exécution et continue à l'instruction suivant immédiatement la commande STOP. Si vous voulez démarrer le programme à une ligne autre que le point d'arrêt, utilisez :

où n est le numéro de la ligne à laquelle vous souhaitez reprendre l'exécution. Vous pouvez également utiliser RUN pour redémarrer le programme depuis le début.

Étant donné que STOP interrompt l'ordinateur d'un programme en cours d'exécution, vous ne l'utiliserez pas souvent dans un programme terminé. Cependant, il est utile pour déboguer un programme. Si vous insérez STOP dans une section d'un programme où vous suspectez un problème, vous pouvez arrêter l'exécution à ce stade. Utilisez ensuite les commandes du mode immédiat pour vérifier l'état des variables et des fichiers. Une fois que vous avez les informations dont vous avez besoin, vous pouvez redémarrer le programme avec CONT.

Lorsque vous exécutez le programme, le résultat est :

Une fois que vous avez entré CONT, le programme continue :

WEND

Utilisez la commande WEND pour terminer une boucle indéfinie. L'instruction WHILE établit une condition étant une relation. Le programme teste la véracité de la relation et exécute toutes les instructions entre l'instruction WHILE et le WEND suivant qu'il trouve. Une fois que la valeur de la relation est fausse (0), le contrôle du programme passe à l'instruction suivant immédiatement la commande WEND.

(Voir la description de WHILE pour un exemple de programmation utilisant WEND.)

WHILE

La commande WHILE fonctionne avec WEND (While END) pour contrôler une boucle indéfinie. Une boucle indéfinie signifie simplement que le nombre de fois qu'un groupe d'instructions répète l'exécution est conditionnel, plutôt que fixe, comme avec la structure FOR...TO...NEXT. La relation définit une condition obligeant un groupe d'instructions à s'exécuter de manière répétée jusqu'à ce que l'instruction WHILE détecte que la condition n'est plus vraie.

Une boucle indéfinie est utile lorsque vous souhaitez que le programme effectue certaines actions sur un ensemble de données de longueur variable, comme des nombres dans un fichier disque. Le format générale est :

Lorsque l'exécution du programme atteint l'instruction WHILE, elle teste la véracité de la relation. Si la relation renvoie un vrai (-1), toutes les instructions suivant la condition s'exécutent. Dès qu'ABasiC arrive à l'instruction WEND, le contrôle revient à l'instruction WHILE, testant à nouveau la véracité de la relation. Une fois que la valeur est fausse (0), le contrôle du programme saute à l'instruction suivant immédiatement l'instruction WEND.

Vous pouvez également imbriquer des boucles WHILE...WEND (c'est-à-dire placer une boucle à l'intérieur d'une autre étant à l'intérieur d'une autre,...). Dès qu'un programme contenant des boucles WHILE...WEND imbriquées atteint une commande WEND, il retransfère le contrôle à la dernière instruction WHILE qu'il a rencontrée.

Lorsque vous exécutez le programme, le résultat peut être :