DIM - INPUT#

Dictionnaire des mots-clés BASIC, C64

Du Commodore 64

DIM

Type : Instruction

Syntaxe : DIM nom_variable [, nom_variable..]

Modes : Les modes Direct et Programme sont tous deux valides.

Jeton : $86 (134)

Entrée abrégée : D SHIFT-I

Utilisation :

DIM (DIMension) alloue de la mémoire au-dessus du programme BASIC pour les variables, dans l'ordre de leur liste dans l'instruction DIM.

Cette commande est exécutée automatiquement lorsqu'une variable reçoit une valeur (par exemple, une ligne contenant l'expression X=1).

Il est donc inutile d'utiliser DIM, sauf pour les tableaux de plus de 10 dimensions.

Toutes les variables allouées par DIM sont initialisées à 0 (pour les valeurs numériques) ou à null (pour les chaînes de caractères).

Remarques :

1. Les tableaux peuvent utiliser des expressions numériques dans leurs instructions DIM ; leur taille peut donc être déterminée par une valeur d'entrée et n'est pas nécessairement fixe.

Les tableaux commencent à l'élément zéro.

Ainsi, DIM X(4) crée un tableau numérique avec cinq emplacements de stockage, de X(0) à X(4). Une dimension peut contenir jusqu'à 32 767 éléments.

Les tableaux multidimensionnels ne peuvent contenir que 255 indices au maximum.

En pratique, une erreur de mémoire insuffisante (?OUT OF MEMORY ERROR) se produira bien avant d'atteindre ces limites.

2. Les tableaux sont stockés en mémoire au-dessus des variables classiques.

Vvoici quelques conséquences  :

• L'ajout de nouvelles variables après la création d'un tableau entraîne un délai.

• Les tableaux peuvent être supprimés avec :

POKE 49, PEEK(47) : POKE 50, PEEK(48)

Ainsi, si des résultats intermédiaires sont calculés avec un grand tableau, celui-ci peut être supprimé une fois le traitement terminé.

3. Les tableaux d'entiers sont performants, tandis que la performance des tableaux de chaînes de caractères dépend de la longueur des chaînes. PRINT FRE(0) donne une indication rapide de la RAM disponible à tout moment.

4. Les grands tableaux de chaînes de caractères sont sensibles aux délais de récupération de mémoire. C'est le nombre total de chaînes distinctes, et non leur longueur, qui est le facteur déterminant pour la récupération de mémoire.

Exemples :

1. 100 INPUT "NUMBER OF ITEMS";N: DIM IT$(N)

Cela pourrait être utilisé dans un programme de tri, où un nombre quelconque d'éléments peut être trié.

2. DIM X,Y,J,L,P$ :REM SET ORDER OF VARIABLES

L'ordonnancement des variables, en plaçant en premier les plus fréquemment utilisées, contribuera à augmenter la vitesse des programmes BASIC.

3. 100 DIM A(20): FOR J=1 TO 20: INPUT A(J): A(0)=A(0)+A(J): NEXT

La ligne ci-dessus utilise l'élément zéro pour calculer un total cumulé.

4. DIM X%(10,10,10)

Cela crée un tableau de 1331 entiers, peut-être pour stocker les résultats de trois questionnaires à 11 points.

END

Type : Instruction

Syntaxe : END

Modes : Les modes direct et programme sont tous deux valides.

Jeton : $80 (128)

Saisie abrégée : E SHIFT-N

Fonction : END interrompt l’exécution d’un programme et le fait passer en mode immédiat.

Cette commande permet de définir des points d’arrêt dans un programme ; CONT permet à un programme de reprendre son exécution à l’instruction suivant END.

BASIC n’a pas toujours besoin de END ; un programme peut simplement manquer de lignes, mais END est nécessaire pour terminer le programme en cours d’exécution.

END laisse BASIC disponible pour l’affichage ; vous pouvez préférer éviter cela en utilisant NEW ou SYS 64738 à la place de END.

Remarque : Les premiers ordinateurs nécessitaient toujours END pour séparer les cartes perforées de chaque programme. Ce n’est plus le cas aujourd’hui.

