Index des instructions en Omikron Basic 3.01 (Atari)
For more details, see the complete page Omikron 3.01
Attention: ceci n’est qu’un index des instructions de l’Omikron 3.01. Pour les détails, voir la page complète Omikron 3.01.
LES caractères [entre crochets] sont optionnels, et une virgule admet une suite de même type. Les "" représentent une chaîne de caractères. Une variable$ peut généralement être remplacée par une chaîne de caractères, à condition de s’entourer de guillemets. Il existe 2 types d’instructions: les commandes, qui s’emploient de manière directe (RUN, MOUSEON, CIRCLE…) et les fonctions, qui contiennent une valeur et qui nécessitent un PRINT ou une relation d’égalité, appelée allocation (?SQR(7744), KEY 1= "Chaine", V!= SIN(PI/4)…).
V, W$… sont des variables, Et =Etiquette, n =nombre naturel ou n°, x, y ou u, v sont des coordonnées en pixels, l =largeur, h =hauteur, Can = canal, Adr = Adresse en mémoire, L = longueur, R = retour, A et B sont des opérandes, "Nom" et "*.*" sont des fichiers. < > représente une instruction quelconque.
A - B - C - D - E - F - G - H - I - J - K - L - M - N - O - P - Q - R - S - T - U - V - W - X
| Expression | Utilisation | Description |
|---|---|---|
| ! | Variable! | suffixe Réel simple précision |
| # | Variable# | suffixe Réel double précision |
| $ | Variable$ | suffixe Chaîne de caractères |
| $ | $4F3D | préfixe base hexadécimale |
| % | %10010 | préfixe base binaire |
| %B | Tableau%B(4) | suffixe octet, dans les tableaux uniquement |
| %F | Tableau%F(3) | suffixe booléen, dans les tableaux uniquement |
| %[W] | Variable% | suffixe Entier court, W facultatif |
| [%L] | Variable | suffixe Entier long, facultatif |
| [&d] | 43 | préfixe base décimale, facultatif |
| &[o] | &4672 | préfixe base octale, o facultatif |
| ' | ' commentaire | abréviation de REM |
| , | PRINT A$, B$ | affichage à la tabulation suivante (tous les 8 caractères) |
| ; | PRINT A$;"-";B$; | imprime à la suite; empêche le saut de ligne si à la fin |
| < = > | IF A < 3 | opérateurs d’ordre |
| = | Variable=43 | allocation de valeur à une variable |
| ? | ? Variable | abréviation de PRINT |
| \ | 43 \ 5 | division entière |
| ˆ | 2^5 | exposant |
| @(l, c) | ?@(l, c);V$ | affichage "ligne-colonne" |
A | ||
| ABS | ?ABS(V) | valeur absolue |
| AND | ?A AND B | "ET" logique |
| ARCCOS | ?ARCCOS(V!) | arccosinus |
| ARCCOT | ?ARCCOT(V!) | arccotangente |
| ARCOTH | ?ARCOTH(V!) | arccotangente hyperbolique |
| ARCSIN | ?ARCSIN(V!) | arcsinus |
| ARCTAN ou ATN | ?ARCTAN(V!) ou ATN(V!) | arctangente |
| ARSINH | ?ARSTYH(V!) | arcsinus hyperbolique |
| ARTANH | ?ARTANH(V!) | arctangente hyperbolique |
| ASC [Alt_A] | ?ASC("") | code ASCII du 1er caractère |
B | ||
| BACKUP | BACKUP "Nom" | copie *.BAK d’un *.BAS |
| BIN$ | ?BIN$(V) | convertit en chaîne binaire |
| BIOS | BIOS([R], n[, param]) | fonctions-système |
| BIT | ?BIT(n, V) | donne la valeur du bit n de V |
| BITBLT | BITBLT x, y, l, k TO u, v, l, h | déplacement d’image |
| BITBLT | BITBLT x, y, l, h TO Adr | vers mémoire |
| BITBLT | BITBLT Adr TO x, y, l, h, | de 0 à 15 |
| BLOAD [Alt_B] | BLOAD "Nom", Adr | charge sur écran/en mémoire |
| BOX | BOX x, y, l, h ou BOX x, y TO u, v | rectangle |
| BSAVE | BSAVE "Nom", Adr, n | sauve l’écran/la mémoire |
C | ||
| CALL | CALL V (p, q, ) | prg appelé de l’adresse V |
| CDBL | ?CDBL(V) | convertit en double-precision |
| CHAIN | CHAIN [MERGE] "Nom.BAS" | chaîne un *.BAS |
| CHDIR | CHDIR"A;\ DOSSIER" | change le chemin d’acces |
| CHR$ | ?CHR$(n) | caractère ASCII de 0 à 25S |
| CHR$(27) | ?CHR$(27);"n" | code Escape |
| CINT | ?CINT(V) | convertit en entier court |
| CINTL | ?CINTL(V) | convertit en entier long |
| CIRCLE | CIRCLE x, y, r[, d, a] | d et a en 1/10 degré |
| CLEAR | CLEAR | variables à 0, vérifie les boucles |
| CLEAR | CLEAR m[, n] | mémoire GEMDOS et Pile |
| CLIP | CLIP x, y, l, h ou CLIP x, y TO u, v | limite d’affichage |
| CLOSE | CLOSE Can | ferme le canal |
| CLS | CLS | efface l’écran |
| CMD | CMD Can | toute sortie vers un fichier |
| COMMON | COMMON V, W$ | conserve les valeurs pour CHAIN |
| CONT [Alt_C] | CONT [TO n] | après un STOP |
| COPY | COPY "A:\Nom" TO "C:\Nom" | copie un fichier |
| COS | ?COS(V!) | cosinus |
| COSEC | ?COSEC(V!) | cosécante |
| COSECH | ?COSECH(V!) | cosécante hyperbolique |
| COSH | ?COSH(V!) | cosinus hyperbolique |
| COT | ?COT (V!) | cotangente |
| COTH | ?COTH(V!) | cotangente hyperbolique |
| CSNG | ?CSNG(V) | convertit en simple-précision |
| CSRLIN | ?CSRLIN | ligne du curseur (1 à 25) |
| CVD | ?CVD(V$) | V$= 10 caractères -> V# |
| CVI | ?CVI(V$) | V$= 2 caractères -> V% |
| CVIL | ?CVIL(V$) | V$= 4 caractères -> V |
| CVS | ?CVS(V$) | V$= 6 caractères -> V! |
D | ||
| DATA [Alt_D] | DATA "chaine", nombres | données pour READ |
| DATE$ | ?DATE$ : DATE$="" | retourne ou définit la date, voir MODE |
| DEFDBL | DEFDBL V | définit une variable en double-précision |
| DEF FN | DEF FN Nom[$]: < > RETURN(V[$]) | définit une fonction |
| DEFINT | DEFINT V-Z | définit var. entiers courts |
| DEFINTL | DEFINTL V, Z | définit var. entiers long |
| DEF PROC | DEF PROC Nom[p, q, ] ou [R p, R q, ] | définit une procédure |
| DEFSNG | DEFSNG A-C, W | définit var. simple précision |
| DEF SPRITE | DEF SPRITE n, Type, Adr_Fond DEF SPRITE n, 0 | définit une icone mobile |
| DEFSTR | DEFSTR V | définit variables-chaîne |
| DEF USR | DEF USR=Adr | fixe l’Adresse d’un prog-mach |
| DEG | DEG | passage en mode degré |
| DET | X#=DET(V#(n, n)) | déterminant de matrice |
| DIM | DIM V[$](n, m, ) | dimensionne un tableau |
| DRAW | DRAW x, y ou DRAW x, y TO u, v | trace un point ou une ligne |
| DUMP | DUMP [B, V-Z] | affiche les variables [selon leurs initiales] |
E | ||
| EDIT [Help] | EDIT [n] | entre dans l’éditeur GEM (ligne n) |
| ELLIPSE | ELLIPSE x, y, r1, r2[, d, a] | d, a en 1/10 de degré |
| ELSE [Alt_E] | IF < > THEN < > ELSE < > ENDIF | condition alternative |
| END | END | arrêt définitif du programme .BAS |
| ENDIF | IF < > THEN < > [ELSE < >] ENDIF | plusieurs lignes |
| EOF | EOF(Can) | retourne -1 si fin de fichier "I" |
| EQV | ?A EQV B | équivalence logique |
| ERL | ?ERL | n° de ligne de la dernière d’erreur |
| ERR | ?ERR | n° de la dernière erreur |
| ERR$ | ?ERR$ | libellé de la dernière erreur |
| ERROR | ERROR n | simule l’erreur n, de 1 à 70 |
| EXEC | EXEC "A:\Nom.PRG"[, "A:\Nom.PRG"] | lance un programme chargeant un fichier |
| EXIT | EXIT [TO Et] | pour sortir d’une boucle |
| EXP | ?EXP(V) | exponentielle de base e |
F | ||
| FACT | ?FACT(n) | factorielle |
| FIELD | FIELD Can, n AS V$, | longueurs des champs |
| FILES | FILES "A:\DOSS\Nom" ou "*.* ou "*.BAS" | liste fichiers et répertoires |
| FILESELECT | FILESELECT(Chemin$, Nom$, R) | variable$! |
| FILL | FILL x, y, -1 | la zone doit être délimitée + CLIP! |
| FILL COLOR | FILL COLOR=n | couleur Hardware |
| FILL PATTERN | FILL PATTERN= T%(0): FILL STYLE=4, 1 | détermination du motif de remplissage utilisateur |
| FILL STYLE | FILL STYLE n, m - 0, 1 - 1, 1 - 2, 2-24 - 3, 1-12 | motifs de remplissage prédéfini |
| FIX | ?FIX(V!) | supprime la partie décimale |
| FN | ?FN Nom | appel de fonction |
| FOR [Alt_F] | FOR I= m TO n [STEP p] : < > : NEXT | boucle itérative |
| FORM_ALERT | FORM_ALERT(Def, "[n][Tex|te][Ch|oi|x]", R) | appel d’une boîte d’alerte |
| FRAC | ?FRAC(V!) | retourne la partie décimale |
| FRE | ?FRE("A:"), ?FRE(0), ?FRE(""), FRE(Adr) | renseigne la quantité ou libère la mémoire |
G | ||
| GEMDOS | GEMDOS([R], Nr[, param]) | fonctions-système |
| GET | GET Can, V | lit fichiers "R" et "F" |
| GET | GET Can, Adr, L … GET Can, V$ | fichiers "U" |
| GOSUB | GOSUB n - GOSUB Et - GO SUB(V[$]) - RETURN | appelle une routine |
| GOTO [Alt_G] | GOTO n - GOTO Et - GOTO(V[$]) | saute à l’endroit désigné |
| GOTO [Alt_G] | GOTO n-m | peut lancer un programme à un endroit |
H | ||
| HCOPY [Alt_H] | HCOPY | imprime l’écran sur imprimante matricielle |
| HCOPY TEXT | HCOPY TEXT | imprime texte seul |
| HEX$ | ?HEX$(V) | convertit en chaîne hexadécimale |
| HIGH | ?HIGH(V) | mot de poids fort d’un long |
I | ||
| IF | IF < > THEN < > [ELSE < > : ENDIF] | condition |
| IMP | ?A IMP B | implication logique |
| INKEY$ | WHILE A$="": A$=INKEY$: WEND: ?HEX$(CVIL(A$)) | prend un caractère du tampon clavier |
| INLINE | INLINE "" | une ligne d’instructions-machine |
| INPUT [Alt_I] | INPUT [@(l, c) "Texte"] V[$], W[$], | champ éditable simple |
| INPUT# | INPUT #Can, V[$], | fichier "I" (lecture), canal de 1 à 16 |
| INPUT USING | INPUT [@(l, c) ""] V$ USING "Com$", R, n, a, P | formate une champ éditable |
| INPUT$ | V$=INPUT$(n) | attend n caractères |
| INPUT$ | INPUT$(n, Can) | lit n caractère sur le Canal |
| INSTR | INSTR([n, ]V$, W$) | position de W$ dans V$ |
| INT | INT(V!) | arrondit au nombre inférieur |
| INV | MAT A!(n, n)=INV B!(n, n) | inverse une matrice carrée |
| IPL | IPL n | niveau de priorité, de 0 à 7 |
J | ||
| JOYSTICK | A=JOYSTICK(n); BIN$(A) | n=0 ou 1 |
K | ||
| KEY [Alt_K] | KEY n ="" | n= 1 à 20, 32 caractères max |
| KEY LIST | KEY LIST | liste les fonctions associées aux touches |
| KILL | KILL "Nom" ou KILL "DOSSIER\*.BAS" | efface un ou plusieurs fichiers |
L | ||
| LDUMP | LDUMP | affiche les variables sur imprimante |
| LEFT$ | ?LEFT$(V$, n) | retourne les n caractères de gauche |
| LEN | ?LEN(V$) | longueur de la chaîne |
| LET | [LET] V=nombre ou [LET] V$="chaine" | allocation |
| LIBRARY | LIBRARY GEM, "Chemin\GEM.LIB" | charge la librairie "GEM" |
| LINE COLOR | LINE COLOR=n | couleur Hardware |
| LINE INPUT | LINE INPUT V$ | saisie de , et "" |
| LINE INPUT# | LINE INPUT #Can, " " | fichiers "I" |
| LINE PATTERN | LINE PATTERN=n: LINE STYLE=7 | n est %W |
| LINE STYLE | LINE STYLE=n | n= 0 à 7 |
| LINE WIDTH | LINE WIDTH=n | n impair |
| LIST | LIST [m, n] | liste le programme [de m à n] |
| LIST ERL | LIST ERL | retourne la ligne de la dernière erreur |
| LLIST | LLIST | liste sur imprimante |
| LN | ?LN(V) | logarithme naturel de base e |
| LOAD | LOAD "A:\DOSSIER\Nom" | charge fichier *.BAS |
| LOC | ?LOC(Can) | dernier enregistrement "R" lu |
| LOCAL | LOCAL V | définit des variables locales |
| LOF | ?LOF(Can) | longueur "I", n de "R" |
| LOG | ?LOG(V, W) | logaritme en base V de W |
| LOW | ?LOW(V) | mot de poids faible d’un long |
| LOWER$ | LOWER$(V$) | passe un texte en minuscule |
| LPEEK | ?LPEEK(Adr) | donne le contenu, adresse paire |
| LPOKE | LPOKE Adr, n | inscrit un %L, adresse paire |
| LPOS | ?LPOS(0) | colonne de la tête d’imprimante |
| LPRINT [Alt_L] | LPRINT | affiche sur imprimante |
| LSET | LSET V$="chaine" | formate par la gauche |
M | ||
| MAT | MAT A!(l, c)= MAT B!(l, p) * MAT C!(p, c) | multiplication de deux matrices |
| MAT | MAT V!(n, n)=1 | génère une matrice unité |
| MAT CLEAR | MAT CLEAR V(n, m, ) | efface le tableau |
| MAT CLEAR | MAT CLEAR V(n) | efface jusqu’à l’élément n |
| MAX | ?MAX(V$, W$) | choisit le plus grand (ASCII) |
| MEMORY | Adr= MEMORY(n) | réserve n octets de mémoire |
| MEMORY | Adr= MEMORY(V$) | réserve et place en mémoire |
| MEMORY | MEMORY(-1) | affiche la mémoire du GEMDOS |
| MEMORY_BLOCK | MEMORY_BLOCK xx, L, Adr | sauve une zone avec le programme |
| MEMORY_MOVE | MEMORY_MOVE Adr1, L TO Adr2 | Adresses paires |
| MEMORY_MOVEB | MEMORY_MOVEB Adr1, L TO Adr2 | octet par octet |
| MERGE | MERGE "Nom"[, n] | charge sans écraser |
| MID$ [Alt_M] | ?MID$(V$, n, m) | m caract. à partir du n° |
| MIN | ?MIN(V$, W$) | choisit le plus petit (ASCII) |
| MIRROR$ | ?MIRROR$(V$) | renverse une chaîne |
| MKDIR | MKDIR "A:\Nom" | crée un dossier |
| MKD$ | MKD$(V#) | transforme en chaîne de 10 car |
| MKI$ | ?MKI(V%) | transforme en chaîne de 2 car |
| MKIL$ | ?MKIL(V) | transforme en chaîne de 4 car |
| MKS$ | ?MKS(V!) | transforme en chaîne de 6 car |
| MOD | ?A MOD B | reste de division |
| MODE | MODE "GB", "F", "D" ou "USA" | formatage date/heure |
| MODE | MODE=n | modes d’affichage graphique |
| MODE LPRINT | MODE LPRINT "GB", "F", "D" ou "USA" | |
| MOUSEBUT | ?MOUSEBUT | 0, 1, 2 ou 3 (pour les deux boutons) |
| MOUSEOFF | MOUSEOFF | efface le curseur de la souris |
| MOUSEON | MOUSEON | affiche le curseur de la souris |
| MOUSEX [Alt_X] | ?MOUSEX | de 0 à 639 ou 319 \ selon la |
| MOUSEY [Alt_Y] | ?MOUSEY | de 0 à 399 ou 199 / resolution |
N | ||
| NAME | NAME "Nom" AS "Autre" | renomme un fichier |
| NAND | ?A NAND B | inverse du "ET" logique |
| NDC | NDC x, y, l, h | (0, 0) en bas à gauche |
| NEW | NEW ["Nom"] | efface [et choisit le suivant] |
| NEXT [Alt_N] | FOR I= m TO n [STEP p] < > : NEXT | boucle itérative |
| NOISE | NOISE m, Plage | 32 plages de fréquences |
| NOR | ?A NOR B | inverse du "OU" logique |
| NOT | ?NOT A | inversion des bits |
O | ||
| OCT$ | ?OCT$(V) | convertit en chaîne octale |
| ON ERROR GOTO | ON ERROR GOTO n | pour traitement d’erreur |
| ON GOSUB | ON n GOSUB n1, n2, | choisit la routine |
| ON GOTO | ON n GOTO n1, n2, | choisit la ligne |
| ON HELP GOSUB | ON HELP GOSUB n | routine si [Help] |
| ON KEY GOSUB | ON KEY GOSUB n | routine si [Touche] |
| ON MOUSEBUT | ON MOUSEBUT GOSUB n | routine si bouton-souris |
| ON RESTORE | ON n RESTORE n1, n2, | choisit les DATA |
| ON TIMER | ON TIMER n GOSUB n | routine toutes les n secondes |
| ON TRON GOSUB | ON TRON GOSUB n | routine à chaque instruction |
| OPEN [Alt_O] | OPEN "O", Can, "Nom" | ouvre un fichier séquentiel en écriture |
| OPEN | OPEN "A", Can, "Nom" | ouvre un fichier séquentiel en ajout d’écriture |
| OPEN | OPEN "I", Can, "Nom" | ouvre un fichier séquentiel en lecture |
| OPEN | OPEN "C", "K", "M", "V" ou "P" | ouvre d’autres fichiers séquentiels: console, clavier, midi, modem ou imprimante |
| OPEN | OPEN "R", Can, "Nom", L | fichief relatif |
| OPEN | OPEN "F", Can, "A:\" | fichier directory |
| OPEN | OPEN "U", Can, "NOM" | fichier relatif de champs à taille variable |
| OR | ?A OR B | "OU" logique |
| OUTLINE | OUTLINE ON ou OFF | contours ou non des P-figures |
P | ||
| PALETTE | PALETTE C1, C2, | Cn=RVB; R, V et B de 0 à 7 |
| PBOX | PBOX x, y , l, h ou TO u, v | boîte remplie |
| PCIRCLE | PCIRCLE r, y, r | cercle rempli |
| PEEK | ?PEEK(Adr) | lit un octet en mémoire |
| PELLIPSE | PELLIPSE x, y, r1, r2 | ellipse remplie |
| PI | ?PI ou V!=PI | double précision par défaut |
| POINT | ?POINT(x, y) | retourne la couleur du point |
| POKE | POKE Adr, n | inscrit un octet en mémoire |
| POLYGONE | POLYGONE (O, n) | n= 2 X côtés + 2 |
| POS | ?POS(O) | n° de colonne du csr |
| PPOLYGONE | PPOLYGONE= T%(O, n) | polygone rempli |
| PRBOX | PRBOX x, y, l, h ou TO u, v | boîte arrondie remplie |
| PRINT [Alt_P] | PRINT V[$], W[$] ou V[$], W[$] | affiche sur écran |
| PRINT # | PRINT #Can, V_ | fichier "O" et "A" |
| PRINT @ | PPRINT @(l, c); V[$] | l de 0 à 24, c de 0 à 79 |
| PRINT SPC | PRINT SPC(n) | imprime n espaces |
| PRINT TAB | PRINT TAB(c); | saute à la co1onne c |
| PRINT USING | PRINT USING "####";V | formate un nombre à l’affichage |
| PUT | PUT Can, L | écrit dans fichiers "R" |
| PUT | PUT Can, Adr, L ou PUT Can, V$ | fichiers "U" |
Q | ||
| QUIT | QUIT | pour quitter le BASIC |
R | ||
| RAD | RAD | pour revenir en mode radian si DEG |
| RBOX | RBOX x, y, l, h ou TO u, v | boîte arrondie |
| READ | READ V[$], W[$], | lit des DATA |
| REM | REM ou ' | pour des remarques ou titres |
| RENUM | RENUM nv [, anc, pas] | renumérote les lignes; RENUM seul: 1e ligne=100, pas=10 |
| REPEAT | REPEAT: < > : UNTIL < > | répéter |
| RESTORE | RESTORE [n], RESTORE Et | repositionne le pointeur pour les DATA |
| RESUME | RESUME [NEXT], RESUME Et | retourne au programme après un traitement d’erreur |
| RETURN [Alt_R] | GOSUB, DEF PROC Nom[$], RETURN | fin de sous-programme ou procédure fonction |
| RETURN | DEF FN Nom[$]= ou RETURN (V[$]) | fin de fonction |
| RIGHT$ | ?RIGHT$(V$, n) | retourne les n car. de droite |
| RMDIR | RMDIR "Dossier" | détruit si vide |
| RND | RND(1), RND(n), -RND(-n), RND(0) | nombre aléatoire, réel ou naturel |
| RSET | RSET V$="chaine" | formate par la droite |
| RUN | RUN [n] ou RUN [Et] | lance le programme en mémoire |
| RUN | RUN "Nom" | charge et lance un programme |
S | ||
| SAVE | SAVE "Nom"[, A] | sauvegarde un programme [en ASCII] |
| SCREEN | SCREEN n, Adr | choisit entre 3 écrans |
| SCREEN | SCREEN n, Adr, 4 | passe en moyenne résolution |
| SEC | ?SEC(V!) | sécante |
| SECH | ?SECH(V!) | sécante hyperbolique |
| SEEK | SEEK Can, Depl, Mode | déplacement dans un fichier "R" |
| SEGPTR | ?LPEEK(SEGPTR+n) | pointeurs du programme |
| SGN | ?SGN(V) | retourne le signe (1 ou -1) d’un nombre |
| SHL | ?A SHL(n) | multiplication par 2^n |
| SHR | ?A SHR(n) | division entière par 2^n |
| SIN | ?SIN(V!) | sinus |
| SINH | ?SINH(V!) | sinus hyperbolique |
| SORT | SORT V[$](0) [TO W(0)] | trie un tableaux à une dimension |
| SORT ASC | SORT ASC T$(n) | distingue MAJ et min. |
| SPACE$ ou SPC | ?SPACE$(n) | chaîne de n espaces |
| SPRITE | SPRITE n, x, y, Adr_Dess, 0, 1 | appel du sprite n |
| SQR | ?SQR(V) | racine carrée rapide |
| STEP | FOR I= n TO m STEP p < > : NEXT | pas |
| STOP | STOP | suspend un programme |
| STRING$ | ?STRING$(n, "x") ou (n, Asc) | ="xxxxxxxxx" |
| STR$ | ?STR$(V) | transforme expr num en chaîne |
| SWAP | SWAP A, B | intervertit A et B de même type |
| SYSTEM [Alt_S] | SYSTEM | pour quitter le BASIC |
T | ||
| TAN | ?TAN(V!) | tangente |
| TANH | ?TANH(V!) | tangente hyperbolique |
| TEXT | TEXT x, y, V$ | affiche un texte graphique |
| TEXT COLOR | TEXT COLOR= n | couleur Hardware |
| TEXT HEIGHT | TEXT HEIGHT= n | hauteur, n= 1 à 26 |
| TEXT ROTATION | TEXT ROTATION= n | n multiple de 900 |
| TEXT STYLE | TEXT STYLE= n | n= combinaison de paramètres |
| THEN [Alt_T] | IF < > THEN < > [ELSE < > ENDIF] | condition |
| TIMER | T=TIMER | en 200° de seconde |
| TIME$ | ?TIME$ ou TIME$="hh:mm:ss", | retourne ou définit l’heure |
| TROFF | TROFF | annule le suivant |
| TRON | TRON | passe en mode "trace" |
| TUNE | TUNE 1, n, 2, m, 3, o, | hauteur du son |
U | ||
| UNTIL | REPEAT: < > UNTIL < > | «jusqu’à» |
| UPPER | ?UPPER$(V$) | passe un texte en majuscule |
| USING [Alt_U] | USING "####" - USING "" | formate un nombre |
| USR | ?USR[(V%L)] | appelle un programme-machine |
V | ||
| VAL | ?VAL(V$) | transforme en valeur numérique |
| VARPTR [Alt_V] | ?VARPTR(V[$]) | adresse de la variable |
| VOLUME | VOLUME voie, n | volume pour la voie de 1 à 3, n de 0 à 15 |
| VOLUME | VOLUME Voie, Env, Duree | enveloppe de son |
W | ||
| WAIT | WAIT n | en secondes, au 200° |
| WEND | WEND < > : < > : END | fin de WHILE |
| WHILE [Alt_W] | WHILE < > : < > : WEND | "tant que" |
| WPEEK | WPEEK(Adr) | donne le contenu (adresse paire) |
| WPOKE | WPOKE Adr, n | inscrit un court (adresse paire) |
| WRITE | WRITE " " | guillemets conservés |
| WRITE# | WRITE #Can, " " | dans fichier "A" et "O" |
| WVBL | WVBL | attend le retour de balayage vertical |
X | ||
| XBIOS | XBIOS([R], Nr[, param]) | fonctions-système |
| XOR | ?A XOR B | "OU" exclusif logique |