LISTE DES MOTS CLÉS SPÉCIFIQUES.

Mots clés du BBC BASIC.

# : en tant que suffixe, indique une variable double de 64 bits.

$ : en tant que suffixe, indique une variable de chaîne.

$$ : écrit une chaîne terminé par NUL dans la mémoire. 

% : en tant que préfixe, il indique une valeur binaire, par exemple %11101111.

% : en tant que suffixe, indique une variable entière (signée 32 bits).

%% : indique une variable signée 64 bits.

& : en tant que préfixe, il indique une valeur hexadécimale, par exemple &AC.

& : en tant que suffixe, indique une variable de type octet (8 bits non signés).

^ : retourne l'adresse mémoire à laquelle débute une variable.

CLEAR : détruit toutes les variables déclarées dynamiquement.

EVAL() : retourne la valeur numérique contenue dans une expression dans une chaine de caractères.

INT() : retourne la partie entière d'une valeur numérique.

LET : déclare une variable, en lui affectant une valeurs si besoin (ne doit plus être utilisé).

STR$() : convertie une valeur numérique en chaine de caractères.

SWAP : échange le contenu de deux variables, de deux tableaux ou de deux structures.

VAL() : convertit un chaine de caractères en une valeur numérique.

Module de la bibliothèque du BBC BASIC.

bigint.bbc : propose des procédures et des fonctions pour l'arithmétique pour grands nombres entiers.

GÉNÉRALITÉS.

Lorsqu'une variable n'a pas été définie ou n'a pas de suffixe de type, sa valeur est du type numérique variable.

Dans BBC BASIC les noms de variables peuvent être de n'importe quelle suite de lettres majuscules ou minuscules, de chiffres, ainsi que du caractère de soulignement et l'apostrophe, de n'importe quelle longueur, mais ils doivent commencer par une lettre, majuscule (de A à Z) ou minuscule (de a à z), par le caractère de soulignement (_) ou un apostrophe (` ou CHR$( 96 ) ). Ils ne doivent pas commencer par un mot réservé du langage BBC BASIC.

Les noms de variables sont sensibles à la casse. Ainsi knom, KNOM, kNom, Knom, ... désignent des variables différentes. Et des noms de variables identiques mais avec un suffixe différent sont aussi des variables différentes. Donc kvaleur, kvaleur$, kvaleur#, kvaleur%, kvaleur& sont des variables différentes et de types différents.

Des noms de variables choisis judicieusement, indiquant ce qu'elles représentent, facilitera grandement la lecture du script pour la recherche d'éventuelles erreurs, la maintenance et l'amélioration future du programme.

Comme dans la plupart des langages de programmation modernes, dans BBC BASIC, il n'est plus utile de déclarer une variable pour pouvoir l'utiliser. Dans BBC BASIC seules les variables composites : les tableaux de données et les structures de données, doivent être déclarées avant toute utilisations. De plus les pseudo-variables, voir plus bas, ne doivent jamais être déclarées.

Pour déclarer une variable ordinaire, il suffit donc de lui affecter une première valeur selon la forme : variable = valeur, où : 

- variable est l'identifiant, le nom, de la variable avec si besoin un suffixe précisant le type de donnée ;

- = dans ce cas est l'opérateur d'affectation ;

- valeur est une expression : nombre, opération, chaine de caractères, instruction de conversion, valide pour le type de variable.

On peut aussi créer des variables en les nommant comme paramètres lors de la définition de fonctions personnalisées PROC ou FN. Par exemple : 

PROC_Aire( kaire )

DEF PROC_Aire( longeur , klargueur , RETURN ksurface )

Les variables klongeur, klargueur et ksurface seront crées et initialisées à l'entrée de la fonction personnalisée, et pourront être utilisée dans celle-ci mais la valeur de ksurface sera retournée et affectée à la variable kaire qui sera ainsi créée.

On peut aussi créer des variables en les associant aux instructions : INPUT, MOUSE, READ et SYS :

INPUT "Bonjour, comment t'appelle-tu " , knom$

MOUSE kabscisse , kordonnee , kbouton

READ kmois$ , kjours

SYS "GetTickCount" TO kcompteur%

On peut aussi créer des variables en les incluant dans la liste des paramètres d’une instruction CALL 

CALL kcode , kcompteur% , knom$

Enfin, en utilisant l'adresse de l'opérateur : SYS "GetFileSize", @hfile%(F%) , ^ktaille%