Exemples :

1. 10000 IF ABS(BEST-V) <.001 THEN PRINT BEST: END

Le programme s'arrête ainsi lorsqu'un processus répétitif a trouvé une solution à un problème dans une plage de précision souhaitée.

2. 100 GOSUB 1000: END: GOSUB 2000: END: GOSUB 3000: END

Ces lignes proviennent d'un programme en cours de développement ; elles illustrent l'utilisation de END pour définir des points d'arrêt. CONT reprend l'exécution du programme après le test de chaque sous-routine.

EXP

Type : Fonction numérique

Syntaxe : EXP(expression numérique)

Modes : Les modes direct et programme sont tous deux valides.

Jeton : $BD (189)
Saisie abrégée : E MAJ-X

Utilisation : EXP calcule e (2,7182818...) à n'importe quelle puissance comprise entre -88 et +88, approximativement.

Le résultat est toujours positif, tendant vers 0 pour les arguments négatifs et devenant grand pour les arguments positifs.

EXP(0) vaut 1.

Remarque : EXP est l'inverse de LOG.

Les logarithmes de nombres sont parfois utilisés dans les calculs ; EXP ramène les résultats à leur forme normale. EXP(Q) pourrait être remplacé par 2,7182818^Q, mais la forme abrégée est plus lisible.

Exemples :

1. PRINT EXP(LOG(N))

La ligne ci-dessus affiche N (éventuellement avec une erreur d'arrondi), démontrant que EXP et LOG sont des opérations inverses.

2. 100 P(N) = M^N * EXP(-M)/FACT(N)

Il s'agit d'une formule statistique classique, qui calcule la probabilité que N événements rares se produisent exactement lorsque la moyenne est M, FACT(N) vaut N! pour un intervalle de valeurs approprié.

EXP est important car il a la propriété particulière d'être égal à son propre taux de croissance ; il apparaît fréquemment dans les calculs scientifiques.

FOR-TO (STEP)

Type : Instruction

Syntaxe : FOR variable numérique simple = expression numérique TO expression numérique /STEP expression numérique]

Modes : Les modes direct et programme sont tous deux valides.

Jeton : FOR : $81 (129) ; TO : $A4 (164) ; STEP : $A9 (169)

Entrée abrégée : FOR : F SHIFT-O ; TO : Aucun ; STEP : ST SHIFT-E

Fonction : FOR-TO [STEP] permet de compter le nombre d’exécutions d’une portion de code BASIC.

Remarques :

1. Fonctionnement des boucles FOR-NEXT.

La syntaxe après FOR est vérifiée ; par exemple, FOR X% = 1 TO 10 est rejetée. La pile est ensuite examinée pour vérifier si une instruction FOR avec la variable actuelle existe ; si c’est le cas, la boucle précédente est supprimée.

Ainsi, FOR X=1 TO 10 : FOR X=1 TO 10 est traitée comme une seule instruction FOR. 18 octets sont alors placés sur la pile, si l’espace le permet. Une fois placées, ces valeurs restent inchangées.

Ainsi, la limite supérieure de la boucle FOR X=1 TO N ne change pas après le démarrage de la boucle, même si la valeur de N est modifiée à l'intérieur de celle-ci.

10 FOR X=489 TO 506: PRINT PEEK(X): NEXT

liste 18 octets de la pile :

le jeton FOR, l'adresse sur deux octets de la variable de boucle, la taille du pas (STEP) au format décimal, le signe du pas, la valeur décimale de la limite supérieure de la boucle, le numéro de ligne de la boucle FOR et l'adresse de destination après la fin de la boucle.

La valeur du pas est par défaut de 1.

Comme NEXT détermine si la boucle doit continuer, chaque boucle FOR-NEXT est exécutée au moins une fois, même FOR J=1 TO 0: NEXT.

NEXT vérifie également la variable de boucle ; ainsi, NEXT X,Y, par exemple, garantit un enchaînement correct des boucles : il doit être précédé des instructions FOR Y et FOR X.

