| |
|
|
| Introduction |
|
Instructions et fonctions
Cette partie contient la description de toutes les instructions et fonctions disponibles, pas forcément dans l'ordre alphabétique. Il se peut que certaines instructions ou fonctions soient différentes du GFA Basic sur ATARI ST. Ce manuel fera la distinction.
La différence entre instruction et ordre, qui avait un sens historiquement, est désormais levée (Il était d'usage d'appeler ordre ce qui concernait le mode direct et qui contribuait à l'élaboration des programmes). Les instructions, par contre, s'utilisaient à l'interieur d'un programme. Comme toutes les instructions peuvent être employées aussi bien en mode direct que dans un programme, cette distinction n'est plus necessaire).
La description des instructions et des fonctions s'organise en quatre parties.
1- Syntaxe:
Ici est décrit le format de l'instruction ou de la fonction.
Les mots écrits en majuscules sont des mots-clés.
Les expressions entre crochets sont optionnelles, c'est à dire facultatives. Trois petits points "..." indiquent que l'expression qui se trouve avant peut être répétée autant de fois que l'on veut.
Les expressions qui interviennent dans le format de l'instruction sont expliquées dans la suite de la description.
2- Exemple:
Dans cette partie, on présente un exemple simple de programmes.
D'une part, l'exemple doit mettre en évidence les différentes syntaxes possibles de l'instruction.
D'autre part, l'exemple sert à concrétiser l'utilisation de l'instruction ou de la fonction.
Si, après l'explication de l'instruction ou de la fonction, des doutes subsistent quant à son emploi ou son utilitée, il est conseillé de taper et de tester soi-même l'exemple fourni.
Comme certains exemples utilisent des boucles sans fin, il est important de savoir que l'on peut interrompre l'execution d'un programme avec la touche [ON].
3- Fonction:
Décrit en peu de mots quelle est l'utilisation de l'instruction ou de la fonction (c'est-à-dire ce que fait l'instruction ou la fonction).
4- Explication:
Dans cette partie, on explique de façon détaillée ce qu'il est important de connaître pour la mise en application de l'instruction ou de la fonction.
Si on peut préciser le domaine d'application de l'instruction.
Instruction I/O (relative aux entrées/sorties).
Instruction graphique.
Instruction arithmétique.
Instruction de structure.
...
ce dernier sera précisé dans l'en-tête de la description.
Dans la description concernant les instructions graphiques, nous supposons que la résolution de la calculatrice est en noir & blanc et que la taille de l'écran est de 240 x 128 pixels.
A noter qu'il existe des constantes, les constantes dynamiques ont un rapport avec le modèle de la calculatrice où le programme est executé et non développé.
Attention:
La liste ci-dessous contient énormément d'instructions/fonctions non implantées et est incompléte (certaines fonctions ne sont pas encore documentées mais elles sont implantées dans GFA-Basic).
Veuillez vous reporter au fichier beta.txt disponible dans le pack pour connaître les instructions/fonctions développées et utilisables.
|
|
| Liste des instructions/fonctions |
|
|
|
|
|
|
|
INSTRUCTION DE STRUCTURE
|
@
|
|
|
| Syntaxe: |
@nom[(list expressions)]
|
|
| Exemple(s): |
CLS
PRINT "Programme principal"
@sousprg
PRINT "Programme principal"
PROCEDURE sousprg
PRINT "Sous programme"
RETURN
|
|
| Fonction: |
Synonyme de Gosub.
|
|
| Explications: |
|
Ce symbole est simplement un synonyme de la fonction Gosub. Il permet ainsi de mieux identifier les sauts à des procédures (sous-programmes).
|
|
|
|
|
|
|
|
|
INSTRUCTION DE STRUCTURE
|
DO...LOOP
|
|
|
| Syntaxe: |
DO
LOOP
|
|
| Exemple(s): |
CLS
DO
INC I
PRINT I
LOOP
|
|
| Fonction: |
Met en place une boucle sans fin.
|
|
| Explications: |
|
La partie du programme qui se trouve entre DO et LOOP est répétée à l'infini.
On peut sortir de cette boucle par l'instruction EXIT ou EXIT IF. Si cette dernière instruction n'est pas utilisée, il ne reste plus qu'une solution pour interrompre le programme: l'action sur la touche [ON].
Sur ATARI ST pour sortir d'une boucle, seul l'instruction EXIT IF existe. EXIT seul n'est pas reconnue.
|
|
|
|
|
|
|
|
|
INSTRUCTION DE STRUCTURE
|
EXIT
EXIT IF
|
|
|
| Syntaxe: |
EXIT
EXIT IF condition
|
|
| Exemple(s): |
CLS
DO
A=A+1
PRINT A
EXIT IF A=20
LOOP
|
|
| Fonction: |
Permet de sortir d'une boucle.
|
|
| Explications: |
|
Si l'instruction EXIT ou EXIT IF est rencontrée à l'intérieur d'une boucle, le déroulement du programme se poursuit à la première instruction en dehors de la boucle. Ces instructions permettent de sortir de n'importe quelle boucle :
FOR...NEXT, DO...LOOP, REPEAT...UNTIL et WHILE...WEND.
A noter que sur ATARI ST, l'instruction EXIT seule n'existe pas.
|
|
|
|
|
|
|
|
|
INSTRUCTION DE STRUCTURE
|
FOR...NEXT
|
|
|
| Syntaxe: |
FOR Var=d [DOWN]TO f [STEP s]
NEXT [Var]
|
|
| Exemple(s): |
CLS
FOR I=3 TO 5
FOR J=5 DOWNTO 3
FOR K=1 TO 5 STEP 2
PRINT I,J,K
NEXT K
NEXT
NEXT
|
|
| Fonction: |
Met en place une boucle dont le nombre de passages est fixé.
|
|
| Explications: |
|
On affecte à la variable Var la valeur d et on exécute les instructions entre FOR et NEXT. Var est ensuite (une fois sur NEXT) augmenté de la valeur s et on teste si le contenu de Var est supérieure à f. Si ce n'est pas le cas, le programme se rebranche sur FOR. Ce processus est répété jusqu'à ce que Var dépasse la valeur de fin f.
Si s est négatif, le processus est inversé: Var est diminué, et on teste si Var est plus petit que f.
Si la partie facultative STEP s est absente, s prend la valeur 1 par défaut.
Si on utilise DOWNTO à la place de TO, il est interdit d'employer STEP s et s prend toujours la valeur -1.
Les boucles FOR-NEXT peuvent être emboîtées les unes dans les autres.
La vitesse d'exécution d'une boucle FOR-NEXT peut sensiblement augmentée si on choisit une variable entière pour le compteur 'Var'. L'exemple suivant met en évidence une diminution du temps d'execution par la simple utilisation de la variable entière I% à la place de I:
T=TIMER
FOR I=1 TO 10000
NEXT I
PRINT (TIMER-T)/200
T=TIMER
FOR I%=1 TO 10000
NEXT I%
PRINT (TIMER-T)/200
Sur Atari ST NEXT est toujours suivie de Var mais sur TI68K Var est facultatif. Ceci apporte un confort interessant lorsque l'on emboîte beaucoup de boucles FOR. Ainsi il est inutile de rechercher la variable terminant une boucle FOR et la stipuler après NEXT. NEXT seule est donc autorisé.
|
|
|
|
|
|
|
|
|
INSTRUCTION DE STRUCTURE
|
GOSUB
|
|
|
| Syntaxe: |
GOSUB nom[(list expressions)]
|
|
| Exemple(s): |
CLS
PRINT "Programme principal"
GOSUB _1er.niveau
PRINT "Retour du 1"
PROCEDURE _1er.niveau
PRINT "Procedure 1"
GOSUB _2eme.niveau(3,2)
PRINT "Retour du 2"
PRINT A,B
RETURN
PROCEDURE _2eme.niveau(A,B)
PRINT A,B
PRINT "Procedure 2"
RETURN
|
|
| Fonction: |
Appelle la procédure dont le nom est 'nom'.
|
|
| Explications: |
|
'nom' est le nom de la procédure appelée.
Le nom d'une proécudre peut s'écrire avec des chiffres, le caractère souligné et le point.
'liste expressions' est une liste d'expressions séparées par des virgules qui sont transmises aux variables locales de la procédure (voir PROCEDURE).
Lorsque l'interpréteur rencontre une instruction GOSUB, il se branche sur la procédure avec le nom correspond.
Il est possible, à l'intérieur d'une procédure, d'appeler une autre procédure GOSUB.
Il est même possible, à l'intérieur d'une procédure, d'appeler à nouveau la procédure où l'on se trouve (appel récursif).
L'exemple appelle, à partir du programme, la procédure '_1er.niveau'. A l'intérieur de la procédure '_1er.niveau', on transmet, par appel de la procédure '_2eme.niveau', les valeurs 3 et 2 aux variables A et B. Enfin, la procédure '_2eme.niveau' affiche ces deux valeurs à l'écran. Pour bien montrer que A et B sont locales à la deuxième procédure, on affiche à nouveau les variables A et B après avoir quitté la deuxième procédure: on obtient deux fois la valeur 0.
Le symbole @ est identique à GOSUB.
(voir PROCEDURE, RETURN, LOCAL).
|
|
|
|
|
|
|
|
|
INSTRUCTION DE STRUCTURE
|
GOTO
|
|
|
| Syntaxe: |
GOTO etiquette
|
|
| Exemple(s): |
CLS
Boucle:
PRINT "Boucle sans fin ";
GOTO Boucle
|
|
| Fonction: |
Permet un branchement inconditionnel.
|
|
| Explications: |
|
'etiquette' est une chaîne de caractères formée de lettres, de chiffres, du souligné et du point. Cette chaîne peut commencer par un chiffre à l'inverse des noms de variables.
Comme le BASIC Gfa travaille sans les numéros de lignes, il est nécessaire de marquer l'endroit où doit se positionner le compteur de programme. On utilise pour cela un nom d'étiquette (label) suivi d'un bouble-point.
Lors d'une exécution, quand l'interpréteur rencontre un GOTO, il se branche de manière inconditionnelle après la ligne repérée par l'étiquette correspondante.
L'exemple simule une boucle DO...LOOP.
Il est a noter que pour l'instant un label ne peut contenir les caractères point ou souligné. Un label doit toujours commencer par une lettre, le reste peut être suivi de chiffres.
|
|
|
|
|
|
|
|
|
INSTRUCTION DE STRUCTURE
|
IF
ELSEIF
ELSE IF
ELSE
ENDIF
|
|
|
| Syntaxe: |
IF condition [THEN]
blocprogramme
[ELSEIF condition [THEN]]
[blocprogramme]
[ELSE IF condition [THEN]]
[blocprogramme]
[ELSE]
[blocprogramme]
ENDIF
|
|
| Exemple(s): |
CLS
INPUT A,B
IF A=3
PRINT "Vous avez gagné..."
IF B=3 THEN
PRINT "...le gros lot !"
ELSE
PRINT "...le lot de consolation !"
ENDIF
ELSE
PRINT "Vous avez malheuresement perdu."
ENDIF
PRINT "A bientôt !"
|
|
| Fonction: |
Branche le programme sur différents blocs-programmes, suivant la valeur logique (vrai ou faux) de 'condition'.
|
|
| Explications: |
|
Le déroulement d'un programme dépend souvent de certaines conditions.
D'où l'utilité de l'instruction IF.
Si la confition est réalisée, on exécute les instructions du bloc-programme qui se trouve entre IF et ELSE (ou bien IF et ELSEIF (ELSE IF) ou bien IF et ENDIF, si ELSE ou ELSEIF (ELSE IF) sont absentes). Si la condition n'est pas remplie, on exécute le bloc-programme entre ELSE et ENDIF ou bien ELSEIF (ELSE IF) et ENDIF (si les instructions facultatives ELSE ou ELSEIF (ELSE IF) manques, on passe à la suite).
Dans tous les cas, après le traitement de l'instruction IF, le programme poursuit son exécution en se branchant sur la première instruction après ENDIF.
Comme cette instruction souvent utilisée possède une syntxae différente de celle des langages BASIC classiques, il est fortement conseillé de tester le programme de l'exemple.
Il est à noter que l'Atari ST ne gère pas ELSEIF (ELSE IF). Cette possibilité à été ajoutée tout simplement car elle est très souvent utilisées. A vrai dire, le manque de ELSEIF (ELSE IF) sur le GFA Basic de l'Atari ST est un handicap assez important.
Ainsi l'exemple suivant:
CLS
INPUT "Votre âge ",age
IF age<3 THEN
PRINT "Encore trop jeune pour l'école!"
ELSE
IF age<=5 THEN
PRINT "Vous êtes en maternelle."
ELSE
IF age<=10
PRINT "Vous êtes en école primaire."
ELSE
IF age<=15
PRINT "Vous êtes au collège."
ELSE
IF age<=18 THEN
PRINT "Vous êtes au lycée."
ELSE
PRINT "Vous faîtes des études supérieures ou autre."
ENDIF
ENDIF
ENDIF
ENDIF
ENDIF
est simplifiable en:
CLS
INPUT "Votre âge ",age
IF age<3 THEN
PRINT "Encore trop jeune pour l'école!"
ELSEIF age<=5 THEN
PRINT "Vous êtes en maternelle."
ELSE IF age<=10
PRINT "Vous êtes en école primaire."
ELSEIF age<=15
PRINT "Vous êtes au collège."
ELSE IF age<=18 THEN
PRINT "Vous êtes au lycée."
ELSE
PRINT "Vous faîtes des études supérieures ou autre."
ENDIF
|
|
|
|
|
|
|
|
|
INSTRUCTION DE STRUCTURE
|
LOCAL
|
|
|
| Syntaxe: |
LOCAL var[,var]
|
|
| Exemple(s): |
CLS
A=1000
PRINT A
GOSUB Sousprg
PROCEDURE Sousprg
LOCAL A
I=I+1
A=I
PRINT A
IF I=5 THEN
ELSE
GOSUB Sousprg
ENDIF
PRINT A
RETURN
|
|
| Fonction: |
Déclare 'var' comme variable locale.
|
|
| Explications: |
|
'var' peut être de n'importe quel type, sauf un tableau. En BASIC Gfa, on peut déclarer des variables locales à l'intérieur de proécudres (sous-programmes).
Une variable située en-dehors de la procédure, n'est pas affectée par une modification du contenu de la variable locale, même si les deux variables ont le même nom.
L'exemple ci-dessus démontre bien cette propriété, en appelant 10 fois la même procédure de façon récursive.
(voir aussi GOSUB, PROCEDURE, RETURN).
|
|
|
|
|
|
|
|
|
INSTRUCTION DE STRUCTURE
|
ON...GOSUB
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
INSTRUCTION DE STRUCTURE
|
PROCEDURE
|
|
|
| Syntaxe: |
PROCEDURE nom[(listevar)]
|
|
| Exemple(s): |
CLS
PRINT "Programme principal"
GOSUB Ssprg(7)
PRINT "retour A=";A
PROCEDURE SSprg(A)
PRINT "procédure A=";A
RETURN
PRINT "reste inchangé"
|
|
| Fonction: |
Indique le début d'une procédure (sous-programme).
|
|
| Explications: |
|
'nom' est le nom de la procédure. 'listevar' sont les noms de variables séparées par des virgules. On transmet à ces variables les paramètres fixés dans l'instruction GOSUB. Les variables de 'listevar' sont toujours des variables locales dans la procédure.
Comme le BASIC GfA n'utilise pas de numéros de lignes, il faut repérer le début d'une procédure (sous-programme). C'est le rôle de cette instruction.
Un autre avantage de cette instruction, en plus des variables locales, est que l'interpreteur peut reconnaître une procédure et éviter ainsi un traitement du sous-programme non souhaité, car une procédure n'est executée que si elle est appelée avec l'instruction GOSUB.
Si l'interpréteur rencontre l'instruction 'PROCEDURE' dans le déroulement normal du programme, il considére cela comme la fin du programme.
Dans l'exemple, on appelle la procédure dont le nom est 'Ssprg' et on transmet la valeur 7 à la variable locale A. Dans la procédure, on affiche la valeur de A. Pour bien montrer qu'il s'agit d'une variable locale, on procéde, après le retour au programme principal, à un nouvel affichage du contenu de A (valeur: 0).
(voir GOSUB, RETURN, LOCAL).
|
|
|
|
|
|
|
|
|
INSTRUCTION DE STRUCTURE
|
REPEAT...UNTIL
|
|
|
| Syntaxe: |
REPEAT
UNTIL condition
|
|
| Exemple(s): |
CLS
REPEAT
A=A+1
PRINT A
UNTIL A=20
|
|
| Fonction: |
Réalise une boucle conditionnelle.
|
|
| Explications: |
|
La partie du programme qui se trouve entre REPEAT et UNTIL est exécutée plusieurs fois jusqu'à ce que la condition soit remplie. A l'inverse de l'instruction WHILE...WEND, la condition n'est testée qu'en fin de boucle. C'est pourquoi une boucle REPEAT...UNTIL est toujours parcourue au moins une fois.
|
|
|
|
|
|
|
|
|
INSTRUCTION DE STRUCTURE
|
RETURN
|
|
|
| Syntaxe: |
RETURN
|
|
| Exemple(s): |
CLS
PRINT "Programme principal"
GOSUB Ssprg
PRINT "De retour"
PROCEDURE Ssprg
PRINT "Procédure"
RETURN
|
|
| Fonction: |
Indique la fin d'un sous-programme (procédure).
|
|
| Explications: |
|
Lorsque l'interpréteur rencontre l'instruction RETURN à l'intérieur d'une procédure (sous-programme), le traitement de la procédure est terminé et le programme se branche après l'instruction GOSUB ayant appelé la procédure.
Les variables locales sont alors effacées.
(voir GOSUB, PROCEDURE, LOCAL).
|
|
|
|
|
|
|
|
|
INSTRUCTION DE STRUCTURE
|
WHILE...WEND
|
|
|
| Syntaxe: |
WHILE condition
WEND
|
|
| Exemple(s): |
CLS
WHILE A<10
A=A+1
PRINT A
WEND
|
|
| Fonction: |
Met en place une boucle conditionnelle.
|
|
| Explications: |
|
Le bloc d'instructions entre WHILE et WEND est exécuté (éventuellement plusieurs fois) tant que la condition est vérifiée. Comme on teste la condition au début de l'instruction, il est fort possible que la boucle ne soit parcourue aucune fois, à l'inverse de l'instruction REPEAT...UNTIL.
|
|
|
|
| |
| |