A noter que l'instruction FOR, utilise une variable de controle pour son fonctionnement, mais que celle-ci est créée à l'entrée de la boucle et ne doit pas être déclarée au préalable.

Pour assurer la rétrocompatibilité avec d'anciens scripts, l'instruction LET, dont l'utilisation était obligatoire pour déclarer une variable avant son utilisation dans les premières versions du BBC BASIC, reste disponible.

A l'exception des variables statiques, voir plus bas, il est possible détruire toutes les variables d'un programme avec la l'instruction CLEAR. Après l'exécution de l'instruction CLEAR, toutes les variables déclarée avant cet appel ne seront plus accessibles. Si le programme tente de les utiliser, une erreur sera retournée. Par exemple :

A% = 123

knombre = 10

ktexte$ = "texte"

PRINT knombre , ktexte$ , A% : REM retourne 10 texte 123

CLEAR

PRINT A% : REM retourne 123

PRINT knombre , ktexte$ : REM retourne No such variable

L'instruction SWAP permet de permuter les valeurs de 2 variables de même types. Par exemple :

klongueur = 26

klargeur = 10

khauteur# = 7.5

PRINT klongueur , klargeur , khauteur# : REM retourne 36      10      7.5

SWAP klongueur , klargeur

PRINT klongueur , klargeur , khauteur# : REM retourne  10     36      7.5

SWAP klongueur , khauteur# : REM retourne Type mismatch

PRINT klongueur , klargeur , khauteur#

A noter que dans BBC BASIC le type constante n'existe pas.

LES TYPES DE VARIABLES UTILISATEURS.

Pour les variables qui doivent recevoir des chaines de caractère on utilisera le suffixe $.

Les machines modernes disposant d'une grande quantité de mémoire, il n'est plus très utile de choisir le type le mieux adapté aux valeurs que pourra recevoir une variable numérique, donc dans l'immense majorité des cas on ne précisera pas de type. Toutefois, si des variables ne doivent accepter qu'un certain type de valeur, utiliser un suffixe pourra alors s'avérer intéressant pour remplacer toute valeur non conforme par une valeur par défaut, 0 en général, et éviter des interruptions du programme dû à d’éventuelle valeur erronée.

RAPPEL : Dans BBC BASIC, on doit utiliser le point (.) et non la virgule (,), pour séparer la partie entière d'un nombre de sa partie décimale.

Variables numériques variantes.

Lorsqu'une variable n'a pas été définie ou n'a pas de suffixe de type, sa valeur est du type numérique variable.

Les variables numériques variantes n'ont pas de caractère suffixe et peuvent contenir des entiers ou réels.

Sur les plateformes x86 (Windows, MacOS, Linux), les variables numériques variantes peuvent contenir soit une valeur entière signée de 64 bits, soit une valeur à virgule flottante de 80 bits (10 octets) composée d'une mantisse de 64 bits et d'un exposant de 16 bits, avec une plage d'environ ±3,4E−4932 à ±1,1E4932 et une précision d'environ 19 chiffres significatifs.

Sur les plateformes ARM (Raspberry Pi, Android, iOS) et l'édition dans le navigateur, les variables numériques variantes peuvent contenir soit une valeur entière signée de 64 bits, soit une valeur à virgule flottante de 64 bits (8 octets) composée d'une mantisse de 53 bits et d'un exposant de 11 bits, avec une plage d'environ ±2,3E−308 à ±1,7E308 et une précision d'environ 15 chiffres significatifs.

Variables numériques en octets (&).

Elles peuvent être n'importe quel nombre entier compris entre 0 et +255, et ne sont donc pas signées. 

Les variables d'octets sont particulièrement utiles en tant que membres de structure, car elles peuvent être utilisées comme blocs de construction pour créer des structures de données de n'importe quelle taille. Lors de l'attribution d'une valeur à une variable d'octet, celle-ci est évaluée modulo - 256 (équivalent à AND &FF).

Variables numériques entières de 32 bits (%).

Elles peuvent être n'importe quel nombre entier compris entre −2147483648 et +2147483647.

Il n'est pas nécessaire de déclarer une variable comme un entier pour bénéficier de l'arithmétique rapide des entiers. Par exemple, les boucles FOR / NEXT s'exécutent à la vitesse d'un entier, que la variable de contrôle soit ou non de type %, à condition qu'elle ait une valeur entière.

Variables statiques.

Les variables A%..Z% incluses sont appelées variables statiques. Il s'agit d'un type spécial de variable numérique entière qui ne sont pas effacées par les instructions RUN, CHAIN ​​ou CLEAR.