L'instruction NEXT ajoute la valeur de STEP à la variable.

Si le résultat dépasse la limite stockée (ou est inférieur si une valeur de STEP négative a été utilisée), le traitement se poursuit avec l'instruction suivant NEXT.

Le système ne peut pas détecter l'absence d'un appel à NEXT ; si une série de boucles s'exécute anormalement vite, cela peut en être la raison.

Lorsque la valeur de STEP est définie avec précision, l'utilisation de boucles ne génère aucune perte de précision.

Ainsi :

FOR J=1 TO 10000 STEP .5

est exact, tout comme la valeur par défaut de STEP (1).

En revanche :

FOR M=1 TO 1000 STEP 1/3: PRINT M: NEXT

produira des erreurs.

Cette description devrait vous permettre de repérer les bogues dans les boucles, ce qui peut s'avérer difficile sans informations détaillées.

2. Vitesse d'exécution des boucles.

Lors de l'optimisation d'un programme long pour améliorer sa vitesse, portez une attention particulière aux boucles, car les inefficacités sont amplifiées proportionnellement à la taille de la boucle.

Dimensionner les variables par ordre d'importance décroissante peut accélérer l'exécution (attention toutefois à ne pas dimensionner les variables à l'intérieur de la boucle, car cela provoquerait une erreur).

3. Sortie de boucle.

L'une des meilleures façons de sortir d'une boucle est d'utiliser l'instruction NEXT ; modifier la variable de boucle est une méthode simple pour y parvenir.

Par exemple :

5 FOR J=1 TO 9000: GET X$: IF X$="A" THEN J=9000

10 NEXT

Se termine prématurément si la touche A est enfoncée.

4. Autres boucles.

La boucle étendue DO WHILE peut être simulée avec :

FOR J= -1 TO 0 : instructions à exécuter :

J=CONDITION : NEXT

Le traitement se poursuit jusqu'à ce que J soit faux.

Bien entendu, des structures de boucle plus complexes sont possibles.

Exemples :

1. PRINT "{CLR}": FOR J=1 TO 500: PRINT "*";: NEXT

La ligne d'exemple ci-dessus affiche 500 astérisques.

2. K=0: FOR J=1024 TO 1024+255: POKE J,K: K=K+1: NEXT

Cette fonction écrit les caractères de 0 à 255 séquentiellement dans la mémoire de l'écran. K compte au même titre que J.

3. FOR J=2048 TO 9E9: IF PEEK(J)<>123 THEN NEXT:PRINT J

Ces instructions recherchent en mémoire, à partir de l'adresse 2048, un octet égal à 123.

À la fin de la boucle, l'instruction PRINT J affiche l'adresse.

4. 5 FOR J=l TO 12

10 IF M$<>MID$("JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC",3*J-2,3) THEN NEXT

Les lignes ci-dessus correspondent à une abréviation de mois correctement saisie, précédemment entrée sous la forme M$.

Une fois le programme exécuté, J prendra la valeur d'un nombre compris entre 1 et 12, indiquant le mois (ou 13 si aucune correspondance n'a été trouvée).

FRE

Type : Fonction numérique

Syntaxe : FRE (expression numérique)

Modes : Les modes direct et programme sont tous deux valides.

Jeton : $B8 (184)

Saisie abrégée : F + MAJ + R

Utilisation :

FRE calcule le nombre d'octets disponibles pour BASIC.

Si ce nombre est supérieur à 32 767, la valeur renvoyée est négative ; l'ajout de 65 536 permet de la convertir en valeur réelle.

Le Commodore 64 dispose de 64 Ko de mémoire RAM, mais 24 Ko sont généralement masqués par la ROM et n'apparaissent pas dans le total des octets libres.

FRE est utile pour supprimer les chaînes dynamiques inutilisées, qui occupent un espace variable en RAM et peuvent être à l'origine d'erreurs de type « mémoire insuffisante ».

FRE effectue d'abord un nettoyage de la mémoire avant de renvoyer sa valeur.

