Nous ne prétendons pas ici donner une présentation complète du langage BASIC. On trouve en effet en librairie une grande variété d'ouvrages de cette nature, du plus austère au plus humoristique. Par ailleurs les constructeurs livrent leurs machines accompagnées d'un manuel d'apprentissage et il est couramment admis qu'il suffit d'une heure à un ingénieur pour connaître les rudiments de ce langage, sans oublier qu'il existe maintenant une énorme bibliothèque de programmes de démonstration dans les domaines les plus divers.
Fidèles à notre principe, nous supposons que nous ne nous adressons pas ici à de futurs informaticiens. Nous n'entrerons donc pas dans les subtilités des différents dialectes du BASIC et nous nous contenterons de faciliter la transition depuis les petites cal-culatrices, maintenant largement répandues, vers les petits systèmes informatiques appelés à leur succéder.
Ensuite, la forme du dialogue est extrêmement simple. Pour connaître la somme de deux nombres, on tapera sur le clavier:
|
|
|
|
|
qui a la signification suivante
|
signifie que l'on pose une question à l'ordinateur, c'est-à-dire que l'on va lui demander de calculer une expression |
|
est un premier opérande numérique |
|
est le symbole de l'addition |
|
est un second opérande numérique |
|
signifie que l'expression est terminée |
La touche ENTER est à peine enfoncée que l'ordinateur effectue le calcul et affiche sur l'écran (ou sur l'imprimante) le résultat : : 4
Des expressions plus complexes peuvent être calculées en utilisant les différents symboles existants en BASIC :
+ addition- soustraction
* multiplication
/ division
exponentiation
Des parenthèses peuvent être utilisées pour définir des expressions complexes. Les opérations situées à l'intérieur des parenthèses les plus intérieures sont réalisées en premier lieu ; ensuite celles du niveau suivant sont effectuées, et ainsi de suite jusqu'aux opérations qui ne sont pas entre parenthèses. Au même niveau, les opérations sont réalisées dans l'ordre suivant :
Exposant : A B |
ABS(x) valeur absolue de x ATN(x) arc (en radians) dont la tangente est x COS(x) cosinus de l'angle x, exprimé en radians EXP(x) exponentielle ex INT(x) partie entière de x LOG(x) logarithme naturel de x SIN(x) sinus SQR(x) racine carrée TAN(x) tangente |
Beaucoup d'autres fonctions arithmétiques peuvent être déduites de celles-ci, par exemple le sinus hyperbolique, égal à (EXP(x)-EXP(-x)/2.
Les opérandes numériques peuvent être eux-mêmes écrits sous trois formes
- nombre entier ex : 3 |
Voici des exemples d'utilisation du mode "machine à calculer"
?SQR(2) (1) ?(EXP(4)-EKP(-4)/2 (2) ?4*ATN(l) (3) ?SQR(102+l52) (4) |
De même qu'avec les calculatrices de poche, il est possible d'enchaîner des calculs en affectant des valeurs à des variables intermédiaires. Si par exemple, on cherche le périmètre et la surafce d'un cercle dont le rayon est égal à 4.28571, on peut écrire la suite d'instructions :
R=4.28571 PI=3.14157 ?2*PI*R ?PI*R*R |
L'enchaînement de ces instructions est rendu possible par le fait que la machine est capable de reconnaître les variables algébriques "R" et "PI" définies par l'utilisateur et d'en mémoriser la valeur. Par contre, dans les exemples qui précèdent, les expressions mathématiques sont calculées, et leur résultat est affiché, mais le programme de calcul qu'elles représentent n'est pas mémorisé par la machine.
Le langage BASIC offre bien sûr la possibilité de mémoriser, non seulement les valeurs de variables définies par l'utilisateur, mais aussi un enchaînement de calculs : c'est la notion de programme.
Pour prendre un exemple simple, rappelons que l'équation du second degré :
ax2 + bx + c = 0 |
possède les deux racines suivantes
si le discriminant
D = b2 - 4ac |
est positif
Un programme BASIC permettant de chercher les racines pour tout triplet de nombres a, b, c peut s'écrire
REM Equation a*x2+b*x+c-0 10 INPUT "A,B,C"; A,B,C 20 LET D=B*B-4*A*C 30 IF D<0 then print "PAS DE RACINE REELLE": goto 10 40 if d=o then print "RACINE DOUBLE: "; -b/(2*a): goto 10 50 print "LES RACINES SONT "; (-b+sqr(d))/(2*a);" ET ";(-b-sqr(d))/(2*a) 60 goto 10 |
Ce programme nous donne un premier aperçu du langage BASIC.
Les nombres entiers qui figurent au début de chaque ligne sont les numéros de ligne. Ils sont rangés systématiquement par ordre croissant et indiquent l'ordre normal d'exécution des instructions du programme.
| Ligne 1 | la première ligne, qui commence par le mot "REM" est un commentaire destiné à faciliter la lisibilité du programme par le lecteur ; ce n'est pas une instruction exécutable. |
| Ligne 10 | L'instruction INPUT permet d'introduire en mode conversationnel les trois données du programme. |
| Ligne 20 | Calcul du discriminant D. La plupart des machines modernes admettent la suppression du mot LET, qui symbolise l'affectation de valeur de l'expression située à droite du signe égal à la variable dont le nom figure à gauche de ce même signe. |
| Ligne 30 |
La forme IF ... THEN permet au programme de réagir différemment selon la valeur du discriminant. S'il est négatif, l'exécution du programme se poursuit immédiatement. après le mot "THEN" par l'affichage ("PRINT") du message "PAS DE RACINE", puis l'instruction "GOTO 10" provoque le retour au début du programme en vue de reprendre le calcul avec d'autres données.
Si le discriminant n'est pas négatif, les instructions qui suivent THEN sur la même ligne sont ignorées et le programme continue à la ligne suivante. |
| Ligne 40 | Dans le cas particulier d'un discriminant nul, la racine double est obtenue par 1'expression -b/2a |
| Ligne 5O | L'ordinateur calcule les deux racines |
| Ligne 60 | Retour au début du programme |
Remarquons bien dans cet exemple, plusieurs concepts fondamentaux du langage BASIC :
Le cas des textes fixes suggère l'usage du papier carbone ou des machines de reproduction usuelles (duplicateur à alcool, ronéo, offset, etc.). Ces moyens supportent de légères variantes, à condition de laisser en blanc les passages à modifier.
L'idée est venue progressivement d'utiliser les programmes écrits en langage informatique pour manipuler des textes comportant des parties fixes et des parties variables. Pratiquement impossible avec les premiers langages tels que FORTRAN et COBOL, le traitement de texte est tout à fait possible avec les langages plus évolués tels que BASIC ou APL, qui acceptent de considérer les chaînes de caractères Comme des variables sur lesquelles on peut effectuer les opérations suivantes
(Par souci de clarté, les noms de variables de cette nature seront suivis du symbole "$")
| Constante | "PAPA ET MAMAN" |
| Comparaison |
A$ < B$ signifie que A$ précède B$ dans l'ordre alphabétique
A$ = B$ signifie que A$ et B$ sont identiques |
| Concaténation | A$ + B$ est une chaîne composée de A$ suivie de B$ |
| Extraction |
LEFTS(A$,n) est une chaîne composée des n caractères les plus à gauche dans A$
RIGHTS(A$,n) est une chaîne composée des n caractères les plus à droite dans B$ MIDS(A$,i,n) est une sous-chaîne de A$ composée de n caractères, en partant du ième caractère de A$ |
| Création |
STR$(x) est une chaîne de caractères développant "en clair" le nombre x
STRING$(n, C$) est une chaîne de n caractères identiques au caractère C$ |
| Longueur : | LEN(A$) fournit la longueur de la chaîne A$ |
Exemple :
10 INPUT "MONSIEUR OU DAME";G$ 20 IF LEFT$(G$,1)="D" THEN C$="CHERE MADAME" ELSE C$="CHER MONSIEUR" 30 PRINT "VEUILLEZ AGREER, ";C$;", L'EXPRESSION DE MES MEILLEURS SENTIMENTS' |
De nombreuses fonctions de mise en page ont été introduites, notamment la fonction de tabulation TAB. Soit T$ un titre à centrer au milieu d'une ligne de 64 caractères. On écrira en BASIC
Sans entrer dans des détails qui varient selon les machines utilisées, on aperçoit la possibilité d'obtenir une précieuse assistance dans les cas suivants :
De manière générale, les langages informatiques évolués admettent la notion de tableau, avec un ou plusieurs indices, avec une notation du type X(i) ou A(i,j).
Imaginons un espace vectoriel à trois dimensions et deux vecteurs X et Y. Au lieu de désigner leurs coordonnées Xl, X2, X3 et Y1, Y2, Y3, nous pouvons définir deux tableaux X et Y de trois éléments chacun de sorte que ces mêmes coordonnées s'écrivent X(1), X(2), X(3) et Y(1), Y(2) et Y(3).
Le produit scalaire S de ces deux vecteurs s'écrit
Autre exemple :
A l'école, on s'intéresse aux noms, prénoms, sexe et âge des élèves d'une classe. Sans même connaître au départ le nombre exact d'élèves, on peut définir différents traitements sur ces paramètres N$(i), P$(i), S$(i), A(i) tels que :
On peut gérer de la même manière un fichier clients, une liste d'adresses, etc.
Il est essentiel d'avoir des idées claires sur la démarche à suivre et que l'écriture du programme en BASIC en soit le reflet. Il apparaît clairement aujourd'hui que la meilleure technique est celle dite de programmation modulaire dans laquelle un problème complexe doit être clairement décomposé en sous-problèmes (un peu) plus simples dans son écriture.
Le langage BASIC n'est malheureusement pas très propice à l'application de ces principes, mais comme il ne les exclut pas totalement, il est bon de s'y astreindre.
1ère règle : Si une même série d'instructions doit être exécutée plusieurs fois, utiliser une boucle FOR... NEXT
Exemple : pour calculer le produit scalaire de deux vecteurs X et Y dans un espace à n dimensions
2ème règle : Si une même série d'instructions doit être exécutée à plusieurs reprises à des stades différents de l'exécution du programme (ou même une seule fois si cette série a une signification particulière), il est avantageux de lui donner la forme d'un sous-programme.
Exemple : (dérivé de l'équation du second degré) :
100 REM CE SOUS-PROGRAMME CHERCHE LES RACINES 11O REM DE L'EQUATION A*X*X+B*X+C=O 115 IF A=O THEN RETURN 120 D=B2-4*A*C 130 IF D<O THEN PRINT"PAS DE RACINE": RETURN 140 IF D=O THEN PRINT"RACINE DOUBLE: ";-B/2/A:RETURN 150 PRINT "LES RACINES SONT ";(-B+SQR(D))/2/A;" ET ";(-B-SQR(D))/2/A 160 RETURN |
Depuis tout endroit du programme, l'instruction "GOSUB 100" provoque l'exécution du sous-programme commençant à la ligne 100, qui s'achèvera sur la rencontre de l'instruction "RETURN", laquelle renverra à l'instruction qui suit l'appel "GOSUB". Comme il n'existe pas de limitation particulière au nombre d'instructions d'un sous--programme, et qu'un sous-programme peut lui-même en appeler un autre, et ainsi de suite, la notion de sous-programme permet de programmer avec une grande élégance les algorithmes les plus compliqués, dès lors qu'on sait à chaque stade de l'analyse, décomposer le problème posé eh un petit nombre de sous-problèmes.
Ici se situe l'un des progrès-clés qu'apportent les langages évolués par rapport aux langages-machines qui incitaient plut8t à un raisonnement par ordinogrammes.
Il n'existe pas, en dehors de quelques cas d'école, de moyen parfait de prouver l'exactitude de la programmation, sans même évoquer le problème de l'exactitude des données numériques. Il faut en conclure que dans de nombreux cas, la confiance à accorder aux résultats produits par un ordinateur reste un acte de foi dans le talent de celui qui a écrit le programme.
Autre paradoxe :quelle que soit la vraisemblance des résultats, ils sont invariablement reproduits à chaque exécution d'un même programme avec les mêmes données d'entrée. L'ordinateur ne serait-il pas capable de .... fantaisie ? Eh bien, si, grâce à une fonction spéciale, qui est maintenant disponible sur la plupart des machines, il est parfaitement possible d'insuffler une certaine dose de hasard dans l'exécution d'un programme BASIC, grâce à la curieuse fonction RND.
Une exécution de RND(O) fournit un nombre aléatoire uniformément compris entre 0 et 1 tandis que RND(n) tire un nombre entier au hasard compris entre 1 et n inclus.
Exemple :
pour noter les devoirs de philo
FOR I=1 TO N : NM(I)=PM(20): NEXT I
pour simuler le jeu de la roulette russe
IF RND(6)=l THEN PRINT "PAN ! VOUS ETES MORT"
4.7. Le graphisme
Les progrès des consoles de visualisation et des imprimantes permettent d'obtenir des ordinateurs bien plus que des manipulations de nombres et de textes : ils peuvent créer des images, en couleur, en relief, etc ...
Sans entrer dans des problèmes particuliers tels que la C.A.O. (conception assistée par ordinateur) et la télémanipulation, qui font appel à des langages spécialisés, le langage BASIC permet de traiter l'écran de visualisation (ou la feuille de papier de l'imprimante) comme une matrice de points qui peuvent soit être allumés, soit éteints, en plus de la possibilité de faire apparaître des caractères à tout emplacement de l'écran.
Les conventions peuvent varier d'une machine à l'autre et donnent naissance à des dialectes spécifiques. Celle adoptée par TRS-80, et que nous allons décrire, est pourtant assez typique.
Pour l'écriture des caractères, l'écran est divisé en 16 lignes de 64 colonnes, soit 1024 cases numérotées de 0 à 1023. Pour écrire le caractère CS à la case numéro i, utiliser l'instruction :
PRINT@I,C$;
Pour l'écriture de points en mode graphique, le même écran est divisé en U lignes de 128 colonnes. Pour allumer la case d'abscisse x (0<= x < 128) et d'ordonnée y (0< =Y< 47) utiliser l'instruction
SET(X,Y)
Pour éteindre cette même case
RESET (X, Y)
Pour éteindre instantanément tout l'écran
CLS
Exemple : pour tracer une sinusoïde sur l'écran
CIS: FOR X=O TO 127: SFT(X,24): SET(X,24+20*SIN(X/10)): NEKT
Il est possible de combiner les modes "caractère" et "graphique" pour graduer des axes, commenter des histogrammes, etc...
Pour atteindre sa pleine dimension, le langage BASIC doit bénéficier d'un environnement :
a) il faut pouvoir ranger les programmes en mémoire permanente (ruban perforé, bande ou disque magnétique) de façon à pouvoir les réutiliser ultérieurement. C'est le r8le des fonctions LOAD et SAVE, qui n'appartiennent pas vraiment au langage BASIC mais plutôt au système d'exploitation qui l'environne.
b) Dès lors que l'ordinateur dispose, en dehors de sa mémoire centrale (RAM et ROM) d'une mémoire auxiliaire (disques), les programmes BASIC doivent pouvoir échanger des informations avec ces mémoires auxiliaires (avec des délais évidemment plus longs). C'est l'objet d'instructions spéciales d'entrée-sortie :
| OPEN | : ouverture de fichier |
| INPUT, PRINT, GET, PUT | : échange d'informations avec fichier ouvert |
| CLOSE | : fermeture de fichier |
c) Pour certaines applications en temps réel, l'ordinateur bénéficie d'une horloge, qui lui permet de mieux gérer son propre fonctionnement, et de communiquer à distance avec d'autres ordinateurs. Il n'existe pas encore de standard pour les instructions de communication en temps réel.
Mode Commande
| Passage à la ligne logique suivante et interprétation de la commande. | |
| ¬ | Recul du curseur et suppression du dernier caractère introduit. | |
| SHIFT ¬ | Retour du curseur au début de la ligne logique; effacement de celle-ci. | |
| ¯ | Passage à la ligne d'écran suivante. | |
| : | Séparateur d'instructions dans une même ligne | |
| ® | Avance du curseur à la position de tabulation suivante. Les positions d'arrêt sont les suivantes : 0, 8. 16, 24, 32, 40, 48, 56. | |
| SHIFT ® | Conversion de l'affichage en 32 caractères par ligne. | |
| CLEAR | Effacement de l'écran et conversion en 64 caractères par ligne. |
Mode Exécution
| SHIFT @ | Suspension de l'exécution; suspension de l'affichage pendant un LIST | |
| BREAK | Arrêt de l'exécution | |
| Envoi des données introduites au clavier et demandées par INPUT |
Abréviations
| ? | Mis pour PRINT |
| ' | Remplace: REM |
| . | Désigne la ligne courante dans LIST, EDIT.... |
Caractères de déclaration de type
| Caractère | Type | Exemples |
|
| ||
| $ | alphanumérique (chaîne) | A$, ZZ$ |
| % | entier | Al%, SOMME% |
| ! | simple précision | A!, N1! |
| # | double précision | A#, 1/3# |
| D | double précision (notation exponentielle) | 1.23456789D-12 |
| E | simple précision (notation exponentielle) | 1.23456E+30 |
Opérateurs arithmétiques
| + addition | - soustraction | * multiplication |
| / division | puissance (p.ex, 2 3 = 8) |
Opérateur alphanumérique
| + concaténation (assemblage de chaînes) | "AB"+"CD"="ABCO" |
Opérateurs de comparaison
| Symbole | signification numérique | alphanumérique |
| < | inférieur à | précède |
| > | supérieur à | suit |
| = | égal à | est égal à |
| < = ou = < | inférieur ou égal à | précède ou est égal à |
| >= ou = > | supérieur ou.égal à | suit ou est égal à |
| < > ou > < | différent de | est différent de |
Ordre d'exécution des opérations
(les opérateurs sur une même ligne ont mème priorité)
| |
| - |
| *, / |
| +, - |
| Opérateurs de comparaison NOT AND OR |
Commandes
| Commande | Fontion | Exemples |
|
| ||
| AUTO mm, nn | Enclenche la numérotation automatique des lignes à partir de mm, par incrément de nn |
AUTO AUTO 10 AUTO 5,5 AUTO -10 |
| CLEAR | Réinitialise les variables numériques à zéro et les variables alphanumériques à vide. | CLEAR |
| CLEAR n | Même fonction que CLEAR avec réservation de n bytes pour les chaînes |
CLEAR 500 CLEAR MEM/4 |
| CONT | Fait reprendre une exécution arrêtée par un BREAK | CONT |
| DELETE mm-nn | Supprime les lignes mm à nn dans le programme |
DELETE 100 DELETE 10-50 DELETE |
| EDIT mm |
Entrée dans le mode Editeur
pour corriger la ligne mm (voir ci-dessous) |
EDIT 100 EDIT. |
| LIST mm-nn | Affiche les lignes mm à nn du programme |
LIST LIST 30-60 LIST 30- LIST -60 LIST - |
| NEW | Effacement de programme résident, réinitialisation des variables, pointeurs, etc. | NEW |
| RUN mm | Exécuter le programme à partir de la ligne mm ou de la ligne dont le numéro est le plus petit. |
RUN 55 RUN |
| SYSTEM | Entrée dans le mode moniteur pour charger des programmes en langage machine écrits sur cassette. | voir Chapitre 2 |
| TROFF | Arrêt de la fonction Trace | TROFF |
| TRON | Enclenchement de la fonction Trace | TRON |
Sous-commandes et touche de fonction du mode Editeur
|
Sous-commande/ touche de fonction | Fontion | |
|
| ||
| Fin des corrections et retour au mode Commande. | |
| SHIFT ¬ | Fin du mode Insertion; reste en mode Editeur. | |
| n barre d'espace | Avance du curseur de n positions vers la droite. | |
| n ¬ | Recul du curseur de n positions vers la gauche. | |
| L | Affichage du reste de la ligne et retour en début de ligne. | |
| X | Affichage du reste de la ligne, positionnement du curseur en fin de ligne et entrée en mode Insertion. | |
| I | Entrée en mode Insertion; tout caractère tapé est inséré à la position du curseur; sortie par SHIFT ¬ | |
| A | Suppression de l'effet des corrections et retour du curseur en début de ligne. | |
| E | Fin des corrections et retour au mode Commande. | |
| Q | Suppression de l'effet des corrections et retour au mode Commande. | |
| H | Suppression du reste de la ligne et entrée en mode Insertion tapez SHIFT pour en sortir. | |
| nD | Suppression de n caractères à partir de 1a position courante du curseur. | |
| nC | Remplacement des n caractères à partir de la position du curseur par les n caractères qui vont être tapés. | |
| nSc | Positionnement du curseur sur la nième occurrence du caractère c à partir de la position du curseur. | |
| nKc | Suppression des caractères entre la position du curseur et la nième occurrence du caractère c. | |
Instructions d'Entrée/Sortie
exp
peut être une constante, une variable, un élément de tableau, une expression en général, ou une liste de ces éléments.
| Instruction* | Fontion | Exemples |
|
| ||
| PRINT exp |
Afficher à l'écran la valeur de exp Exp peut être une constante ou une expression numérique ou alphabétique, ou une liste de tels éléments. |
PRINT A$ PRINT X+3 PRINT "D=";D |
| , |
Les virgules modifient un
PRINT en avançant le curseur
jusqu'à la zone d'impression
suivante. A la fin de exp supprime le passage à la ligne suivante. |
PRINT 1,2,3,4 PRINT "l", "2", PRINT 1,,2 |
| ; | Les point-virgules modifient un PRINT en insérant un espace après une valeur numérique dans exp (mais pas après une valeur numérique). A la fin de exp supprime le passage à la ligne suivante. |
PRINT X;*'=REPONSE" PRINT X;Y;Z PRINT "REPONSE='*; |
| PRINT @n |
Modificateur de PRINT; commence l'impression à l'adresse n de l'écran. |
PRINT @540,"CENTRE" PRINT@ N+3, X*3 |
| TAB n | Modificateur de PRINT avance le curseur jusqu'à la position n de la ligne courant (n est une expression) | PRINT TAB(N) |
|
PRINT USING chaîne; exp |
Spécificateur de format
impression = exp est
imprimée selon le format chaîne (voir ci-dessous) |
PRINT USING A$;X PRINT USING "#.#"; Y+Z |
|
INPUT "message"; variable | Imprimer le message 's'il y en a un) et attend des données du clavier. |
INPUT "NOM="; A$ INPUT "VALEUR"; X INPUT "DEUX NOMBRES"; X,Y INPUT A,B,C,D$ |
| PRINT #-1 | Ecriture sur la cassette n°1 | PRINT #-1,A.B,C,D$ |
| INPUT #-1 | Lire sur la cassette n°1 | INPUT #-1,A,B,C,D$ |
|
DATA liste valeurs | Ligne contenant des données sous forme d'une liste de valeurs |
DATA 22,33,11,1.2345 DATA "HENRI", 74, "JEAN", 16 |
| READ | Affecte aux variables de la liste liste variables les valeurs suivantes à partir de la valeur courante des lignes DATA |
READ A,A1,A2,A3 READ A$,B$,C$,D |
| RESTORE | Repositionne le pointeur courant au début des lignes DATA. | RESTORE |
Spécificateurs de zone des instructions PRINT USING
| Caractère numérique | Fonction | Exemple |
| # | Zone numérique (un chiffre par # ). | # # # |
| . | Position du point décimal | # #.# # 0 |
| + | Impression du signe en début ou en fin de zone (signe + et signe -). |
+#.# # # #.# # #+ |
| - | Impression du signe - en fin de zone si le nombre est négatif. | # #.# - |
| ** | Remplacement des zéros initiaux par des astérisques | **# #.# |
| $$ | Imprime un $ à la gauche du premier chiffre significatif | $$# # # # #.# # |
| **$ | Cfr. $$ avec remplissage des positions de gauche inoccupées par des astérisques. | **$# #.# # |
| | Format exponentiel, le premier correspondant à un zéro. |
#.# # # # # #.# .# # # |
| Caractère alphanumérique | Fonction | Exemple |
| ! | Un seul caractère | ! |
| % espaces % | chaîne de n caractères où n = 2 + nombre d'espaces |
%% % % |
Instructions
| Instruction | Fonction | Exemple |
|
| ||
| Définition de type | ||
|
DEFDBL liste de lettres ou d'intervalles | Définit de type double précision toutes les variables dont le nom commence par une lettre appartenant à la liste de lettres ou d'intervalles. |
DEFDBL J DEFDBL X,Y,A DEFDBL A-E, J-L, X |
|
DEFINT liste de lettres ou d'intervalles | Définit de type entier toutes les variables dont le nom commence par une lettre appartenant à la liste de lettres ou d'intervalles. |
DEFINT A DEFINT C, G, T DEFINT F, G-T, B |
|
DEFSNG liste de lettres ou d'intervalles | Définit de type simple précision toutes les variables dont le nom commence par une lettre appartenant à la liste de lettres ou d'intervalles. |
DEFSNG F,0 DEFSNG Z, V-X DEFSNG A-C, I-K |
|
DEFSTR liste de lettres ou d'intervalles | Définit de type alpariumérique toutes les variables dont le nom commence par une lettre appartenant à la liste de lettres ou d'intervalles. |
DEFSTR A, B, C DEFSTR S, V-Y DEFSTR C-E, G-K |
| Assignation et allocation | ||
| CLEAR n | Réinitialise les variables et réserve n bytes pour les valeurs alphanumériques. |
CLEAR 750 CLEAR MEM/10 CLEAR 0 |
|
DIM tab (dim l, ... dim k) | Alloue de l'espace pour un tableau tab de k dimensions ayant successivement une taille de dim 1, ..., dim k. DIM peut déclarer plusieurs tableaux. |
DIM A(2.3) DIM Al(15), A2(15) DIM B(X+2), C(J,K) DIM T(3,3,5) |
| LET variable=expression | Assigne la valeur de l'expression à la variable. LET est facultatif en BASIC NIVEAU II. |
LET A$="HENRI" LET B$=C$ LET A%=1# |
| Enchaînement des instructions | ||
| END | Termine l'exécution et provoque le retour en mode commande. | 99 END |
| STOP |
Arrête l'exécution et imprime
le message BREAK suivi du numéro de la ligne courante.
L'utilisateur peut faire reprendre l'exécution par CONT. | 100 STOP |
| GOTO n° ligne | Provoque un branchement à la ligne n° ligne. | GOTO 100 |
| GOSUB n° ligne | Provoque l'exécution de la sous routine commençant à la ligne n° ligne. | GOSUB 300 |
| RETURN | Provoque une branchement à l'instruction qui suit le dernier GOSUB exécuté. | RETURN |
|
ON exp GOTO nl 1,... nl k | L'expression exp est évaluée; si INT(exp) est égal à l'un des nombres de 1 à k, il y aura branchement vers la ligne appropriée, sinon il y aura passage à l'instruction suivante. | ON K+1 GOTO 100,200,300 |
|
ON exp GOSUB nl 1,... nl k | Même fonction que avec exécution de la sous-routine nl 1, .... nl k selon la valeur de exp. | ON J GOSUB 400,500 |
| FOR var=exp 1 TO exp 2 STEP exp 3 | Ouvre une boucle FOR-NEXT. STEP est facultatif; son absence correspond à un pas de 1 (voir Chapitre 4). |
FOR 1=1 TO 50 STEP 1.5 FOR M%=J% TO K-1% |
| NEXT var | Clôture une boucle FOR-NEXT. var peut être omis ou être remplacé par une liste de noms de variable (voir Chapitre 4). |
NEXT NEXT I NEXT I,J |
| ERROR (code) | Simule l'erreur spécifiée par code (voir table des codes d'erreur). | ERROR (14) |
|
ON ERROR GOTO n° ligne | Si une erreur survient dans la suite du programme, elle provoquera un branchement à a, routine d'erreur commençant à la ligne n° ligne. | ON ERROR GOTO 999 |
| RESUME n | Retour à la ligne n après exécution d'une routine de traitement d'erreur; si n est 0 ou est absent, le retour se fait à l'instruction ayant entraîné l'erreur; si n est "NEXT", le retour se fait à l'instruction qui suit celle qui a entraîné l'erreur. |
RESUME RESUME 0 RESUME 100 RESUME NEXT |
| RANDOM | Réinitialise le générateur de nombres aléatoires. | RANDOM |
| REM | Spécifie un commentaire et fait ignorer le reste de la ligne. | REM A=ALTITUDE DU POINT |
| Instruction conditionnelle | ||
| IF exp THEN instr 1 ELSE instr 2 |
exp est évaluée: si exp est VRAI,
les instructions instr 1 sont
exécutées puis l'exécution se
poursuit à la ligne suivante (sauf
si instr 1 se termine par un
GOTO).
Si exp est FAUX, les instructions instr 2 sont exécutées. |
IF A=0 THEN PRINT "OUI" ELSE PRINT "NON" |
| Instructions graphiques | ||
| CLS | Efface l'écran. | CLS |
| RESET (x, y) | Eteint le segment graphique de coordonnée horizontale x et de coordonnée verticale y. 0<=x<123 et 0<y 48 | RESET (8+B,11) |
| SET(x,y) | Allume le segment graphique de coordonnées x et y. Mêmes limites que pour RESET. | SET(A*2,B+C) |
| Instructions spéciales | ||
| POKE adresse, valeur | Range la valeur dans le byte d'adresse spécifiée. Les arguments sont exprimés sous forme décimale et 0<=valeur<255 |
POKE 15635,34 POKE 1+1, 3*K |
| OUT port, valeur | Envoie la valeur au port de numéro spécifié. Les arguments sont tous deux compris entre 0 et 255. |
OUT 255,10 OUT I,J |
Fonctions alphanumériques
| Fonction* | Action | Exemples |
|
| ||
| ASC(chaîne) | Fournit le code ASCII du premier caractère de la chaîne. |
ASC(B$) ASC("H") |
| CHRS(exp) | Fournit le caractère correspondant au code exp. (voir table des Codes). |
CHR$(34) CHR$(I+1) |
| FRE(chaîne) |
Fournit la quantité de mémoire
disponible pour les chaînes. Chaîne est un argument fictif. | FRE(A$) |
| INKEY$ | Lit le clavier et fournit une chaîne constituée du caractère correspondant à la touche frappée. Cette chaîne est vide si aucune touche n'a été frappée. | INKEY$ |
| LEN(chaîne) | Fournit la longueur de la chaîne. (Zéro si celle-ci est vide). |
LEN(A$+B$) LEN("LONGUEUR") |
| LEFT$(chaîne,n) | Fournit les n premiers caractères de la chaîne. |
LEFT$(A$,l) LEFT$(A$+B$,21) |
| MID$(chaîne,p,n) | Fournit les n caractères de la chaîne commençant à la position p |
MID$(M$,5,2) MID$(A$+B$,P,L-1) |
| RIGHT$(chaîne,n) | Fournit les n derniers caractères de la chaîne. |
RIGHT$(NA$,7) RIGHT$(B$+C$,N-1) |
| STR$(exp) | Fournit la représentation en caractères de la valeur numérique de exp. |
STR$(1.2345) STR$(A + 2*8) |
| STRING$(n,car) | Fournit une chaîne de n fois le premier caractère de car. |
STRING$(32,"*") STRING$(K,A$) |
| VAL(chaîne) | Fournit la valeur numérique que représente la chaîne. |
VAL("1"+A$+"."+B$) VAL("3.1416") |
*Chaîne peut être une constante, une variabliou une expression.
Fonctions mathématiques*
| Fonction | Action | Exemples |
|
| ||
| ABS(exp) | Fournit la valeur absolue de exp. |
ABS(L*.7) ABS(SIN(X)) |
| ATN(exp) | Fournit l'arc-tangente (en radians) de exp. |
ATM (2.7) ATN (A*3) |
| CDBL(exp) | Fournit la valeur de exp en double précision. |
CDBL(A) CDBL(A+1/3#) |
| CINT(exp) | Fournit le plus grand entier inférieur ou égal à exp. -32768 < =exp < =32768. | CINT(A#+B) |
| COS(exp) | Fournit le cosinus de exp (en radians). |
COS(2*A) COS (A/57.29578) |
| CSNG(exp) | Fournit la valeur de exp en simple précision; si exp est en double précision le chiffre le moins significatif subit un arrondi 5/4. |
CSNG(A#) CSNG(.33*B#) |
| EXP(exp) | Fournit l'exponentielle de exp, soit : eexp |
EXP(34.5) EXP(A*B*C-1) |
| FIX(exp) | Fournit la partie entière de exp (suppression des décimales). | FIX(A-B) |
| INT(exp) | Fournit le plus grand entier inférieur ou égal à exp. | INT(A+B*C) |
| LOG(exp) | Fournit le logarithme naturel (en base e) de exp. exp doit être positif. |
LOG (34.5) LOG(AB+C) |
| RND (0) | Fournit un nombre pseudo- aléatoire entre 0.000001 et 0.999999 inclus. | RND(O) |
| RND(exp) |
Fournit un nombre entier
pseudo-aléatoire compris entre
1 et INT(exp) inclus. 1<=exp<32768. |
RND(40) RND(A+B) |
| SNG(exp) | Fournit -1 si exp est négatif, 0 si exp est nul et +1 si exp est positif. |
SGN(A8+3) SGN(COS(X)) |
| SIN(exp) | Fournit le sinus de exp (en radians). |
SIN(A/B) SIN(90/57.29578) |
| SQR(exp) |
Fournit la racine carrée de exp . exp doit être positif ou nul. | SOR(A*A-B*B) |
| TAN(exp) | Fournit la tangente de exp (en radians). |
TAN(X) TAN (X*.Ol 74533) |
*exp est une constante, une variable au une expression de type numérique. Sauf spécification contraire, -1.7E+38 < =exp < = 1.7E+38.
Fonctions spéciales
| Fonction | Actions et limites | Exemples |
|
| ||
| ERL | Fournit le numéro de la ligne où l'erreur courante s'est produite. | ERL |
| ERR |
Si une erreur s'est produite, fournit une valeur
quii vaut : 2*(code d'erreur -1) D'où également : code d'erreur= ERR/2 + 1. | ERR/2+1 |
| INP(port) | Fournit la valeur lue au port d'entrée-sortie spécifié. Cette valeur ainsi que port sont comprises entre 0 et 255 inclus. | INP(55) |
| MEM | Fournit la quantité de mémoire non protégée et non utilisée. | MEM |
| PEEK(adr) | Fournit la valeur du byte d'adresse adresse mémoire. adr doit être une valeur d'adresse valide sous forme décimale (voir Carte de la Mémoire, Annexe D). | PEEK(15370) |
| POINT(x,y) | Teste l'allumage du segment graphique de coordonnée horizontale x et de coorionnée verticale y. Si le segment est allumé, POINT fournit la valeur VRAI (-1), sinon elle fournit la valeur FAUX (0). Les limites sont 0<=x<128 et 0<=y<48. | POINT(2-A,B) |
| POS(0) | Fournit la position du curseur dans la ligne d'écran (de 0 à 63). 0 est un argument fictif. | POS(0) |
| USR(n) |
Branche vers une sous-routine en langage
machine et fournit la valeur qu'elle calcule. Voir chapitre 8. | USR(45+I) |
| VARPTR(var) | Fournit l'adresse de la variable var ou de son descripteur. var doit être un nom de variable valide ou d'un élément de tableau. Fournit 0 si la variable n'a pas encore reçu de valeur. |
VARPTR(A$) VARPTR(A(I)) |