| |
|
|
| Qu'est ce que le GFA-Basic, les origines? |
Après la déception provoquée par le BASIC Atari d'origine et la longue attente d'une alternative, les possesseurs d'un Atari ST reçurent enfin une excellente nouvelle: il existait un nouveau BASIC, GFA-Basic, dont l'auteur était Frank Ostrowski. les fanas de l'informatique purent vite constater que ce qui se passait sur l'écran surpassait largement ce à quoi le BASIC les avait habitués. La rapidité de l'interpréteur est telle qu'elle rend le Basic interessant même pour un travail professionnel. Si on en plus on utilise le compilateur, on peut même dire qu'il y a peu de chances qu'on rencontre des problèmes de programmation qui exigent une rapidité encore plus grande. L'atout que constitue la programmation structurée permet d'obtenir dans les codes sources une clarté et une facilité d'analyse qui étaient restées jusqu'ici l'apanage du Pascal, du 'C', etc... On peut ainsi oublier le code "spaghetti" qui a longtemps caractérisé le BASIC. Enfin, la quantité d'instructions et routines que Frank Ostrowski a integrées exige un certain temps, d'apprentissage pour qu'un programmeur puisse les exploiter à fond. On peut donc dire que le GFA-Basic définit un nouveau standard pour les langages de programmation.
Source: Livre Data Becker, Trucs et Astuces.
A savoir que l'auteur de ce langage a mis 6 mois pour réaliser entièrement l'interpréteur et le compilateur, soit une prouesse pour l'époque.
|
|
| Comment utiliser ce langage? |
Il vous faut tout d'abord télécharger la dernière version que vous trouverez dans la rubrique téléchargement.
Ensuite envoyez tout le contenu du dossier bin sur votre calculatrice. GFA-Basic ne possède pas encore d'environnement, il va falloir donc executer une ligne de commande pour pouvoir lancer votre programme.
Créez un fichier TEXT que vous nommerez test et écrivez les lignes suivantes:
Cls
Setfont F_8X10
Print "Hello World!!!"
Repeat
Until RR_ESC
Revenez à l'écran Home et lancez la commande: gfaexec("test")
Voilà, à présent vous savez comment executer un programme écrit en GFA-Basic, si cela ne fonctionne pas, vérifiez que vous avez correctement créé le fichier texte et que vous avez correctement tapé la commande.
|
|
| Quels sont les types de variables? |
En GFA-Basic il existe 4 types de variables.
Les flottants, aucun prefixe. Un flottant est stocké sur 10 octets et correspond au format du TIOS.
Les entiers, avec le préfixe %. Un entier est stocké sur 4 octets. C'est un nombre sur 32 Bits signés, la valeur minimale étant -2 147 483 648 et la valeur maximale étant +2 147 483 647.
Les booléens, avec le préfixe !. Un booléen est une variable stockée sur 1 octet qui peut prendre que 2 valeurs différentes, soit -1 pour vrai (TRUE) ou 0 pour faux (FALSE). Ce type de variable est très pratique pour manier les conditions...
Les chaînes de caractères, avec le préfixe $. Une chaîne de caractères est de taille variable plus précisément taille de la chaîne de caractères plus la taille d'un caractère nommé caractère NULL marquant la fin de la chaîne. La taille maximale d'une chaîne de caractères est de 32767 octets.
La gestion des chaînes de caractères est naturellement indépendante de la gestion des variables numériques, ainsi si vous essayez de faire des calculs avec des nombres ou avec des variables numériques, l'interpréteur vous le signalera en émettant une erreur.
Si votre programme n'utilise que des nombres entiers, n'hésitez pas à n'utiliser que des variables du type entier. La gestion des flottants est assez lente, vous pouvez le constater par vous même en faisant un programme traitant que des flottants et le même mais avec que des entiers.
Il est vivement conseillé de manipuler les booléens, si vous utilisez des flags (drapeaux) dans votre programme.
N'oubliez pas que mélanger le type de variable entraine une 'surcharge' d'opérations pour l'interpréteur et ralenti votre programme. Pensez donc à maitriser ce sujet, votre programme pourra ainsi s'optimiser facilement rien qu'en organisant et en gérant mieux les variables. Dans certains cas le gain peut être très important (2x ou 3x plus rapide!).
Quand vous écrivez un nombre dans votre code, il est possible de forcer son type. Par exemple un entier écrit de cette façon par exemple:
521445
sera du type entier est sera stocké sur 4 octets mais si vous préférez optimiser votre programme plutôt en vitesse qu'en taille pour x raisons et que vous n'utilisez que des flottants, le nombre 521445 écrit de cette façon 521445. ou 521445.0 sera par défaut du type flottant et sera stocké sur 10 octets. Si il arrive que vous dépassiez la valeur maximale ou minimale d'un nombre du type entier par exemple:
-5214455211144521
ce nombre sera automatiquement du type flottant. Autrement si par calculs divers vous dépassez le contenu d'une variable du type entier, son résultat sera retranché à l'aide d'un modulo. Autrement dit, le type d'une variable est fixe et ne peut changer au cours du programme!
Pour finir, les booléens sont les seules variables directement exploitables par les structures de conditions telles que IF, WHILE...LOOP, REPEAT...UNTIL... Tout autre résultat qui n'est pas directement sous format d'un booléen dans une condition sera automatiquement transformé en booléen.
Un tuto fera l'objet des variables et donnera plusieurs astuces pour optimiser un programme écrit en GFA-Basic.
|
|
| Est-il possible d'interrompre à tout moment l'exécution d'un programme? |
|
Il est possible d'interrompre à tout moment l'exécution d'un programme en appuyant tout simplement sur la touche [ON]. Ceci déclenche une erreur nommée Break et interrompt l'exécution du programme. Cette touche est valide si elle n'est pas désactivée (il est toute fois fortement déconseillé de la désactivée car si un programme tourne en rond et se trouve dans une boucle infinie, la seule façon de l'interrompre sera de provoquer un Reset de la machine pouvant entrainer la perte de données).
|
|
| GFA-Basic permet-il de récupérer des erreurs sérieuses? |
GFA-Basic est en effet capable de récupérer des erreurs sérieuses pouvant être produites par une mauvaise utilisation des fonctions Peek et Poke ou encore à un bug interne à GFA-Basic.
Il est possible d'activer sans risque le gestionnaire d'exceptions, s'occupant d'intercepter les erreurs sérieuses pouvant entrainer un plantage de la machine. Tapez le code suivant dans votre programme:
POKE 1,1 'Ceci provoque l'exception Protect Memory Violation
Cette ligne écrit la valeur 1 sur un octet à l'adresse 0x000001 or les adresses hautes sur TI68K sont protégées et une écriture non autorisée provoque une exception.
Voici à quoi ressemble le gestionnaire d'exceptions, il est constitué de 4 pages dont 3 permettent de nous renseigner sur l'état de la machine lors du plantage.
A la page n°1, vous trouverez un texte indiquant que le gestionnaire d'exception a intercepté une erreur et vous invite à transmettre un rapport de bug si cette erreur n'est pas une erreur de manipulation de votre part (souvent produite par Peek et Poke).
A la page n°2, on trouve des informations concernant l'état du processeur ainsi que l'exception générée. Ces informations sont utiles pour permettre au(x) développeur(s) de GFA-Basic de trouver le bug en question qui a provoquer ce plantage et de le corriger.
Aux pages suivantes, on trouve des informations concernant l'interpréteur.
La page n°3 nous renseigne sur le modèle de la calculatrice utilisé et donne des informations relatives à des pointeurs de gestion de données internes à l'interpréteur. Ces pointeurs sont essentiels pour déterminer quelle instruction à provoquer une erreur et surtout dans quelle condition l'erreur a été produite (débordement de piles, instruction incorrecte...).
La page n°4, contient d'autres informations relatives à la structure interne de l'interpréteur ainsi que l'espace mémoire en RAM libre (utile dans le cas où il y a eu écrasement de données...).
Si vous rencontrez une erreur qui provoque l'ouverture de ce gestionnaire d'exceptions, vous devez vous assurer dans un premier temps que cette erreur ne provient pas de votre source (voir Peek et Poke) pour cela explorez votre code source et essayez d'isoler le problème. Si vous pensez que cette erreur est un bug de GFA-Basic, envoyez un rapport complet avec un descriptif des manipulations que vous avez effectuées, le modèle de votre calculatrice... et surtout votre source à l'adresse suivante: gfabasic@tigen.org
Il est possible de quitter le gestionnaire d'exceptions en interrompant GFA-Basic en appuyant tout simplement sur la touche [ESC] ou [ENTER], si vous constatez qu'il est impossiblde de quitter le gestionnaire alors il ne vous reste plus qu'à faire un Reset de votre machine en appuyant sur F5.
Le gestionnaire d'exceptions permet dans la majorité des cas de 'déplanter' la machine et de permettre d'utiliser sa calculatrice de façon stable. Néanmoins il est possible qu'après l'interception d'une exception que la machine ne soit plus stable.
Le déclenchement du gestionnaire d'exceptions est la dernière couche de détection d'erreurs de GFA-Basic. Il correspond à une détection bas niveau d'erreurs produites par des instructions bas niveau (de l'assembleur ou encore d'instructions modifiant le contenu de la mémoire).
|
|
| Comment sont organisées les variables en mémoire par GFA-Basic? |
Le GFA-Basic possède quatre types de variables différents:
Les variables sans suffixe distinctif représentent des réels à virgule flottante qui sont mémorisés sur 10 octets sous forme binaire. Avec une précision assez importante.
Les variables avec le suffixe % (par exemple A%) sont des variables entières (Integer), dont la mémorisation nécessite 4 octets. Avec ce type de variables, on peut représenter des nombres entiers allant de -2 milliards à +2 milliards environ (-2147483648 à +2147483647 exactement).
Les variables booléennes sont suivies du caractère ! et ne peuvent prendre que deux valeurs : la valeur 0 (pour Faux) et -1(en fait toute valeur différentes de 0 : pour Vrai). Elles utilisent un octet (parfois deux octets en cas d'alignement de données).
Les variables alphanumériques (variables chaînes de caractères) ont pour suffixe le caractère $. De telles variables peuvent contenir au maximum 32767 caractères, car, dans le descripteur (voir plus bas) d'une variable alphanumérique, seuls deux octets sont utilisés pour indiquer la longueur.
Les noms de variables doivent toujours commencer par une lettre alphanumérique et peuvent avoir une longueur de 64 caractères maximum.
Pour différenceier les variables, toute la longueur du nom est prise en compte naturellement.
Les caractères suivant la lettre alphanumérique initiale peuvent être des lettres, des chiffres, le souligné ou le point.
Si une instruction d'affectation commence par LET, on peut même utiliser des mots clés (nom d'instruction) (même si cela n'est pas conseillé) comme nom de variables. Ainsi, la ligne suivante est tout à fait autorisée:
LET LET=17
En BASIC Gfa, il y a donc très peu de mots réservés.
Grâce à l'instruction VARPTR(var) (pointeur de variables), on peut accéder à l'adresse en mémoire du premier octet de la zone-mémoire où le BASIC Gfa place le contenu de 'var'.
Pour pouvoir mémoriser les chaînes de caractères et les tableaux (champs), on utilise un descripteur.
Le descripteur est stocké sur 6 octets, dont les quatres premiers représentent une adresse. La signification des deux derniers est différente selon qu'il s'agit d'une chaîne de caractères ou d'un tableau.
Examinons donc séparément les descripteurs de chaînes de caractères et de tableaux. Commençons par le plus simple : l'organisation des chaînes de caractères en mémoire:
Avec l'instruction ARRPTR(var), on obtient l'adresse du premier octet du descripteur. Comme nous l'avons déjà dit, les quatre premiers octets du descripteur indiquent une adresse. C'est l'adresse où est placé le premier caractère de la chaîne. Cette adresse est identique à celle que retourne l'instruction VARPTR. Les deux derniers octets du descripteur indiquent la taille de la chaîne. A la fin de la chaîne mémorisée, on trouve, un octet de remplissage couramment appelé octet NULL.
Plus tard viendra, après ce fameux octet NULL, l'adresse de début du descripteur correspondant (on appelle cette adresse 'backtrailer'. Il permettera d'accélérer sensiblement l'exécution du processus appelé Garbage-Collection (la collecte et l'effacement des zones mémoires qui ne sont plus utilisées)).
Le programme suivant devrait permttre de comprendre encore mieux l'organisation des chaînes de caractères en mémoire:
CLS
A$="GfA"
PRINT "Adresse du descripteur:"'
PRINT ARRPTR(A$)
PRINT "Adresse de début de la chaîne:"'
PRINT LPEEK(ARRPTR(A$))
PRINT "Pour vérification:"'
PRINT VARPTR(A$)
PRINT "Longueur de la chaîne:"'
PRINT DPEEK(ARRPTR(A$)+4)
PRINT "Chaîne de caractères:"'
PRINT CHR$(PEEK(VARPTR(A$)));
PRINT CHR$(PEEK(VARPTR(A$)+1));
PRINT CHR$(PEEK(VARPTR(A$)+2))
PRINT "Octet de remplissage:"'
PRINT PEEK(VARPTR(A$)+3)
Examinons à présent la manière dont les tableaux (champs ou array) sont stockés en mémoire:
On accède aux tableaux de la même façon que pour les chaînes, c'est-à-dire par l'intermédiare d'un descripteur (descripteur de tableau). L'adresse de début du descripteur est également obtenue à l'aide de l'instruction ARRPTR(tab()). Les quatre premiers octets du descripteur de tableau contiennent l'adresse du début du tableau. Les deux derniers octets indiquent le nombre de dimensions du tableau (exemple : quatre pour A(3,4,5,7)).
Au début du tableau se trouvent, contenu dans chaque fois deux octets, les nombres d'éléments dans chaque dimension. On commence par la dernière dimension (avec l'exemple précédent A(3,4,5,7), les deux premiers octets contiennent la valeur 8, les deux suivants la valeur 6, les deux suivants la valeur 5 et les deux derniers la valeur 4 (ne pas oublier que l'indice commence à 0)).
On trouve ensuite le contenu des différents éléments du tableau. Pour des tableaux de réels, chaque élément occupe 10 octets, pour des tableaux d'entiers relatifs (Integer), 4 octets, et pour des tableaux de booléens, 1 seul octet.
S'il s'agit d'un tableau de chaînes de caractères, on n'obtient pas directement le contenu des chaînes, mais leurs descripteurs. Ces descripteurs de chaînes ont le même format et la même fonction que ceux décrits dans la première partie.
Pour se familiariser avec cette organisation des tableaux qui peut paraître confuse au premier coup d'oeil (surtout en ce qui concerne les tableaux de chaînes de caractères), il est conseillé de programmer l'exemple suivant:
CLS
DIM A$(1,0)
A$(0,0)="A"
A$(1,0)="BC"
D=ARRPTR(A$())
PRINT "Adresse du descripteur de tableau:"'D
F=LPEEK(D)
PRINT "Adresse du tableau:"'F
PRINT "Nombre de dimension:"'
PRINT DPEEK(D+4)
PRINT "Nombre d'éléments dans la 2ème dim.:"'
PRINT DPEEK(F)
PRINT "Nombre d'éléments dans la 1ère dim.:"'
PRINT DPEEK(F+2)
PRINT "Adr. du descripteur pour 0,0:"'
PRINT F+4
PRINT "Adr. dans le descripteur pour 0,0:"'
PRINT LPEEK(F+4)
PRINT "Longueur de la chaîne 0,0:"'
PRINT DPEEK(F+8)
PRINT "Adr. du descripteur pour 1,0:"'
PRINT F+10
PRINT "Adr. dans le descripteur pour 1,0:"'
PRINT LPEEK(F+10)
PRINT "Longueur de la chaîne 1,0:"'
PRINT DPEEK(F+14)
PRINT "Vérification pour 0,0:"'
PRINT VARPTR(A$(0,0))
PRINT "Vérification pour 1,0:"'
PRINT VARPTR(A$(1,0))
PRINT "Chaîne 0,0:"'
PRINT CHR$(PEEK(LPEEK(F+4)))
PRINT "Chaîne 1,0:"'
PRINT CHR$(PEEK(LPEEK(F+10)));
PRINT CHR$(PEEK(LPEEK(F+10)+1))
|
|
| |
| |