FRE utilise une expression factice ; généralement un zéro est utilisé, donc l'expression est FRE(0).

Exemples :

1. 1000 IF FRE(0)<100 PRINT "SHORT OF RAM"

L'exemple ci-dessus affiche un message lorsque la mémoire libre est inférieure à 100 octets ou renvoie une valeur négative.

Cette routine devrait être modifiée pour être utilisable, en raison des valeurs négatives renvoyées par FRE (voir explication ci-dessus).

2. F=FRE(O): DIM X$(50): PRINT F-FRE(0)

Cela affiche le nombre d'octets utilisés pour dimensionner X$ à 50.

3. 200 F=FRE(0)-(FRE(0)<0)*65536

Cela calcule le nombre d'octets libres dans toutes les circonstances, et stocke la réponse dans F.

GET

Type : Instruction d'entrée

Syntaxe : GET nom_variable [, nom_variable...]

Mode : Seul le mode programme est disponible.

Jeton : $A1 (161)

Entrée abrégée : G SHIFT-E

Fonction : GET lit un caractère unique depuis le périphérique d'entrée courant, généralement le clavier, et l'affecte à la variable nommée.

Si le tampon clavier est vide, les variables de type chaîne de caractères reçoivent la valeur nulle et les variables numériques la valeur 0.

Contrairement à INPUT ou à GET sur certains autres ordinateurs, GET n'attend pas la frappe d'une touche.

Le BASIC peut donc vérifier la présence d'une touche et poursuivre son exécution en l'absence de touche.

GET X$ est plus puissant que GET X, qui provoque un plantage en cas de détection d'une touche non numérique.

C'est pourquoi la forme chaîne de caractères de GET est presque toujours utilisée, et des conversions sont effectuées si nécessaire.

La forme chaîne de caractères GET fonctionne avec n'importe quel caractère ASCII, mais les touches RUN/STOP, Commodore, SHIFT, CTRL et RESTORE ne sont pas détectées par GET.

Exemples :

1.

5 GET X$: IF X$="" GOTO 5: REM AWAIT KEY

10 PRINT "{CLR}" X$ ASC(X$): GOTO 5

Ce court programme attend qu'une touche soit pressée, puis efface l'écran et affiche la touche pressée ainsi que sa valeur ASCII.

Quelques exceptions existent, comme les guillemets et les commandes de couleur. Vous verrez comment la touche Entrée est interprétée, ainsi que toutes les autres touches.

2. 100 DIM IN$(200): FOR J=1 TO 200: GET IN$(J): NEXT

Cette ligne insère 200 caractères dans un tableau, dont la plupart seront des valeurs nulles.

3. 200 GET A$,B$,C$

Cette instruction est syntaxiquement valide, mais ce format est plus approprié avec l'instruction GET#.

La syntaxe est acceptée car GET, GET#, INPUT et READ utilisent en grande partie les mêmes routines du noyau, et les concepteurs du 64 ont estimé qu'il n'était pas nécessaire de supprimer les alternatives relativement inutiles.

GET#

Type : Instruction d'entrée

Syntaxe : GET# expression numérique, nom de variable ,[nom de variable...]

L'expression numérique, un numéro de fichier, doit être évaluée et tronquée à un nombre compris entre 1 et 255.

Mode : Seul le mode programme est disponible.

Jeton : $A1 (161) puis $23 (35). Ceci correspond à GET puis # ; GET# n'a pas de jeton propre.

Saisie abrégée : G SHIFT-E #

Fonction :

GET# lit un seul caractère du fichier spécifié, qui doit être ouvert sur un périphérique d'entrée, sous peine d'une erreur « FICHIER NON OUVERT ».

Contrairement à l'instruction INPUT#, GET# peut lire des caractères tels que les deux-points, les guillemets et les retours à la ligne.

GET# peut lire les fichiers caractère par caractère, ce qui est impossible avec INPUT#, et n'est pas limité à 88 caractères par chaîne.

Remarques :

1. GET# peut lire depuis l'écran ou le clavier, bien que cela ne présente généralement aucun avantage.