En tant que telles, ces variables peuvent être utiles pour transférer des valeurs entre programmes ou pour conservées des valeurs lorsque les autres variables doivent être effacées. Elles sont également accessibles légèrement plus rapidement que les autres variables.

A noter aussi que les variables :

- A%, B%, C%, D%, F%, X% et Y% ont des utilisations spéciales dans les routines CALL et USR, et :

- L%, O% et P% ont une signification particulière dans l'assembleur.

Variables numériques entières de 64 bits (%%).

Elles peuvent être n'importe quel nombre entier compris entre −9223372036854775808 et +9223372036854775807.

Variables à virgule flottante 64 bits (#).

Elles peuvent être n'importe quel nombre à virgule flottante de 64 bits (8 octets) composée d'une mantisse de 53 bits et d'un exposant de 11 bits. Elles ont une plage d'environ ±2,3E−308 à ±1,7E308 et une précision d'environ 15 chiffres significatifs.

Variables de chaîne ($).

Elles peuvent être n'importe quelle combinaison de caractères ASCII imprimables, le nombre de caractères qu'elles peuvent contenir n'est limité que par la mémoire disponible sur le système de l'utilisateur. Elles débutent et se terminent par des guillemets, qui ne sont pas compris dans la valeur de la variable.

Tableaux de données.

Les tableaux de données sont des variables composites. Ils doivent être obligatoirement déclarés avant leur utilisations avec l'instruction DIM ou REDIM. Allez à la rubrique les tableaux de données pour plus de détails sur les tableaux de données.

Structures de données.

Les structures de données sont des variables composites. Ils doivent être obligatoirement déclarés avant leur utilisations avec l'instruction DIM{ } Allez à la rubrique les stuctures de données pour plus de détails sur les tableaux de données.

LES PSEUDO-VARIABLES DU BBC BASIC.

Les pseudo-variables sont des mots clés qui se comportent comme des variables. Il s'agit de : 

- HIMEM, qui contient l'adresse du premier octet au-dessus de la mémoire de programme ;

- LOMEM, qui contient l'emplacement en mémoire des structures de données dynamiques ;

- PAGE, qui contient l'adresse de départ du programme BASIC en cours ;

- PTR, qui contient la position du pointeur dans fichier d'accès aléatoire ;

- TIME, qui contient la valeur de l'horloge en centièmes de secondes ;

- TIME$, qui contient la valeur de l'horloge au format sem.jj mm aaaa,hh:mm:ss.

Leurs valeurs peuvent être modifiées, par exemple TIME = 0, ou retournée, par exemple kactuel = TIME, selon le contexte.

Les pseudo-variables ne peuvent pas être utilisées : 

- comme paramètres formels de fonctions ou de procédures ; 

- avec l'instruction LOCAL pour les rendre de portée locale ; 

- comme variable de contrôle dans un boucle  FOR  NEXT ; 

- comme paramètre à CALL et ; 

- dans des instructions INPUT, MOUSE, READ ou SYS.

LA PORTÉE DES VARIABLES.

Dans BBC BASIC toutes les variables sont, par défaut, de portée globale. C'est-à-dire que leur valeur peut être lue ou modifiée dans tout le script, même dans les fonctions et procédures personnalisées PROC et FN.

Cependant, les fonctions personnalisées PROC et FN peuvent créer des variables qui seront de portée locale, c'est-à-dire que leur valeur ne pourra être lue ou modifiée qu'à l'intérieur de la fonction personnalisée qui les aura déclarées. On utilisera l'instruction : 

- LOCAL, pour déclarer une variable locale qui devra être réinitialisée à chaque appel de la fonction ;

- PRIVATE, pour déclarer une variable locale dont la valeur devra être préservée pour le prochain appel de la fonction.

CONVERTION DE VALEUR.

Le BBC BASIC propose un certain nombre d'instructions permetant convertir une valeur d'un type vers un autre type.

La fonction INT( ) retourne la partie entière d'une valeur numérique. Si la valeur indiquée n'est pas d'un type numérique une erreur sera relevée. Par exemple :

PRINT INT( 123.34 ) : REM retourne 123

kvaleur = 123.98 : PRINT INT( kvaleur ) : REM retourne 123

PRINT INT( "123.34" ) : REM retourne Type mismatch

La fonction EVAL( ) retourne, si cela est possible, la valeur numérique contenue dans une expression dans une chaine de caractères. Si l'expression contenue dans la chaine de caractère ne correspond pas à une valeur numérique, une erreur sera retournée. Par exemple :

kvaleur = EVAL( "1234" )

PRINT kvaleur : REM retourne 1234

PRINT EVAL( "1234" ) : REM retourne 1234

PRINT EVAL( "12.34" ) : REM retourne 12.34

PRINT EVAL( "-1234" ) : REM retourne -1234

PRINT EVAL( "+1234" ) : REM retourne 1234

PRINT EVAL( "12+34" ) : REM retourne 46

PRINT EVAL( "BBC BASSIC" )  : REM retourne No such variable et stoppe le programme

La fonction VAL() retourne la valeur numérique correspondante à une chaine de caractères. Cette fonction lit les caractères de son argument de gauche à droite et les converti en chiffre jusqu’à ce qu'elle rencontre un caractère qui ne peut pas être une valeur numérique. Si la chaine de caractère ne commence pas par un chiffre ou n point, la fonction retourne 0. Par exemple :

kpi = VAL( "3.14" ) 

PRINT kpi : REM retourne 3.14

PRINT VAL( "3.14" )  : REM retourne 3.14

PRINT VAL( "8" ): REM retourne 8 

PRINT VAL( "-8" ): REM retourne -8 

PRINT VAL( "+8" ): REM retourne 8

PRINT VAL( "Dix-sept : 17" ): REM retourne 0

PRINT VAL( "12 pouces" ): REM retourne12

La fonction STR$( ) convertie une valeur numérique en chaine de caractères.

kpi$ = STR$( 3.14 )

PRINT kpi$ : REM retourne 3.14

PRINT STR$( 3.14 ) : REM retourne 3.14

ADRESSE MEMOIRE D'UNE VARIABLE.

Vous pouvez découvrir l'adresse mémoire à laquelle une variable est stockée en utilisant l'opérateur "adresse de" : ^ (accent circonflexe). Une fois que vous connaissez son adresse, vous pouvez accéder à la valeur d'une variable au moyen de l'opérateur d'indirection approprié :

A% = 1234

PRINT !^A%

Cela fonctionne pour tous les types de variables (entier, virgule flottante, chaîne, tableau, etc.) mais dans le cas d'une variable de chaîne normale, l'adresse renvoyée n'est pas celle du premier caractère de la chaîne mais celle du descripteur de chaîne de 6 ou 8 octets (voir l'instruction CALL pour plus de détails sur les descripteurs de chaine). Par conséquent, l'adresse de la chaîne elle-même est !^kvariable$ ou alternativement PTR( kvariable$ ).

