Langage BASIC du VPC-32V
Licence
Ce document fait partie du projet VPC-32V et est fourni sous licence
CC-NC-SA-BY V3.0
auteur: Jacques Deschênes
révision 1.0
Copyright: 2013-2018, Jacques Deschênes
Présentation
L'ordinateur VPC-32V possède un interpréteur BASIC inspiré de QBASIC mais n'est pas indentique. Le code source BASIC est
d'abord compilé en bytecode pour être exécuté sur une machine virtuelle à piles. Ce document décris le langage BASIC et son utilisation.
Caractéristques du langage.
- Types de données
- Entier 32 bits signé, {-2147483648...2147483647}
- Entier 8 bits (octet) non signé, {0-255}
- Chaîne de caractères ASCII, {0-127}
- Nombres en virgules flottante 32 bits
- Tableau unidimensionnel de ces 4 types de données
- Programmation structurée
Contrairement au BASIC des années 70-80 vpcBASIC est un language de programmation structuré de type procédural basé sur
des fonctions déclarées avec le mot réservé FUNC ainsi que des sous-routines déclarées avec
le mot résservé SUB. Il n'y a pas de numéros de lignes ni de GOTO ou GOSUB comme dans les versions plus ancienne de BASIC.
Pour l'essentiel je me suis inspiré de QBASIC qui venait avec MS-DOS à partir de 1991.
La compilation se fait en 1 seule passe, cependant les appels en références avant sont possible grâce à l'utilisation du mot clé DECLARE.
Il en va de même avec les variables tableaux qui doivent-être définies avec la commande DIM avant d'être référencées. Par contre une variable
scalaire globale est créée automatiquement lors de la première référence si elle n'existe pas. Cette auto-création des variables
scalaire n'est valide qu'à l'extérieur des fonctions et sous-routines.
vpcBASIC est insensible à casse tous les mots réservés et indentificateurs de variables sont convertis en majuscules par le compilateur.
conventions typographiques
les éléments de syntaxe indiqués entre '[' et ']' sont des éléments optionnels. si le caractère '+'
suit le caractère ']' l'élément peut-être répété un nombre abritraire de fois.
le caractère '|' sépare les alternatives
Dans les exemples le > au début d'une ligne représente l'invite de la ligne de commande.
expr signifie une expression arithmétique.
str_expr signifie une expression chaîne. Le signe + peut-être utilisé pour concaténer des chaînes.
expr_list liste d'expression numérique. Les éléments sont séparés par la virgule ','.
cond signifie une condition logique résultant de la comparaison de 2 expr.
log_expr signifie un ensemble de cond reliées par les opérateurs logiques AND et OR.
arg_list est la liste des arguments passés à une sous-routine ou fonction. La virgule ',' est le séparateur de liste.
val_list est une liste de valeur numérique ou chaîne servant à initialiser un tableau lors de sa déclaration.
var représente un nom de variable.
num représente un nombre entier.
float représente un nombre en virgule flottante
const représente une constante numérique.
block groupe d'instructions BASIC.
Opérateurs par ordre de précédence
Cette table montre les opérateurs par ordre de précédence. À précédence égale les opérateurs sont traités de gauche à droite.
| opérateur | description |
|---|
| () | Parenthèses de groupement d'expression. Le groupement entre parenthèses est réservé aux expression arithmétiques.
Les cond et les log_expr ne peuvent pas être regroupées. |
| func() | Les fonctions ont la plus haute priorité dans les expression arithmétiques. |
| * / % | multiplication, division entière, modulo |
| + - | addition soustraction |
| = >= < <= <> >< | les opérateurs de comparaison utilisés dans les cond |
| NOT | négation logique appliquée au résultat d'une cond |
| AND | conjonction logique appliqué entre les cond |
| OR | alternative logique appliqué entre les cond |
nom de variables
Les noms de variables sont insensibles à la casse. Tous les noms sont convertis en majuscules par le compilateur. Un nom peut
avoir un maximum de 31 caractères, doit commencer par une lettre mais peut contenir des chiffres et le caractère '_'.
Le type des variables peut-être déterminé de 2 façon.
- Par utilisation d'un caractère spécial à la fin du nom.
- $, il s'agit d'une variable chaîne.
- #, il s'agit d'une variable octet.
- !, il s'agit d'une variable float32.
- En l'absence d'un caractère spécial la variable est considérée comme entier 32 bits.
- AS INTEGER|STRING|BYTE|FLOAT
exemple:
dim var1 as integer
dim var2 as string
dim var3 as byte, var4 as float
On a donc ici déclarer 4 variables,
VAR1 de type entier 32 bits.
VAR2 de type chaîne de caractères.
VAR3 de type octet et
finalement
VAR4 de type float32.
valeurs litérales
Les valeurs litérales numérique peuvent-être saisie sous 3 formes:
- entier en décimal 23, -267 , -32560, 255
- entier en hexadécimal $23f2, $fff3
- virgule flottante 1.0, 3.23e-23
Les chaînes de caractères sont saisies entre guillemets '"'.
Un caractère ASCII est saisie en le précédent de la barre oblique '\'
example:
>print "Hello world"
Hello world
>putc \a
a
>|
fonctions et sous-routines
Les paramètres des fonctions et sous-routines sont passées par valeur sauf si le nom de la variable est précédé du
caractère '@'. Dans ce cas le paramètre doit-être le nom d'une variable qui est passée par référence.
example:
sprite(10,10,8,8,@lem#) ' lem# est le nom d'une variable taleau qui contient un sprite.
' ce tableau doit-être passé par référence.
Le type de la valeur retournée par une fonctions peut-être déterminé en utilisant un caractère spécial à la fin du nom de la
fonction comme pour les variables. Le mot clé AS n'est pas supporté pour les fonctions et non plus pour la liste des arguments de FUNC
et SUB. Le programmeur doit s'assurer qu'il passe des paramètres du bon type.
Si une fonction est appellée comme s'il s'agissait d'une sous-routine, la valeur retournée est simplement jetée comme c'est le cas dans le langage
C.
commandes BASIC
index
- @
Permet de passer une variable par référence.
Lors de l'appel d'une sous-routine ou d'une fonction normalement les arguments sont passé par valeur.
Mais certaines procédures ou fonctions utilisent des arguments de type pointeur.
Il suffit de faire précéder le nom de la variable du caractère @ pour passer une pointeur vers
cette variable.
exemple:
Pour afficher un sprite sur l'écran VGA il faut passer le tableau qui contient le sprite par référence. Dans cet exemple sp est une tableau de type
octets qui contient le sprite à afficher.
- ABS(expr)
Fonction qui retourne la valeur absolue de l'expresssion passée comme paramètre.
- expr, expression numérique dont la valeur absolue sera retournée.
exemple:
- ACOS(expr)
Fonction trigonométrique qui retourne l'arc-cosinus exprimé en radians.
- expr, expression numérique qui représente le cosinus d'un angle.
exemple:
La valeur retournée 1.0472 est en radians.
- AND
Conjonction logique ET utilisé dans les log_expr. L'opérateur AND a une priorité plus élevé que
l'opérateur OR donc dans log_expr de forme A AND B OR C AND D, les relations A AND B
et C AND D sont évéaluées avant à la relation OR. On peut utiliser des parenthèses pour changer la priorité.
exemple:
if hour>=12 and hour<=17 then print "afternoon" end if
REM si la varialbe hour a une valeur entre 12 et 17 imprime le mot afternoon.
- APPEND$(str_expr1, str_expr2)
Fonction chaîne qui retourne la concaténation de 2 chaînes. Le deuxième argument étant attaché à la fin du premier.
- str_expr1, expression chaîne principale.
- str_expr2, expression chaîne secondaire ajoutée à la fin de la principale.
exemple:
>? append$("hello ","world!")
hello world!
>_
- AS
Ce mot réservé a 2 utilisations différentes.
Voir DIM.
Voir OPEN
- ASC(str_expr)
Fonction qui retourne la valeur ASCII du premier caractère de la chaîne passée en paramètre.
- str_expr, chaîne dont la valeur ASCII du premier caractère sera retournée.
exemple:
- ASINE(expr)
Fonction trigonométrique qui retourne l'arc-sinus de l'argument.
exemple:
>? asine(0.5)
0.523599
>_
La valeur retournée est en radians.
- ATN(expr)
Fonction trigonométrique qui retourne l'arctangeante de son argument.
- expr, expression numérique dont on veut connaître l'arctangeante.
exemple:
La valeur retournée est en radians.
- BEEP()
Génère une tonalité de 1000 hertz d'une durée de 40 millisecondes.
exemple:
Pour les sous-routines qui n'utilisent aucun argument les parenthèses sont optionnelles.
- BOX(x0,y0,width,height)
Dessine un rectangle plein sur le moniteur VGA.
- x0, représente la coordonnée x en pixels du coin supérieur gauche.
- y0, représente la coordonnée y en pixels du coin supérieur gauche.
- width représente la largeur de la boite en pixels.
- height représente la hauteur de la boite en pixels.
exemple:
Dans cet exemple, le coin supérieur gauche de la boite est à la position {10,20}, la largeur est de 100 pixels et la hauteur
de 50 pixels. Le fonctions graphiques sont limitées au moniteur VGA même si la commande est faite à partir de la console REMOTE.
- BTEST(expr,bit)
Fonction qui vérifie l'état d'un bit. Retourne vrai si le bit est à 1 sinon retourne faux.
- expr valeur entière pour laquelle on veut vérifier l'état d'un bit.
- bit bit est une expression de valeur comprise entre 0 et 31 puisque les entiers sont de 32 bits. 0 est le bit
le plus faible et 31 le plus fort.
exemple:
>n=44
>if btest(n,0) then ? "nombre impair" else ? "nombre pair" end if
nombre pair
>n=65
>if btest(n,0) then ? "nombre impair" else ? "nombre pair" end if
nombre impair
>_
- BYE
Cette commande termine l'éxécution d'un programme et peut-être utilisée n'importe où à l'intérieur d'un programme.
Invoquée en mode interactif provoque la sortie du shell BASIC vers le shell de commandes.
exemple:
> REM imprime chaque caractere saisie au clavier jusqu'a ce que 'q' soit enfoncé.
>while 1
>k=tkey()
>>if k=\q then bye end if
>>putc k
>>wend
ffafafajlfkjafklaj
>_
>bye
$echo a provoquer un retour au shell de commandes.
- CASE
Voir SELECT CASE
- CEIL(expr)
Fonction qui retourne un entier d'un float arrondie vers l'infini positif. Voir aussi FLOOR
- expr, paramètre numérique de type float.
exemple:
>? ceil(3.0001)
4
>? ceil(-3.999)
-3
>_
- CHR$(n)
Fonction chaîne qui retourne une chaîne de longueur 1 correspondant au code ASCII de n.
- n, valeur entière dans l'interval {0..255}.
exemple:
>? chr$(65)
A
>? chr$(97)
a
>_
- CIRCLE(cx,cy,r)
Fonction graphique qui dessine un cercle sur le moniteur VGA.
- cx, coordonnée x du centre du cercle exprimé en pixels.
- cy, coordonnée y du centre du cercle exprimé en pixels.
- r, rayon du cercle exprimé en pixels.
exemple:
>for i=10 to 100 step 10: circle(240,120,i):next i
>_
Cette exemple dessine 9 cercles concentriques au centre de l'écran.
- CLOSE(#n)
Ferme un fichier préalablement ouvert avec la commande OPEN.
- n, numéro assigné à ce fichier lors de son ouverture.
exemple:
rem file system test
open "hello.txt" for output as #1
print #1,"hello world\r"
putc #1, 33 : putc #1, 10
v$="bonjour\r": n=3*5
? #1, v$, n, 4*5+20, 32.5e-3
close(#1)
dim hello$
open "hello.txt" for input as #1
input #1, hello$
c=fgetc(#1)
input #1,x$,n1,n2,n3!
close(#1)
? hello$,c,x$,n1,n2,n3!
- CLS
Efface l'écran de la console active et positionne le curseur texte dans le coin supérieur gauche.
- CON REMOTE|LOCAL
Cette commande fonctionne à l'identique de la même commande dans le shell de commande et permet de passer de la console
locale à la console à distante. Cependant le passage d'un console à l'autre en vpcBASIC n'affiche aucun message et n'efface
pas l'écran.
exemple:
>REM impression d'un message sur la console remote
>REM a partir de la console locale.
>con remote: ? "hello world!" : con local
>_
Dans cet exemple on transfert à la console REMOTE ensuite on imprime le message "hello world!" pour ensuite
revenir à la console LOCAL. Cette commande peut-être utilisée pour envoyer et recevoir de l'information via le port
COM à partir d'un programme BASIC.
- CONST nom=valeur [,nom=valeur]
Déclare une ou plusieurs constantes séparées par une virgule ','.
- nom est le nom de la constante. Le type de la constante est défini de la même manière que pour les variables.
- valeur selon le type de la constante il s'agit d'un entier, d'un float ou d'une chaîne ASCII.
exemple:
>const pi as float=3.1415, e as float=2.718, nom$="Capitaine Bonhomme"
>? pi,e,nom$
3.1415 2.718 Capitaine Bonhomme
>nom$="hello"
line: 5
token#: 1
Constant can't be redefined
tok_id: 3
tok_value:
token_string: NOM$
>_
Lorsqu'on tente de redéfinir une constante le compilateur affiche une erreur.
- COS(expr)
Fonction trigonométrique cosinus.
- expr, expression qui représente un angle en radians.
exemple:
>? cos(3.1415) ' cosinus de PI i.e. 180°
-1
>? cos(3.1415/4) ' cosinus de 45°
0.707123
>
- CURCOL()
Retourne la position colonne du curseur texte, {0..79}.
exemple:
if curcol()=78 then locate(curline()+1,0) end if
Dans cet exemple on force un retour au début de la ligne suivante lorsque le curseur texte atteint la colonne 78.
- CURLINE()
Retourne la position ligne du curseur texte, {0..29}.
exemple:
if curline()=29 and curcol()=79 then scrlup(): locate(curline(),0) end if
Dans cet exemple on force un défilement vers le haut de l'écran lorsque le curseur atteint la dernière position de l'écran.
- DATE$
Fonction chaîne qui retourne la date inscrite dans le RTCC. Voir TIME$
exemple:
>? date$
Thursday 2018/06/28
>_
- DECLARE FUNC|SUB nom(arg_list)
Ce mot réservé sert à déclarer une fonction ou sous-routine sans la définir.
Ça permet de faire des appels à celle-ci avant qu'elle ne soit définie dans le texte source. Ce qui authorise les appels circulaire.
exemple:
>declare sub test1(n)
>sub test2(n)
>>test1(2*n)
>>end sub
>sub test1(n)
>>? 1.0*n/3
>>end sub
>test2(45)
30
>test2(4)
2.66667
>_
Dans cet exemple la sous-routine test1 est définie après la sous-routine test2 cependant test2 peut appeller test1 car
elle a été prédéclarée. Si on supprimait la déclaration le compilateur afficherait une erreur lorsque test2 appelle test1.
- DIM
Mot réservé pour la déclaration des variables. Il y a plusieurs formes.
- DIM var_name[$|#|!] [,var_name[$|#|!]] pour déclarer des variables sans les initialiser. Le type de variable
est déterminé par le dernier caractère du nom de la variable.
- DIM var_name as DATATYPE [,var_name as DATATYPE], pour déclarer des variables en spécifiant le type de donnée par
utilisation du mot réservé AS suivit d'un des spécificateurs de type suivant: BYTE,INTEGER,FLOAT,STRING.
- DIM table(10) as INTEGER=(1,2,3,4,5,6,7,8,9.10), pour déclarer un tableau à 1 dimension et l'initialiser.
Chaque déclaration de variable peut-être suivie d'un caractère = et d'une valeur d'initialisation.
exemple:
>dim table(10)=(1,2,3,4,5,6,7,8,9,10)
>? table(5)
5
>dim message(3) as string=("hello","hi","bonjour")
>? message(2)
hi
>dim a#=245
>? a#
245
>_
- DO
Débute une structure de contrôle de type DO ... LOOP UNTIL|WHILE
DO
block
LOOP WHILE log_expr
Le bloc d'instructions est exécuté en boucle tant que log_expr est vrai.
DO
block
LOOP UNTIL log_expr
Le bloc d'instructions est exécuté en boucle jusqu'à ce que log_expr soit vrai.
exemple:
>i=0 : DO ? i : i=i+1 LOOP UNTIL i=5
0
1
2
3
4
>i=9 : DO ? i : i=i-1 : LOOP WHILE i
9
8
7
6
5
4
3
2
1
- ELLIPSE(x0,y1,x1,y1)
Dessine une ellipse circonscrite dans un rectangle. Les coordonnées sont en pixels.
- {x0,y0} coordonnées d'un des coin du rectangle.
- {x1,y1} coordonnées du coin opposé en diagonale du rectangle.
exemple:
>ellipse(200,100,280,140)
>_
- ELSE
Le mot réservé ELSE est utilisé dans 2 situations.
Voir IF
Voir SELECT CASE.
- END
Le mot réservé END est utilisé dans les 4 contextes suivants.
- ENV$(env_var)
Fonction chaîne qui retourne la valeur d'une variable d'environnement.
- env_var, est une chaîne représentant le nom d'une variable d'environnement. Si cette variable n'existe pas
la fonction retourne un pointeur NULL.
exemple:
>? env$("shell_version")
1.0
>? env$("existe_pas")
>_
- EXIST(fichier)
Fonction booléenne servant à vérifier l'existance d'un fichier.
- fichier, est le nom du fichier dont on veut vérifier l'existance.
exemple:
>? exist("test.bas")
0
>? exist("snake.bas")
1
>_
- EXIT SUB
Permet la sortie prématurée d'une sous-routine. Voir SUB.
- EXP(expr)
Fonction de type float qui retourne l'exponentielle de la base naturelle e.
- expr, expression numérique qui représente l'exposant.
exemple:
- FGETC(#n)
Cette fonction retourne un octet lu à partir d'un fichier.
- #n, est le numéro qui a été assigné au fichier lors de son ouverture. Voir OPEN.
exemple:
>open "snake.bas" for input as #1
>?chr$(fgetc(#1));:?chr$(fgetc(#1));:?chr$(fgetc(#1)):close(#1)
r e m
>_
Le fichier snake.bas débute par la ligne rem snake game.
- FILL(x,y)
Procédure graphique qui remplie une figure géométrique fermée.
- x, coordonnée x du point de départ de la procédure de remplissage.
- y, coordonnée y du point de départ de la procédure de remplisssage.
exemple:
>vgacls
>dim triangle(6)=(240,120,250,120,250,130)
>polygon(@triangle,3)
>fill(245,121)
>_
AVERTISSEMENT: Il s'agit d'une procédure récursive qui fait déborder la pile lorsque la figure dépasse une certaine taille.
Il se peut donc que l'ordinateur génère une exception lorsqu'elle est utilisée.
- FLOOR(expr)
Fonction qui retourne un entier qui est l'arrondie d'un float vers l'infini négatif. Voir aussi CEIL
- expr, expression de type float qui sera arrondie.
exemple:
>? floor(45.23)
45
>? floor(-4.001)
-5
>_
- FOR
Débute une structure de contrôle basée sur une énumération.
FOR var=expr TO expr [STEP expr]
block
NEXT var
Permet l'exécution d'un bloc d'instructions en boucle un nombre de fois déterminé par l'incrémentation d'une variable. Le programme sort de
la boucle lorsque la variable dépasse la valeur de la limite. l'incrément par défaut est 1. Si STEP est présent l'incrément est
le résultat d'expression et peut-être un entier quelconque. La valeur de la variable de contrôle est vérifiée au début de la boucle
d'instructions. Si au départ elle dépasse la limite le bloc d'instruction n'est jamais exécuté.
exemple:
>for i=0 to 10 step 2
>>? i
>>next i
0
2
4
6
8
10
>_
- FREE
Cette commande ne peut-être utilisée qu'en mode interactif. Elle affiche la quantité
de mémoire programme utilisée et la partie encore disponible ainsi que l'espace disponible pour les chaînes allouées
dynamiquement.
exemple:
>free
Program space (bytes): used 0 , available 38184
strings space (bytes): available 4096
>_
- FUNC
Mot réservé servant à déclarer ou définir une fonction. Une fonction est une sous-routine qui retourne une valeur.
La valeur retournée peut-être de n'importe quel type de base, BYTE,INTEGER,FLOAT,STRING. Le type retourné est déterminé
par le dernier caractère du nom de la fonction comme pour les variables.
FUNC name(arg_list)
[LOCAL var_list]
block
RETURN expr
END FUNC
- name est le nom de la fonction qui sera utilisé pour son appel. Les caractères de typage $,# et ! peuvent-être
utilisés pour définir le type de donnée retournée par la fonction.
- arg_list Liste du nom des arguments de la fonctions. Les éléments sont séparé par la virgule ','
- LOCAL var_list Si la fonction utilise des variables locales la liste doit-être donnée au début.
- block bloc d'instructions exécuté par cette fonction.
- RETURN expr Cette directive termine la fonction en retournant la valeur de l'expresssion qui suit. Cette
directive peut apparaître plusieurs fois dans le bloc d'instruction dans une structure conditionnelle.
exemple:
REM cette fonction calcule la factorielle d'un entier
REM methode recursive
FUNC fact(n)
if n<1 then 1/0 end if ' nombre < 1 génère une exception
if n=1 then return 1 end if
return n*fact(n-1)
END FUNC
REM meme fonction mais en utilisant une boucle FOR
FUNC fact(n)
LOCAL f,i
f=1
for i=2 to n
f=f*i
next i
return f
END FUNC
- HEX$(expr)
Fonction chaîne qui retourne la représentation hexadécimale d'un entier.
- expr, est évaluée et sa valeur convertie en chaîne hexadécimale. Si cette valeur est un float la partie décimale
est tronquée.
exemple:
>? hex$(3.1415)
$3
>? hex$(3.9)
$3
>? hex$(25.2 * 3.5)
$58
>_
Les chaînes représentant un nombre en hexadécimal débute par le caractère $ pour éviter toute confusion avec la représentation
décimale.
- IF
Mot réservé qui débute une structure de contrôle IF ... THEN ... ELSE ... END IF
IF log_expr THEN
block
[ELSE
block]
END IF
La expresssion booléenne log_expr est évaluée et si elle est vrai le block d'instructions qui
suit le THEN est exécuté. Dans le cas contraire c'est le bloc d'instruction qui suit le ELSE
qui est exécuté. La clause ELSE est optionnelle.
exemple:
>IF btest(4,0) THEN
>> ? "nombre impair"
>>ELSE
>> ? "nombre pair"
>>END IF
nombre pair
>_
- INPUT [#n,] | [invite,] var_list
- n, est le numéro d'un fichier ouvert si la lecture doit se faire à partir d'un fichier.
- invite est un message facultatif à imprimer à l'écran avant la saisie des données.
- var_list est la liste des variables auquelles les valeurs saisies au clavier seront affectées.
La saisie se fait une variable à la fois dans leur ordre d'apparation dans la liste. Pour chaque variable
son nom est affichée à l'écran suivit d'un point d'interrogation.
exemple:
>INPUT "Entrez votre prenom et votre age", nom$, age
Entrez votre prenom et votre age
prenom? Arthur
age? 40
>? nom$, age
Arthur 40
>_
#n et invite sont mutuellement exclusifs. #n n'est utilisé que pour la lecture de fichier et invite pour
la saisie à l'écran.
- INSERT$(s1,s2,expr)
Fonction chaîne qui sert à insérer un chaîne dans une autre.
- s1, est une expression de type chaîne.
- s2, est une expression de type chaîne qui sera insérée dans s1.
- expr, l'évaluation de cette expression doit résulter en un entier qui représente la position d'insertion de s2
dans s1. Le premier caractère d'une chaîne porte l'indice 1.
exemple:
>heo$="heo"
>ll$="ll"
>? insert$(heo$,ll$,3)
hello
>_
- INSERTLN
Fait glisser vers le bas toutes les lignes à partir de celle où se trouve le curseur en laissant la ligne du curseur vide et
le curseur texte au début de celle-ci.
exemple:
hello
vpcBASIC v1.0
RAM available: 38240 bytes
strings space: 4096 bytes
>locate(0,0):insertln:?"hello":locate(6,0)
>_
Lorsqu'on appelle le shell BASIC à partir du shell de commande l'écran initial shell BASIC est comme ceci.
vpcBASIC v1.0
RAM available: 38240 bytes
strings space: 4096 bytes
>_
On a saisie la liste de commandes montrée dans l'exemple pour obtenir le résultat affiché.
- INSTR([start],s1,s2)
Recherche d'une sous-chaîne dans une chaîne.
- start, Position de départ de la recherche dans la chaîne s1. Cet argument est facultatif. Si absent
la recherche se fait à partir du premier caractère de s1.
- s1, chaîne dans laquelle la recherche est effectuée.
- s2, chaîne recherchée dans s1.
exemple:
>couleurs$="rouge,vert,bleu"
>? instr(couleurs$,"vert")
7
>?instr(9,couleurs$,"e")
14
>_
- INVERTVID(0|1)
Inverse la sortie vidéo.
- 0|1, détermine si la sortie video est inversée(1) ou non(0). Cette inversion n'affecte que le texte et non
les graphiques.
exemple:
>invertvid(1):?"hello ";invertvid(0):?"world"
hello world
>_
- KEY
Cette fonction attend qu'une touche soit tapée au clavier et retourne sa valeur ASCII.
Voir aussi TKEY
exemple:
>? key()
97
>putc key
e
>? chr$(key)
c
>_
KEY ne recevant aucun argument, les parenthèses sont facultatives.
- LCASE$(str_expr)
Fonction chaîne qui convertie str_expr en lettres minuscules. Voir aussi UCASE$
- str_expr, expression chaîne de caractère qui sera convertie en minucuscules.
exemple:
>? lcase$("aBcDeF")
abcdef
>_
- LEFT$(str_expr,n)
Fonction chaîne qui retourne les n premiers caractère de str_expr
exemple:
>? left$("hello world!",5)
hello
>_
- LEN(str_expr)
Fonction qui retourne la longueur de str_expr.
exemple:
>nom$="Arthur Roy"
>? len(nom$)
10
>? len("hello world")
11
>_
- [LET] var_name[(epxr)]=expr
Assigne une valeur à une variable. Le mot réservé LET est entre crochets car il est optionnel.
exemple:
LET a=34*5
a=34*5 REM c'est la même chose
REM ça peut aussi être une variable tableau
DIM tab(4)
LET tab(1)=-1234 ' le premier élément du tableau vaut maintenenat -1234
- LINE(x0,y0,x1,y1)
Dessine une ligne à l'écran. L'opérateur xor est utilisé sur chaque pixel donc en redessinant la même ligne
on la fait disparaître.
- {x0,y0} coordonnées première extrémité de la ligne.
- {x1,y1} coordonnées de l'autre extrémité de la ligne.
exemple:
>while not tkey
>>line(10,10,100,100)
>>sleep(250)
>>wend
>_
Fait clignoter 2 fois/seconde une ligne sur le montieur VGA.
- LOCAL var_list
Déclaration de la liste des variables locales utilisées dans une FUNC ou une SUB.
- LOCATE(ligne,colonne)
Positionne le curseur texte à l'endroit désigné.
- ligne numéro de la ligne, {0-29}
- colonne numéro de la colonne, {0-79}
exemple:
example:
>LOCATE(10,0)
>_
Le curseur texte est maintenant au début de la 11ième ligne.
- LOG(expr)
Fonction retournant un float qui est logarithme naturel de expr.
exemple:
>? log(2.718)
0.999896
>? log(10)
2.30258
>_
- LOG10(expr)
Fonction retournant un float qui est la logarithme en base 10 de expr.
exemple:
>? log10(10)
1
>? log10(50)
1.69897
>? log10(62.2)
1.79379
>_
- LOOP
Termine une boucle DO ... LOOP. Voir DO
- MAX(expr1,expr2)
Cette fonction retourne un float qui est le plus grand des 2 nombres. Les expressions entières sont convertie en float
avant la comparaison.
exemple:
- MDIV(expr1,expr2,expr3)
Cette fonction retourne un entier résultant de expr1*expr2/expr3. Le résultat de la
multiplication est conservé sur 64 bits pour obtenir une valeur juste pour la division. Si une des expression passée en
argument est de type float elle est convertie en entier avant appel de la fonction.
exemple:
>? mdiv(45.67,34333,234)
6602
>? mdiv(456,34333,231)
67774
>_
- MID$(s1,star,len)
Fonction chaîne qui retourne une sous-chaîne de s1 à partir de la position star et de longueur len
- s1, est la chaîne de laquelle sera extraite la sous-chaîne.
- star, est la position du début de la sous-chaîne.
- len, est la longueur de la sous-chaîne.
exemple:
>? mid$("hello world",5,3)
o w
>_
- MIN(expr1,expr2)
Cette fonction retourne un float qui est le plus petit des 2 paramètres. Si l'une des expression passé en paramètre
est de type entier, celui-ci est converti en float avant la comparaison.
exemple:
- MOD(expr1,expr2)
Fonction qui retourne un entier qui représente le reste d'une division entière. Si un des arguments passé à la fonction est
de type float il est convertie en entier avant l'appel de la fonction.
- expr1, dénominateur de la division. Convertie en entier au besoin.
- expr2, diviseur. Convertie en entier au besoin.
exemple:
>? mod(45.7,4)
1
>? mod(45.7e3,4)
0
>? mod(45.7343e3,4)
2
>_
- NEXT var_name
Termine une boucle de FOR ... NEXT. Voir FOR
- NOT log_expr
Négation de la valeur d'une expression logique. Ne peut-être utilisé que dans les test logique.
exemple:
>if not 3>4 then ? "3 n'est pas plus grand que 4" end if
3 n'est pas plus grand que 4
>_
- OPEN file_name FOR INPUT|OUTPUT|APPEND as #n
Ouvre un fichier.
- file_name, nom du fichier à ouvrir.
- INPUT,OUTPUT,APPEND, mode d'ouverture, INPUT pour la lecture.OUTPUT, pour l'écriture.APPEND
pour l'écriture en fin de fichier.
- #n, n est le numéro assigné à ce fichier. Jusqu'à 5 fichiers peuvent-être ouvert simultanément.
exemple:
rem file system test
open "hello.txt" for output as #1
print #1,"hello world\r"
putc #1, 33 : putc #1, 10
v$="bonjour\r": n=3*5
? #1, v$, n, 4*5+20, 32.5e-3
close(#1)
dim hello$
open "hello.txt" for input as #1
input #1, hello$
c=fgetc(#1)
input #1,x$,n1,n2,n3!
close(#1)
? hello$,c,x$,n1,n2,n3!
Contenu du fichier file.bas
- log_expr1 OR log_expr2
Retourne vrai si l'une ou l'autre des 2 log_expr est vrai. Ne peut-être utilisé que dans les test logique.
exemple:
while 1
k=tkey
if k=\q or k=\x then bye end if
wend
Quitte le programme si une des touches q ou x est enfoncée.
- PEEK(expr)
Lit le contenu d'une adresse mémoire. Il s'agit de la lecture de 4 octets formant un entier 32 bits. L'adresse n'a pas
besoin d'être alignée.
- expr, adresse à lire. Convertie en entier au besoin. L'ordinateur peut planté si l'adresse est inacessible.
exemple:
>? peek($a0000001)
-1811939328
>? peek($9a000000)
Fatal error at address: 9d0107d4
Bus error exception (data reference: load or store)
<CTRL>-<ALT>-<DEL> to reboot.
- PGET(x,y)
Retourne l'état du pixel à la position {x,y}.
- {x,y}, sont les coordonnées du pixel dont on veut obtenir l'état.
exemple:
>vgacls ' efface l'ecran VGA
>box(200,100,80,40) ' dessine une boite au centre
>?pget(199,99)
0
>?pget(240,120)
1
>_
On dessine une boite ensuite on vérifie l'état du pixel juste en dehors de la boite dans son coin supérieur gauche. Ensuite l'état du
pixel au centre de la boite.
- PLAY(str_expr)
Joue une mélodie.
- str_expr, La mélodie est contenu dans une chaîne ASCII qui représente un langage pour coder la musique.
Description du langage
- Les notes sont représentées par les lettres utilisées par les anglophones, La séquence commence par C pour DO et on
a dans l'ordre: C,D,E,F,G,A,B ce qui représente: DO,RÉ,MI,FA,SOL,LA,SI.
- Ln, détermine la durée des notes. Il ne s'agit pas d'une durée absolue mais de la durée relative. n est dans
l'interval {1..64} où 1 représente une ronde, 2 une blanche, 4 une noire, etc. Pour les triplets, quintets,...,
on utilise les entiers impairs {3,5,...}.
On peut aussi indiquer la durée individuelle de chaque note en faisant suivre la note par sa durée.
Par exemple "F4G8" est un raccourci pour "L4FL8G". Notez que les espaces ne sont pas significatifs dans ce langage.
- On, Détermine l'octave dans lequel les notes sont jouée. L'interval est de n {0..6}.
- <, Pour descendre d'un octave.
- >, Pour monter d'un octave.
- Nn, Sélectionne une note dans l'interval des 7 octaves. n est dans l'interval {0..84}.
- MN, Joue une note normale, c'est à dire que sa durée est de 7/8 de la durée indiquée par Ln.
- ML, Joue une note legato, c'est à dire que sa durée est de 100% de la durée indiquée par Ln.
- MS, joue une note staccato, c'est à dire que sa durée est de 3/4 de la durée indiquée par Ln.
- Pn, Pause d'une durée n. Les valeurs de n sont les même que pour L.
- Tn, Détermine le tempo, c'est à dire le nombre de noires par minute. n est dans l'interval {32..255}.
La valeur par défaut du tempo est de 120 noires/minute.
- MB, Joue la mélodie en arrière plan. L'exécution du programme BASIC se poursuit tandis que la mélodie joue.
- MF, Joue la mélodie en avant plan. L'exécution du programme BASIC est suspendue pour la durée de la mélodie.
exemple:
? "ode a la joie"
ode$="t80mbL8eefggfedccdeL6eL16dL4d"+
"L8eefggfedccdeL6dL16cL4c"+
"L8ddecdL16efL8ecdL16efL8edcdL4&tl;g>"+
"L8eefggfedccdeL6dL16cL4c"
play(ode$)
Contenu du fichier ode_joie.bas, programme qui joue ode à la joie de Beethoven.
- POLYGON(@points,n)
Dessine un polygone fermé.
- points, est un tableau d'entiers passé par référence. Ce tableau contient les coordonnés de chaque sommet du
polygone. Le dernier et le premier points sont reliés pour fermer le polygone.
- n, est le nombre de sommets. Puisqu'il faut 2 entiers pour les coordonnées de chaque sommet, le tableau doit avoir une
demension de 2*n.
exemple:
>dim points(8)=(200,100,245,145,260,180,200,200) ' x0,y0,x1,y1,...xn,yn
>vgacls:polygon(@points,4)
>_
- POWER(base,exposant)
Fonction qui retourne un float qui est base^exposant.
- base, expression numérique qui représente la base numérique.
- exposant, expression numérique qui représente la puissance à laquelle la base sera élevée.
exemple:
>? power(3,4)
81
>?power(4.1,3.2)
91.392
>? power(10,3)
1000
>_
- PREPEND$(str_expr1,str_expr2)
Fonction chaîne qui préfixe une chaîne à une autre.
- str_expr1, Chaîne à laquelle str_expr2 sera préfixée.
- str_expr2, Chaîne qui sera préfixée à str_expr1.
exemple:
>ch1$=" world"
>? prepend$(ch1$,"hello")
hello world
>_
- PRINT|? [#n,]expr|str_expr|var [,expr|str_expr|var]* [;]
Imprime à l'écran ou dans un fichier la liste des expressions, chaîne ou variable. Un espace sépare chaque valeur. Si la commande est terminée
par une ';' il n'y a pas de retour à la ligne.
- #n, Pour imprimer dans un fichie le premier argument doit-être le numéro de fichier.
- expr, une expression arithmétique résultant en un nombre.
- str_expr, une expression de type chaîne.
- var, le contenu d'une variable.
exemple:
>DIM a=34, msg$="hello world"
>print a, msg$, "bonjour"
34 hello world bonjour
>_
- PSET(x,y,c)
Procédure graphique pour définir la couleur d'un pixel sur l'écran VGA.
- {x,y}, sont les coordonnées du pixel à modifier.
- c, est la nouvelle couleur du pixel. cest dans l'intervalle {0..15}. Puisqu'il s'agit d'un affichage
monochrome les valeurs {0..7} représente un pixel noir et les valeurs {8..15} un pixel blanc.
exemple:
>pset(240,120,7) ' le pixel sera noir.
>pset(240,120,12) ' le pixel sera blanc.
- PUTC [#n,] expr
Imprime un caractère à l'écran ou dans un fichier sans ajout d'espace ou de retour à la ligne.
La majorité des codes entre 0 et 31 n'ont aucun effet. les codes reconnus sont les suivants:
- #n, Pour envoyer le caractère dans un fichier il faut indiquer son numéro avant expr suivit d'une virgule.
- expr, évaluée comme un entier dans l'interval {0..127} pour l'écran et {0..255} pour les fichiers.
exemple:
- PXOR(x,y)
Procédure graphique pour inverser l'état d'un pixel.
- {x,y}, sont les coordonnées du pixel dont l'état doit-être inversé.
exemple:
>while not tkey():pxor(240,120):sleep(500);wend
>_
Cet exemple fait clignter le pixel au centre de l'écran avec une période d'une seconde.
- RANDOMIZE
Initialize le générateur pseudo hazard avec le contenu de la variable système systicks.
exemple:
>randomize
>? rnd,rnd,rnd
1747362710 107152609 1620603382
>_
- RECT(x,y,width,height)
Dessine un rectangle à l'écran.
- {x,y} coordonnées du coin supérieur gauche.
- width largeur du rectangle en pixels.
- height hauteur du rectangle en pixels.
exemple:
>RECT(10,10,20,60) ' position {10,10}, largeur 20, hauteur 60
>_
- REM|' texte
Indique un commentaire. Les commentaires se termine à la fin de la ligne.
exemple:
>rem ce commentaire se termine a la fin de la line
>' le mot <rem> peut etre remplace par l'apostrophe.
>_
- RESTSCR(adresse)
Restore l'écran VGA à partir d'une image préalablement sauvegardée dans la RAM externe. Voir SAVESCR.
- adresse, est l'adresse dans la RAM externe où est stockée l'image.
exemple:
>savescr(0):vgacls ' maintenant l'ecran VGA est vide.
>restscr(0) ' maintenant l'ecran VGA est tel qu'il etait avant la commande vgacls.
>_
- RETURN value
Voir FUNC
- RIGHT$(str_expr,expr)
Fonction chaîne qui retourne les n derniers caractères d'une chaîne.
- str_expr, Chaîne d'où sont extraient les n derniers caractères.
- exp, expression entière représentant le nombre de caractères à extraire.
exemple:
>? right$("hello world",5)
world
>_
- RND()
Cette fonction retourne un entier de 32 bits pseudo aléatoire.
exemple:
>while not tkey: ? rnd%100; wend
20 96 38 53 30 14 49 35 3 40 83 70 95 42 99 10 70 56 19 59 3
1 96 18 11 73 13 48 7 23 39 71 60 12 7 6 43 63 52 34 18 41
43 55 63 98 16 90 72 97 53 53 72 84 88 50 10 41 86 27 70 42
49 91 54 94 64 30 26 61 22 27 19 32 2 81 0 54 91 87 82 75 86
77 53 63 27 97 24 84 53 50 46 84 49 46 48 54 34 87 39 35 92
84 12 30 70 65 89 32 21 95 84 90 41 99 59 93 38 5 55 74 58
69 69 77 8 88 86 45 32 55 83 95 18 5 64 70 68 25 87 54 44 5
6 55 50 73 42 27 46 24 18 92 57 43 26 77 67 65 31 98 56 54 1
Imprime des entiers de 0 à 99 sans arrêt jusqu'à l'enfoncement d'une touche.
- RUN file_name
Cette commande permet de charger et d'exécuter un fichier BASIC sauvegarder sur la carte SD.
- file_name, est le nom du fichier à exécuter. Il n'est pas nécessaire de donner l'extension *.BAS.
exemple:
>run snake
length: 3
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
X O X
X X
X X
X X
X X
X X
X X
X X
X X
X X
X X
X X
X X
X OO< X
X X
X X
X X
X X
X X
X X
X X
X X
X X
X X
X X
X X
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
- SAVESCR(adresse)
Sauvegarde le contenu de l'écran VGA dans la RAM externe. Voir RESTSCR.
- adresse, Est l'adresse dans la RAM externe où sera sauvegardée l'image de l'écran VGA. Cette image occupe 14400 octets.
exemple:
- SCRLDN
Fait glisser l'affichage vers le bas d'une ligne texte.
exemple:
- SCRLUP
Fait glisser l'affichage vers le haut d'un nombre d'une ligne texte.
exemple:
- SEEK(#n,position)
Déplace le curseur à l'intérieur d'un fichier.
- #n, Indique le numéro du fichier
- position, indique la nouvelle position du curseur. 0 place le curseur au début du fichier et
-1 indique la fin du fichier. Si position dépasse la grandeur du fichier le curseur est placé à la fin
de celui-ci.
exemple:
>open "test.txt" for output as #1
>putc #1, \1
>putc #1, \2
>putc #1, \3
>close(#1)
>open "test.txt" for input as #1:seek(#1,2):? chr$(fgetc(#1)):close(#1)
3
>_
- SELECT CASE expr
CASE expr_list
block
[case expr_list
block]+
[CASE ELSE
block]
END SELECT
Cette structure de contrôle permet de sélectionnr un bloc d'instruction en fonction de la valeur d'une expression. Contrairement au
switch du langage 'C' l'exécution d'un bloc se termine au prochain CASE sans besoin de mettre un break.
les case peuvent comprendre plus d'une expression séparées par la virgule. Contrairement à d'autres dialectes BASIC les expressions
chaînes sont exclues.
exemple:
REM controle du mouvement d'un sprite à l'ecran a l'aide des touches curseur.
while 1
select case tkey()
case 13 ' touche ENTER
bye
case 144 ' fleche a droite
move_right()
case 143 ' fleche vers la gauche
move_left()
case 142 ' fleche vers le bas
move_down()
case 141 ' fleche vers le haut
move_up()
end select
wend
- SETENV(str_expr1,str_expr2)
Définie la valeur d'une variable d'environnement ou en cré une nouvelle. Il s'agit d'un moyen de communication entre un programme
BASIC et le shell de commande.
- str_expr1, est le nom de la variable à définir.
- str_expr2, est la valeur que doit prendre cette variable.
exemple:
$set test=snake.bas
$set
TEST=snake.bas
NIL=
FALSE=F
TRUE=T
SHELL_VERSION=1.0
$basic
vpcBASIC v1.0
RAM available: 38048 bytes
strings space: 4096 bytes
>setenv("test","bonjour")
>? env$("test")
bonjour
>setenv("t2","hello")
>? env$("t2")
hello
>bye
Exiting BASIC
$set
T2=hello
TEST=bonjour
NIL=
FALSE=F
TRUE=T
SHELL_VERSION=1.0
$echo $t2 $test
hello bonjour
$set t2
$set test
$set
NIL=
FALSE=F
TRUE=T
SHELL_VERSION=1.0
$
- SETTMR(expr)
Démarre une minuterie à rebours. Voir TIMEOUT
- expr, paramètre de type entier représentant la durée en millisecondes.
exemple:
>settmr(10):while not timeout():?"waiting time out":wend
waiting time out
waiting time out
waiting time out
waiting time out
waiting time out
waiting time out
waiting time out
>_
- SHL(expr, n)
Décale vers la gauche expr de n bist (multiplication par 2).
- expr, est une expression de type entier qui sera décalé vers la gauche.
- n, est une expression de type entier qui représente le nombre de bits de décalage. La valeur de décalage est n%32.
exemple:
- SHR(expr,n)
Décale vers la droite expr de n bits (division par 2).
- expr, est une expression de type entier qui sera décalé vers la droite.
- n, est une expression de type entier qui représente le nombre de bits de décalage. La valeur de décalage est n%32.
exemple:
- SINE(expr)
Fonction trigonométrique sinus, retournant un type float.
- expr de type float représent l'ange en radian.
exemple:
>rem imprime sinus de 45 degr.
>?sine(2.0*3.14159*45/360)
0.707106
>_
- SLEEP(expr)
Suspend l'exécution du programme pour une durée en millisecondes.
- expr, est une expression entière représentant la durée en millisecondes. Si expr est un float le délais
ne sera pas celui escompté.
exemple:
>cls:while not tkey: locate(0,0):? time$:sleep(1000):wend
Vide l'écran et ensuite dans dans la boucle while...wend, affiche l'heure à interval d'une seconde dans le coin supérieur gauche.
Termine lorsqu'une touche est enfoncée.
- SOUND(freq,duration)
Émet une tonalité.
- freq, expression qui détermine la fréquence de la tonalité. L'expression doit résulté en un entier.
- duration, expression qui détermine la durée en millisecondes. L'expression doit résulté en un entier.
exemple:
>for i=200 to 2000 step 10: sound(i,4):next i
>_
Succession rapide de tonalités de 200 hertz à 2000 hertz.
- SPRITE(x,y,width,height,@var#)
fonction qui affiche un sprite à l'écran. Cette fonction retourne une
valeur booléenne qui indique si le sprite est entré en collision avec un autre objet.
- {x,y} Coordonnées du coin supérieur gauche du sprite.
- width Largeur du sprite en pixels.
- height Hauteur du sprite en pixels.
- var# Nom de la variable tableau d'octets qui contient le sprite. Cette variable doit-être passée par
référence comme indiqué par le caractère '@'. Chaque octet du tableau contient 2 pixels. Chaque pixel étant
représenté par 4 bits correspondant à 16 couleurs. Cependant puisque VPC-32V est monochrome, seul le bit 3 est utilisé.
Si le bit 3 est à 1 le pixel et blanc sinon il est noir. Lorsqu'un pixel blanc est déposé sur un pixel déjà blanc on
considère qu'il y a eu collision.
exemple:
dim cross#(8)=($0f,$f0,$ff,$ff,$ff,$ff,$0f,$f0) 'petite croix de 4x4 pixels
if sprite(56,24,4,4,@cross#) then ? "collision" end if
Les sprites sont affichés à l'écran en utilisant une fonction XOR (OU exclusif) pixel à pixel. Cette méthode a 2 avantages.
Le premier est qu'elle permet de détecter les collisions en supposant que le fond d'écran est noir (0). Le deuxième est qu'il
suffit de réafficher le sprite par dessus lui-même pour l'effacer. la méthode pour déplacer un sprite à l'écran est la suivante:
while 1
collision=sprite(x,y,8,8,@spr#) ' affiche un sprite de 8x8 pixels
sleep(10) ' pause de 10 millisecondes, cette valeur n'est pas critique peut-être 20 msec.
sprite(x,y,8,8,@spr#) 'efface le sprite
' ici on peut mettre du code pour gérer les collisions
'...
select case tkey() 'lecture du clavier et deplacement dans la direction indiquee.
case \q ' lettre 'q' quitter
cls
bye
case 141 'vers le haut
if y>0 then y=y-1 end if
case 142 'vers le bas
if y<240-8 then y=y+1 end if
case 144 'vers la droite
if x<480-8 then x=x+1 end if
case 143 ' vers la gauche
if x>0 then x=x-1 end if
' on peut ajouter des CASE pour gérer les 4 directions diagonales.
'...
end select
wend
- SQRT(expr)
Fonction de type float qui retourne la racine carré.
- expr, Valeur numérique dont on veut obtenir la racine carré. Si expr est un entier celui-ci
est converti en float avant extraction de la racine carré.
exemple:
>? sqrt(7)
2.64575
> ? sqrt(7)*sqrt(7)
7
>_
- SRCLEAR(adresse,grandeur)
Cette commande met à zéro un bloc de la mémoire RAM externe.
- adresse, est une expression entière indiquant l'adresse du début du bloc.
- grandeur, est une expression entiere indiquant le nombre d'octets à mettre à zéro.
exemple:
srclear(0,1000) ' efface les 1000 premiers octets de la mémoire RAM externe.
- SRLOAD(adresse,"fichier")
Il s'agit d'une fonction qui charge en mémoire SPI RAM le contenu d'un fichier.
La taille maximale est de 65535 octets. La fonction retourne le nombre d'octets chargés.
- adresse, une expression entière indiquant l'adresse dans la RAM où débute le chargement.
- fichier, est le nom du fichier à charger.
exemple:
>size=srload(0,"lem.spr")
>? size
1075
>_
- SRREAD(adresse,@var,grandeur)
Lecture d'un bloc d'octets de la RAM externe dans une variable.
- adresse, adresse RAM externe où doit débuter la lecture.
- @var, nom de la variable tableau dans laquelle les valeurs lues seront copiées. Cette variable doit-être passée par
référence comme l'indique le caractère '@'.
- grandeur, nombre d'octets à lire.
exemple:
DIM i, spr#(32)
srread(0,@i,4)
srread(4,@spr#,32)
Lit un entier et le met dans la variable i.
Lit un bloc de 32 octets à partir de l'adresse 4 dans le tableau spr#.
- SRSAVE(adresse,fichier, grandeur)
Sauvegarde dans un fichier le contenu de la mémoire RAM externe.
- adresse, adresse où débute le région à sauvegarder.
- fichier, expression chaîne donnant le nom du fichier de sauvegarde.
- grandeur, nombre d'octets à sauvegarder.
exemple:
>srsave(100,"test.dat",1024)
>_
Sauvegarde 1024 octets dans le fichier test.dat
- SRWRITE(adresse,@var,grandeur)
Copie le contenu d'une variable dans la mémoire RAM externe.
- adresse, expression donnant l'adresse destination dans la RAM externe.
- @var, variable qui contient les données à transférer dans la RAM externe. Cette variable est passée par référence
comme indiqué par le caractère '@'.
- grandeur, nombre d'octets à copier.
exemple:
DIM i, spr#(32)
srwrite(0,@i,2)
srwrite(4,@spr#,32) ' écris un bloc de 32 octets à l'adresse 4 à partir du tableau spr#
Écrit l'entier i dans la RAM externe à l'adresse 0.
Écris un bloc de 32 octets à l'adresse 4 à partir du tableau spr#.
- STR$(expr)
Fonction chaîne retournant la représentaion d'une expression numérique.
- expr, expression numérique à représenter en chaîne.
exemple:
>? append$("2*PI=",str$(3.1416*2))
2*PI=6.2832
>? append$("le carre de 9 est ",str$(9*9))
le carre de 9 est 81
>_
- SUB name([arg_list])
[LOCAL var_list]
block
[if log_expr then EXIT SUB end if
block]
END SUB
Cette déclaration sert à définir une sous-routine. La liste des variables locales, s'il y en a, doit-être énumérée au début.
EXIT SUB peut-être utilisé pour sortir de la sous-routine si une certaine condition est remplie.
exemple:
sub box_madness() ' dessine des boites au hasard
local x,y,w,h
while not tkey() ' arrete lorsqu'une touche est enfoncee.
x=rnd()%480
y=rnd()%240
w=rnd()%480
h=rnd()%240
box(x,y,w,h)
wend
end sub
- SUBST$(s1,s2,n)
Fonction chaîne qui permet de substituer une partie de s1 par la chaîne s2 à partir de la position n.
- s1, est une expression chaîne.
- s2, est une expression chaîne.
- n, expression entière représentant la position de départ de la substituion.
exemple:
>greet$="bonjour Arthur"
>? subst$(greet$,"Robert",9)
bonjour Robert
>_
- TAN(expr)
Fonction trigonométrique retournant la tangeante d'un angle exprimé en radian.
- expr, expression de type float, exprimant un angle en radiant. Si expression est un entier celui-ci est converti
en float avant l'appel de la fonction.
exemple:
>? tan(2) ' L'entier 2 sera convertie en float 2.0
-2.18504
>? tan(2.0) ' On obtient le même résultat avec un float.
-2.18504
>_
- THEN
Voir IF
- TICKS()
Le VPC-32v possède un compteur interne de 32 bits qui est incrémenté à chaque milliseconde. Cette fonction retourne la valeur de ce compteur.
exemple:
> REM utilisation du compteur interne pour mesurer un interval de temps.
>t0=ticks():for i=0 to 10000:next i:? ticks()-t0
77
>_
- TIME$
Fonction chaîne retournant l'heure donnée par le RTCC. Voir DATE$
exemple:
- TIMEOUT()
Cett fonction vérifie la valeur de la minuterie à rebours et retourne vrai si elle est expirée. Voir SETTMR.
exemple:
>settmr(1000):while not timeout():? "pas encore expiree":wend
pas encore expiree
pas encore expiree
pas encore expiree
...
pas encore expiree
>_
- TKEY()
Fonction qui retourne un caractère s'il y en a un dans la file du clavier, sinon retourne 0. Contrairement à KEY,
TKEY n'attend pas si la file est vide.
exemple:
>while not tkey:?"pas de touche dans la file":sleep(500):wend:? "touche obtenu"
pas de touche dans la file
pas de touche dans la file
pas de touche dans la file
pas de touche dans la file
touche obtenu
>_
- TRACE(0|1|2)
C'est un outil de débogage des programmes BASIC pour les utilisateurs avancés.
Pour l'utiliser il faut connaître le fonctionnement de la machine virtuelle et ses
opcodes. Lorsque trace est actif, à chaque instruction de la machine virtuelle l'état
des piles est affiché à l'écran.
- 0, désactive la fonction trace.
- 1, active la fonction trace en mode continue.
- 2, active la fonction trace en mode pas à pas. L'exécution est suspendue après chaque instruction de la machine virtuelle
et l'utilisateur doit enfoncer une touche pour exécuter l'instruction suivante. La touche q permet de sortir du mode trace pas
à pas.
exemple:
>trace(2):for i=1 to 10:? i:next i
trace: R(0 ) S(0 )
ip: A00047DB dp: A0003F60 next opcode: FOR>R
(Q) leave trace, other step
trace: R(2 ) S(0 )
ip: A00047DC dp: A0003F60 next opcode: LIT
(Q) leave trace, other step
trace: R(2 ) S(1 )A000DCC4
ip: A00047E1 dp: A0003F64 next opcode: CLIT
(Q) leave trace, other step
trace: R(2 ) S(2 )A000DCC4 1
ip: A00047E3 dp: A0003F68 next opcode: SWAP
(Q) leave trace, other step
trace: R(2 ) S(2 )1 A000DCC4
ip: A00047E4 dp: A0003F68 next opcode: !
(Q) leave trace, other step
1
2
3
4
5
6
7
8
9
10
>_
Le mode trace a été activé en mode pas à pas avant d'exécuter la boucle FOR...NEXT. Ici on voit l'état de la machine virtuelle avant
l'exécution des 5 premières instructions machine. Puis l'utilisateur a enfoncé la touche q pour sortir du mode trace.
- UBOUND(var)
Cette fonction retourne la valeur du dernier indice d'une variable tableau.
- var, est la variable tableau dont on veut obtenir la grandeur.
exemple:
>dim chime(3)=(698,784,523)
>for i=1 to ubound(chime):sound(chime(i),500):next i
>_
Utile pour énumérer tous les éléments d'un tableau.
- UCASE$(str_expr)
Fonction chaîne qui convertie une chaîne en majuscule. Voir aussi LCASE$
- str_expr, expression chaîne de caractère qui sera convertie en majuscule.
exemple:
>? ucase$("aBcDeF")
ABCDEF
>_
- UNTIL
Termine une boucle de contrôle DO.
- USE "fichier"
Cette directive sert à compiler un fichier BASIC utilisé par le fichier principal.
- fichier, est une chaîne de caractère représentant le fichier qui sera chargé et compilé. Ce fichier peut lui-même
utilisé la directive USE mais le niveau d'imbrication est limité à 4. Le fichier doit existé sur la carte SD.
exemple:
use "lem.spr" ' fichier definissant un sprite appelle LEM.
' code du programme principal
.
.
.
- VAL(str_expr)
Fonction qui retourne la valeur numérique d'une chaîne de caractère qui représente un nombre. C'est l'inversede STR$
- str_expr, expression chaîne de caractère qui représente un nombre.
exemple:
- VGACLS
Vide l'écran du moniteur VGA. Contrairement à CLS cette commande agit sur le moniteur VGA même lorsque
la console est en mode REMOTE.
- WEND
Termine une boucle WHILE ... WEND
exemple:
>i=10:while i: ? i;:i=i-1:wend
10 9 8 7 6 5 4 3 2 1
>_
- WHILE log_expr
bloc d'instructions
WEND
Boucle de contrôle qui s'exécute seulement si l'expression logique log_expr est vrai.
exemple:
>i=10:while i: ? i;:i=i-1:wend
10 9 8 7 6 5 4 3 2 1
>_
Le mot réservé WHILE est aussi utilisé dans les boucles boucles DO ... LOOP WHILE.
En suivant ce lien vous trouverez quelque
programmes écris en vpcBASIC.
INDEX