2. La commande GET# sur bande attribue la valeur 64 à la variable d'état (ST) lorsqu'elle atteint la fin du fichier.

Les programmes peuvent ainsi évaluer ST pour détecter la fin des données si aucun marqueur spécifique n'a été utilisé. ST est immédiatement réinitialisée ; il est donc nécessaire de répéter cette opération après chaque commande GET#.

3. La commande GET# sur disque attribue également la valeur 64 à ST à la fin du fichier.

Ensuite, ST prend la valeur 66, ce qui indique la fin du fichier et l'absence de réponse du périphérique.

Exemples :

1.

1000 IN$=""
1010 GET#1,X$: IF ASC(X$)=13 GOTO 2000 :REM RETURN FOUND
1020 IN$=IN$+X$: GOTO 1010 :REM BUILD STRING

Ce programme extrait une chaîne de caractères depuis une bande ou un disque, en construisant IN$ à partir de chaque caractère, et passe à la partie suivante du programme lorsque RETURN indique la fin de la chaîne. Une routine à la ligne 2000 traite la chaîne une fois le processus GET# terminé.

2. 100 GET#8,X$: IF ST=64 GOTO 1000: REM END OF DATA

La ligne ci-dessus montre comment utiliser ST pour détecter qu'il n'y a plus de données dans le fichier, et comment passer à une autre partie du programme en fonction de cette information.

3. 100 GET#1,X$,Y$

Cette ligne de programme d'exemple récupère une paire de caractères consécutifs à partir du fichier 1, qui a déjà été ouvert sur un périphérique d'entrée.

GOSUB

Type : Instruction

Syntaxe : GOSUB numéro de ligne

Modes : Les modes direct et programme sont tous deux valides.

Jeton : $8D (141)

Entrée abrégée : GO SHIFT-S

Fonction : GOSUB effectue un saut à la ligne BASIC spécifiée, en sauvegardant l'adresse de la ligne d'origine sur la pile.

Ainsi, l'instruction RETURN d'un programme peut transférer le contrôle à l'instruction qui suit immédiatement l'instruction GOSUB.

Cela signifie qu'une sous-routine peut être appelée depuis n'importe quel endroit en BASIC tout en conservant le flux d'exécution normal du programme.

IF ou ON permettent d'effectuer des appels conditionnels à des sous-routines.

Remarques :

1. Test des sous-routines en mode direct.

Il est souvent simple de tester des parties d'un programme volumineux en mode direct.

Par exemple :

L=1234 : GOSUB 500

2. Traitement de GOSUB.

Les numéros de ligne suivant GOSUB sont analysés par une routine similaire à VAL.

Les nombres sont saisis jusqu'à la rencontre d'un caractère non numérique.

Par exemple, GOSUB, GOSUB NEW et GOSUB 0XX sont interprétés comme GOSUB 0.

Ceci permet à ON-GOSUB de fonctionner, car il peut alors ignorer les virgules.

Ensuite, GOSUB place cinq octets sur la pile.

10 GOSUB 20

20 FOR J=500 TO 504: PRINT PEEK(J);: ​​NEXT

Le programme ci-dessus affiche cinq octets depuis la pile : un jeton GOSUB (141), le numéro de ligne de GOSUB et un pointeur vers l'instruction GOSUB.

Le numéro de ligne est utilisé dans le message d'erreur si la ligne de destination n'existe pas.

Il est légèrement plus rapide de regrouper les sous-programmes au début du BASIC, afin de réduire le temps passé à les rechercher, et il est également légèrement plus rapide de numéroter les lignes avec les plus petits nombres possibles afin de réduire le temps de traitement des numéros de ligne.

Notez que les instructions GOSUB sans instruction RETURN peuvent saturer la pile et provoquer une erreur de mémoire insuffisante (?OUT OF MEMORY ERROR).

Saisissez et exécutez le programme suivant (une seule ligne) pour observer ce phénomène :

100 GOSUB 100

3. Divers.

 L'instruction GOSUB 500: RETURN a le même effet que GOTO 500, mais utilise davantage d'espace sur la pile.