Dans le cas d'un tableau, l'adresse renvoyée par ^LST_Tableau( ) est celle d'un pointeur vers le bloc de paramètres du tableau, donc l'adresse du bloc de paramètres est !^LST_Tableau( ). Pour obtenir l'adresse des données du tableau, vous devez spécifier le nom du premier élément, par exemple ^LST_Tableau( 0 ).

Connaitre l'adresse mémoire d'une variable peut sembler peu utile, mais peut s'avérer utile dans des circonstances particulières, notamment lors de l'appel de fonctions API Windows™ ou SDL 2.0 ou dans du code en langage assembleur. Par exemple, la fonction ReadFile nécessite de passer l'adresse d'une variable dans laquelle le nombre d'octets lus sera renvoyé : SYS "ReadFile", @hfile%( kfichier% ) , kstore% , ktaille% , ^kbytesread% , 0

Dans le code en langage assembleur, vous souhaiterez peut-être copier la valeur d'une variable BBC BASIC (entier) dans l'un des registres du processeur :déplacer eax,[^variable%]

Notez que les variables statiques A% à Z% occupent des emplacements consécutifs en mémoire, ce qui peut être pratique lorsqu'une fonction API nécessite l'adresse d'une structure plutôt qu'une simple variable. Par exemple, GetCursorPos nécessite l'adresse d'une structure POINT dans laquelle elle renvoie deux valeurs :

SYS "GetCursorPos", ^X%. Cela renverra la coordonnée horizontale du curseur en X% et la coordonnée verticale en Y%.

Une autre utilisation consiste à modifier l'ordre des octets d'une variable, par exemple de little-endian à big-endian. Le segment de code suivant inverse l'ordre des octets de la valeur stockée dans A% :

SWAP ?( ^A% + 0 ), ?( ^A% + 3 )

SWAP ?( ^A% + 1 ) , ?( ^A% + 2 )

Voir la gestion de la mémoire pour plus de détails sur la gestion de la mémoire.