La programmation structurée fait un usage intensif des sous-programmes ; la réécriture des programmes contenant de nombreuses instructions IF ou d'autres constructions complexes en sous-programmes contribue à les rendre plus clairs.

Exemples :

1.

100 EM$="DISK NOT IN DRIVE":GOSUB 2000
110 END
2000 PRINT "{HOME} {RVS}*** ERROR " EM$ " {OFF}"
2010 FOR J=1 TO 2000: NEXT: RETURN

Faisant partie d'une routine de message d'erreur simplifiée, cet extrait imprime une erreur (EM$ doit être défini avant GOSUB 2000) à l'envers en haut de l'écran.

2.

500 GOSUB 510
510 PRINT"*"
520 RETURN

Ceci montre comment une sous-routine peut avoir plusieurs points d'entrée.

Ici, GOSUB 510 affiche un astérisque, tandis que GOSUB 500 l'affiche deux fois.

GOTO; GO TO

Type : Instruction

Syntaxe : GOTO numéro de ligne ; GO TO numéro de ligne

Modes : Les modes direct et programme sont tous deux valides.

Jeton : GOTO : $89 (137).

Les jetons GO et TO séparés sont également acceptés.

Entrée abrégée : G SHIFT-O

Fonction : GOTO permet d'accéder à la ligne BASIC spécifiée.

IF et ON permettent des instructions GOTO conditionnelles.

Remarques :

1. Utilisation de GOTO en mode direct.

En mode direct, GOTO exécute le programme en mémoire sans exécuter le CLR.

Ainsi, si le programme a déjà été exécuté, les variables sont conservées.

Ceci est similaire à CONT, sauf que n'importe quelle ligne peut être sélectionnée comme point de départ. Les variables peuvent être modifiées, mais elles seront perdues si des lignes du programme BASIC sont modifiées.

2. Les numéros de ligne sont lus par la même routine que celle qui gère les numéros de ligne de GOSUB, et des restrictions similaires s'appliquent.

Exemples :

1. TI$="235910": GOTO 1000

Il s'agit d'un exemple en mode direct ; l'horloge est réglée juste en dessous de 24 heures, puis le programme en mémoire est exécuté à partir de la ligne 1000, en conservant la valeur de TI$.

2. 100 GET A$: IF A$="" GOTO 100

Cette simple boucle attend une pression sur une touche.

IF-THEN

Type : Instruction conditionnelle

Syntaxe : IF expression logique THEN numéro de ligne

IF expression logique GOTO numéro de ligne

IF expression logique THEN instruction [: instruction...]

Modes : Les modes direct et programme sont tous deux valides.

Jeton : IF : $8B (139) ; THEN : $A7 (167)

Entrée abrégée : IF : Aucun ; THEN : T MAJ-H

Utilisation :

Les instructions IF-THEN permettent un branchement conditionnel vers n’importe quelle ligne de programme ou l’exécution conditionnelle d’instructions suivant THEN.

L'expression suivant IF est traitée comme une valeur booléenne (c'est-à-dire que si elle est égale à zéro, elle est fausse ; si elle est différente de zéro, elle est vraie).

Si l'expression est vraie, l'instruction suivant THEN est exécutée ; si elle est fausse, le reste de la ligne est ignoré et le traitement se poursuit à la ligne suivante.

Si l'expression est une chaîne de caractères, le résultat dépend du dernier calcul effectué à l'aide de l'accumulateur à virgule flottante ; ainsi, IF X$ THEN peut être vrai ou faux.

Exemples :

1. 1000 LC=LC+1: IF LC=60 THEN LC=0: GOSUB 5000

Cet extrait de programme incrémente le compteur de lignes (LC) ; si LC est 60, il réinitialise la valeur du compteur à 0 et appelle une sous-routine d'avance de formulaire à 5000 avant de continuer.

2. 700 IF X=1 THEN IF A=4 AND B=9 THEN PRINT "*"

Il s'agit d'une instruction IF composite, identique en effet à :

IF X=1 AND A=4 AND B=9 THEN PRINT "*"

mais probablement un peu plus rapide.

3. 500 IF X THEN PRINT "NONZERO"

Cet exemple illustre que SI X ALORS est identique à SI X<>0 ALORS.

INPUT

Type : Instruction d'entrée

Syntaxe : INPUT [invite de saisie entre guillemets ;] nom de variable ^nom de variable...]

Modes : Seul le mode programme est disponible.

Jeton : $85 (133)

Entrée abrégée : Aucune

Fonction :

INPUT est une commande facile à programmer qui lit des données depuis le 64 et les assigne à une variable.

INPUT affiche les données à l'écran, permettant ainsi l'utilisation de fonctions d'édition comme la touche SUPPR.

Appuyer sur la touche RETOUR signale la fin de l'instruction INPUT.

Remarques :

1. Invites de saisie.

INPUT N$ et INPUT "NAME";N$ illustrent les deux formes de INPUT.

Les deux affichent un point d'interrogation suivi d'un curseur clignotant, mais la seconde version affiche également NAME, donnant NAME? comme invite.

Lorsque vous utilisez une instruction INPUT avec plusieurs variables (par exemple, INPUT X$,Y$), deux points d'interrogation consécutifs (??) s'afficheront à l'écran si seule la première chaîne est saisie, suivie de la touche RETOUR.

En réponse aux deux points d'interrogation, il vous suffit de saisir les données restantes. La saisie des deux valeurs, séparées par une virgule (PREMIER, DEUXIÈME), assigne les deux chaînes de caractères, sans autre invite.

Ces lignes d'exemple illustrent l'utilisation de la chaîne d'invite :

100 INPUT "{CLR}{DOWN}{RIGHT}";X$

Cela efface l'écran et déplace le curseur (et le point d'interrogation) vers le bas et à droite de sa position initiale.

100 INPUT "{2 SPACES}-{LEFT} {LEFT} {LEFT} {LEFT}",X$

Ceci illustre la technique permettant d'indiquer la longueur attendue des données d'entrée. Il doit y avoir deux espaces après le premier guillemet, et deux traits de gauche de plus que de tirets.

100 INPUT "{RED}{RVS}NAME",N$

Ceci affiche l'invite en rouge et inverse la vidéo. Les invites trop longues peuvent poser problème.

Si la réponse de l'utilisateur est suffisamment longue pour que le curseur passe à la ligne suivante, l'invite risque d'être ajoutée à la saisie. Pour éviter cela, il est conseillé d'utiliser une combinaison des instructions PRINT et INPUT.

PRINT "A LONG PROMPT MESSAGE";:INPUT X$

Vous n'avez peut-être pas à vous soucier de ce problème, car les modèles 64 bits récents en sont exempts.

Une autre solution consiste à modifier le tampon clavier ; cela permet de faire disparaître le point d'interrogation. Saisissez et exécutez la ligne suivante :

100 POKE 198,1: POKE 631,34: INPUT X$

Ceci insère une apostrophe dans le tampon clavier, ce qui revient à appuyer sur la touche guillemet juste après l'exécution de la commande INPUT.

Cela permet la saisie de chaînes de caractères comme LDA $A000,X, même si elles contiennent des virgules ou des deux-points.

2. Gestion des données saisies.

Lorsque vous appuyez sur Entrée, la ligne de données est placée dans le tampon d'entrée en attente de traitement, notez que cela a pour conséquence l'impossibilité d'utiliser INPUT en mode direct.

Après la saisie, les données du tampon sont comparées à la liste des variables après l'exécution de la commande INPUT.

Le message ?EXTRA IGNORED signifie que trop d'éléments distincts ont été saisis ;

l'invite ?? signifie que trop peu d'éléments ont été saisis et qu'il faut en saisir davantage ;

et ?REDO FROM START signifie que les types de variables ne correspondent pas aux données saisies.

100 INPUT X

La ligne ci-dessus indique à l'ordinateur qu'il attend une entrée numérique ; il acceptera 123,4 et même 1E4, mais pas HELLO.

100 INPUT X$,Y$

Dans l'exemple ci-dessus, l'ordinateur attend la saisie de deux chaînes de caractères.

Il acceptera « HELLO, THERE » mais comme deux chaînes distinctes ;

si « HELLO, THERE, 64 » est saisi, l'ordinateur acceptera « HELLO » comme première chaîne, « THERE » comme seconde, et n'acceptera pas les caractères « 64 », mais répondra par « ?EXTRA IGNORED ».

En général, il ne s'agit pas de problèmes graves, sauf si un programme est conçu pour être infaillible, auquel cas l'instruction GET est essentielle. Sans gestion des erreurs, un utilisateur pourrait saisir « HOME »,

CTRL-WHT, SHIFT-RUN/STOP ou des guillemets, ce qui perturberait l'instruction INPUT.

Remarque :

Toutes les invites (« ? », « ?? », « ?EXTRA IGNORED ») sont supprimées lorsque INPUT# est utilisé.

Lors de l'utilisation de INPUT : POKE 19,1 a cet effet.

De même, la ligne suivante, qui ouvre un fichier au clavier, supprime les invites :

OPEN 1,0: INPUT#1,X$

Exemples :

1. INPUT "ENTER NAME";N$: PRINT "HELLO, " N$

Il s'agit d'une simple saisie de chaîne de caractères N$, suivie d'une salutation personnelle.

2. FOR J=1 TO 10: INPUT X(J): NEXT

La ligne ci-dessus saisit dix nombres dans un tableau.

3. 100 INPUT "DEVICE{2 SPACES}3{LEFT}{LEFT}{LEFT}";D

Cet exemple illustre une méthode permettant de définir une valeur par défaut pour la saisie.

Dans ce cas, appuyer sur la touche Entrée attribue la valeur 3 à D, ce qui représente un gain de temps pour l'utilisateur.

Voici une autre méthode, qui n'affiche pas la valeur par défaut sous le curseur :

4. 100 X$="YES": INPUT X$

Si l'utilisateur appuie simplement sur RETOUR, X$ conserve la valeur « OUI ».

INPUT#

Type : Instruction d'entrée

Syntaxe : INPUT# expression numérique, nom de variable [,nom de variable...]

L'expression numérique, un numéro de fichier, doit être évaluée et tronquée à un nombre compris entre 1 et 255.

Mode : Seul le mode programme est disponible.

Jeton : $84 (132)

Saisie abrégée : I SHIFT-N (Ceci inclut le #.)

Fonction :

INPUT# permet de lire facilement des variables à partir d'un fichier, généralement sur bande ou disque.

Le format est identique à celui de PRINT# ; les données sont composées de caractères ASCII séparés par des retours à la ligne. Si INPUT# correspond à PRINT#, cette commande ne devrait pas poser de problème.

Remarque : INPUT# est très similaire à INPUT.

Voici une liste des différences entre les deux :

• Comme le périphérique ne peut généralement pas l'utiliser, aucune invite n'est affichée.

• Certains caractères sont ignorés (comme les espaces sans texte et les caractères d'édition d'écran) sauf s'ils sont précédés de guillemets.

De même :

PRINT#1,"HELLO:THERE"

La commande INPUT# interprète la valeur comme deux chaînes de caractères, car les deux-points sont traités comme des séparateurs.

En général, l'utilisation de PRINT# avec des variables simples permet d'éviter ces erreurs.

• INPUT# ne peut pas accepter une chaîne de plus de 88 caractères, car cela provoque une erreur « ?STRING TOO LONG ». La saisie à l'écran ne présente pas ce problème, car une partie d'une chaîne trop longue est simplement ignorée.

• ST signale la fin du fichier, comme avec l'instruction GET#.

Exemple :

10 OPEN 1 :REM READ TAPE FILE
20 DIM D$(100): FOR J=1 TO 100: INPUT#1,D$(J): NEXT

Cet exemple lit 100 chaînes d'un fichier bande précédemment écrit dans un tableau.