★ CODING ★ AMSTRAD CPC 464 - CRÉER DE NOUVELLES INSTRUCTIONS ★

Nouvelles Instructions 008
EXEMPLES DE PROGRAMMES

5. DESSIN D'UN CERCLE

Ce programme est certainement l'un des plus complexes de tous ceux que présente cet ouvrage, essentiellement parce que nous allons y manipuler des variables de deux types : entières ou à virgule flottante.

A cet égard, il est indispensable d'avoir lu au préalable l'Annexe V, ou tout au moins sa première partie (Les variables numériques).
Le programme débute en 43680, finit en 43877 (chiffre de vérification : 27097), n'est pas directement relogeable, et son format d'appel est le suivant :

CALL 43680,XC,YC,R,C,PV

  • XC et YC sont les coordonnées du centre du cercle.
  • R est la longueur du rayon (exprimée en pixels).
  • C est la couleur.
  • PV détermine si le cercle doit être plein ou vide (0 : vide, 1 : plein).
Le paramètre PV sera optionnel. S'il n'est pas indiqué, le cercle sera vide.
Par ailleurs, une protection sera établie, qui provoquera un retour immédiat au BASIC si l'instruction CALL n'est pas suivie de quatre ou cinq paramètres. Avec certains programmes, en effet, l'oubli d'un ou de plusieurs paramètres peut provoquer des catastrophes. Ce genre de protection permet d'éviter ces désagréments.
Vous savez certainement que l'équation d'un cercle se présente sous la forme :
X - XC + R * Cos(a) Y = YC + R * Sin(a)
la valeur a étant la valeur de l'angle qui varie de 0 à 360 degrés.
Nous allons donc utiliser dans ce programme les routines &BD8B et &BD88 permettant de calculer respectivement les sinus et les cosinus. Ces routines sont malheureusement assez lentes et c'est pour gagner du temps que nous allons utiliser une petite astuce grâce à laquelle nous n'aurons à calculer que les sinus et cosinus des angles allant de 0 a 90 degrés au lieu d'avoir à le faire de 0 à 360 degrés.

La figure ci-dessous servira à expliquer le processus :

Chaque fois que nous aurons calculé les coordonnées d'un point (X,Y), dont l'angle correspondant variera de 0 à 90°, nous calculerons les coordonnées relatives par rapport à ce point du point (X1, Y1), puis les coordonnées relatives de (X2,Y2) par rapport à (X1.Y1), et enfin les coordonnées relatives par rapport à (X2,Y2) de (X3,Y3). Les quatre quadrants seront donc dessinés simultanément. Remarquons que les coordonnées relatives de :

(X1,Y1) par rapport à (X,Y) sont : - 2 (X - XC), 0 ;
(X2,Y2) par rapport à (X1,Y1) sont : 0, - 2 (Y - YC) ;
(X3,Y3) par rapport à (X2,Y2) sont : 2 (X - XC), 0.
A ce sujet, revoir éventuellement l'Annexe II.
Il faut enfin savoir que nous aurons, au cours de ce programme, à stocker provisoirement un certain nombre de variables. C'est la raison pour laquelle les cases mémoires 43878 à 43895 sont divisées en cinq "placards" dans lesquels nous rangerons ces variables (voir en fin de listing la manière dont sont disposés ces placards).

Voyons maintenant le déroulement ligne par ligne de ce programme (dans un premier temps, nous laisserons de côté les lignes 1 à 17, qui rendent le cinquième paramètre optionnel et installent la protection' évoquée plus haut). Considérons donc pour l'instant que le programme débute en ligne 18, et qu'il n'y a que quatre paramètres derrière notre instruction CALL (XC,YC,R,C). Le cercle tracé sera donc vide.


Le tableau suivant représente les cinq placards :

Intéressons nous tout d'abord au bloc constitué par les lignes 18 à 37 qui se charge d'effectuer le calcul de l'abscisse X (rappelons que x ft XC + R * Cos (a)).

Ligne 18 : Le contenu du registre IX est rangé dans le placard prévu à cet effet (cases mémoire 43893 et 43894). Ce registre est chargé pour l'instant, comme nous le savons, avec l'adresse de l'octet faible de C, mais les routines Sinus et Cosinus que nous appellerons plus loin utilisent ce registre pour leur propre compte et vont donc dénaturer son contenu, c'est pourquoi il faut le sauvegarder.

Ligne 19 : Chargement de l'accumulateur avec 90. Ce chiffre servira à la fois pour initialiser le compteur, et pour calculer les sinus et cosinus successifs des angles 90 à 0.

Ligne 20 : Le contenu de A est rangé dans son placard (case mémoire 43895). Une seule case suffit car la machine "sait" que le contenu de A ne peut en aucun cas être supérieur à 255.

Lignes 21 et 22 : Chargement de A avec le numéro de couleur choisi et appel de la routine &BBDE, qui fixe la couleur graphique.

Lignes 23 et 24 : Chargement de HL avec R.

Ligne 25 : Chargement de DE avec l'adresse de la première des cinq cases constituant le placard réservé au rayon R. Nous allons en effet transformer la représentation de R (qui est pour l'instant stockée sous une forme entière, c'est-à-dire sur 2 octets) en sa représentation en virgule flottante, donc sur 5 octets. Nous y sommes obligés car nous allons travailler avec le bloc de routines "Arithmétique avec virgule flottante".
Bien entendu, la valeur R reste la même, seule change sa représentation.

Ligne 26 : Appel de la routine &BD40 : "Transformer la représentation entière d'un nombre en sa représentation en virgule flottante". Le nombre traité doit au départ être chargé dans HL et l'adresse du placard où l'on veut qu'il se retrouve doit être chargée dans DE. Après l'exécution de cette ligne, la représentation en virgule flottante de R est donc rangée dans les cases mémoire 43878 à 43882.

Ligne 27 : Chargement de HL avec le contenu de 43895, c'est-à-dire avec la valeur de l'angle à ce moment : 90 au premier tour de boucle, 89 au deuxième, 88 au troisième, etc.

Ligne 28 : Chargement de DE avec l'adresse du placard réservé aux cosinus (on peut également dire : pointage de DE sur ce placard).

Ligne 29 : Comme pour le rayon, transformation en virgule flottante et rangement du résultat au placard. Il faut savoir qu'au retour de la routine &BD40, les contenus des registres HL et DE ne sont plus les mêmes. Au cours de ses manipulations, la routine les modifie et, après son exécution, c'est maintenant HL, et non plus DE, qui est chargé avec l'adresse du placard.
La manière dont doit être chargé un registre avant l'appel d'une routine s'appelle le registre d'appel, et son état lorsqu'il revient le registre de réponse.

Ligne 30 : Appel de la routine &BD8B qui calcule le cosinus d'un angle. Registre d'appel: HL doit être chargé avec l'adresse de la variable que l'on veut traiter (ce qui était bien le cas après la ligne 29). Registre de réponse : HL reste inchangé. Le résultat est rangé à la place de la variable.

Ligne 31 : Chargement de l'adresse du rayon R dans DE, en prévision de l'utilisation de la routine &BD61 en ligne 32.

Ligne 32 : Appel de la routine &BD61 qui effectue la multiplication de deux nombres.
Registres d'appel : HL et DE doivent respectivement être chargés avec l'adresse du premier et du deuxième nombre.
Registres de réponse : HL reste inchangé, mais pas DE. Le résultat de la multiplication est chargé à l'adresse pointée par HL (notons que le nombre adressé au départ par DE reste inchangé).

Ligne 33 : Appel de la routine &BD45, qui effectue l'opération inverse de la routine &BD40, puisqu'elle transforme une représentation en virgule flottante en une représentation entière.
Registre d'appel : HL doit être chargé avec l'adresse du nombre. Registre de réponse: HL contient le nombre entier, c'est-à-dire maintenant R * Cos(a).

Ligne 34 : Chargement de IX avec le contenu de l'emplacement mémoire d'adresse 43893. Ce registre est donc maintenant rechargé avec sa valeur initiale sauvegardée en ligne 18.

Ligne 35 : Une ligne un peu particulière : il s'agit de l'appel du sous-programme interne d'adresse 43864 (lignes 78 à 80). Ce sous-programme a pour fonction de charger DE avec XC. Nous aurons en effet besoin d'effectuer plusieurs fois cette opération, et il est donc rentable de faire un sous-programe spécifique qu'il suffit d'appeler. Ce sous-programme est extrêmement simple :

Lignes 78 et 79 : Chargement de DE avec XC

Ligne 80 : Retour de sous-programme (donc à la ligne 36)

Plusieurs remarques s'imposent néanmoins :

  1. Cette routine permet d'économiser trois octets chaque fois que l'on aura besoin de charger DE avec XC. L'appel nécessite trois octets ; mais, s'il fallait charger directement DE, il en faudrait six.
  2. L'instruction de retour d'un sous-programme interne est la même que celle d'un retour de l'instruction CALL.
  3. La règle évoquée au début de l'ouvrage est plus que jamais valable si la pile est manipulée au cours d'un sous-programme, e//e doit être remise en état avant que le retour soit provoqué par l'instruction C9.
Ligne 36 : DE étant maintenant chargé avec XC et HL avec R * Cos(a), ils sont additionnés pour obtenir enfin l'abscisse de notre premier point : XC + R * Cos(a).
Le résultat de cette addition se trouve dans HL.

Ligne 37 : Mise au placard de ce résultat. Notons qu'il s'agit d'un entier, maintenant, et qu'il est donc rangé sur 2 octets : 43883 et 43884.
Les lignes que nous venons d'étudier peuvent en fait être séparées en blocs distincts :

  • Le premier va des lignes 18 à 26 et se charge de sauvegarder IX, de sauvegarder la valeur du compteur, de transformer R en virgule flottante et de le ranger une fois pour toutes dans son placard. Ces différentes tâches n'auront à être exécutées qu'une seule fois.
  • Le second bloc (lignes 27 à 36) se charge du calcul XC + R * Cos(a). La ligne 37 sauvegarde ce résultat.
Les lignes 38 à 47 sont identiques aux lignes 27 à 36, si ce n'est que la ligne 41 appelle la routine Sinus au lieu de Cosinus, et que l'on se sert dans ce bloc du placard réservé aux sinus. De même, l'appel au sous-programme 43871 de la ligne 46 charge DE avec YC au lieu de XC.
Il est donc inutile de refaire une étude ligne par ligne de ce bloc chargé de calculer YC + R * Sin(a), et nous nous contenterons de résumer la situation après son exécution (donc immédiatement après la ligne 47):
  1. L'abscisse X du point (X,Y) que nous voulons dessiner a été calculée précédemment et stockée à l'adresse 43883. Elle s'y trouve toujours.
  2. L'ordonnée Y du même point vient d'être calculée et se trouve, après l'exécution de la ligne 47, dans HL.
Nous allons maintenant étudier le bloc allant de la ligne 48 à la ligne 64. Ce bloc va tracer le point (X,Y), puis (X1,Y1), puis (X2.Y2), et enfin (X3.Y3). (Revoir à ce sujet la figure du début et les explications s'y rapportant.)

Ligne 48 : Chargement de DE avec X.

Lignes 49 à 50 : Sauvegarde, en les rangeant sur la pile, de Y puis de X (attention à la pile, ça va se compliquer...).

Ligne 51 : Appel de la routine &BBEA qui dessine sur l'écran le point de coordonnées X,Y.
Registres d'appel: DE doit être chargé avec l'abscisse X et HL avec l'ordonnée Y. Registres de retour : tous modifiés.
Ce premier point étant tracé, nous allons maintenant nous occuper du point (X1.Y1) dont les coordonnées relatives par rapport au précédent sont : - 2 (X - XC), 0. Nous devrons donc d'abord calculer - 2 (X - XC).

Ligne 52 : Chargement de DE avec XC.

Ligne 53 : Appel du sous-programme interne d'adresse 43850, allant des lignes 69 à 77. Voyons ce que fait cette routine :

Lignes 69, 70 et 71, ou "l'art et la manière d'éviter un énorme piège".

En effet, qu'y a-t-il sur la pile au moment où l'on arrive à la ligne 69 ? X ? Eh bien non, justement. N'oubliez pas que, lorsque le programme rencontre un appel de sous-programme, l'adresse de retour est empilée et ne sera dépilée qu'au moment du retour. Au sommet de la pile se trouve donc pour l'instant l'adresse 43820. Cette adresse est soulevée, X qui est en-dessous est chargé dans HL, puis l'adresse est reposée sur la pile.

Ligne 72 : DE est soustrait de HL. Le résultat (X - XC) se retrouve dans HL.

Ligne 73 : HL est additionné à lui-même, ce qui revient à le multiplier par 2. HL contient maintenant 2 (X – XC).

Ligne 74 : Appel de la routine de changement de signe déjà étudiée. HL est maintenant chargé avec – 2 (X – XC).

Ligne 75 : Echange des contenus de HL et DE.

Ligne 76 : HL est chargé avec 0.

Ligne 77 : Retour de sous-programme. Rappelons encore une fois que l'adresse de retour est en même temps dépilée.

Lignes 54, 55, 56 : Sauvegarde de – 2 (X – XC), en s'arrangeant pour que Y reste au sommet de la pile.

Ligne 57 : HL étant toujours chargé avec 0 et DE avec – 2 (X – XC), appel de la routine &BBED qui dessine un point à une position relative au curseur graphique, ce dernier se trouvant alors en (X,Y), c'est-à-dire au dernier point tracé.
Registres d'appel : l'abscisse et l'ordonnée relatives doivent se trouver respectivement dans DE et HL.
Notre deuxième point (X1,Y1) est donc tracé et le curseur graphique y est positionné. Nous pouvons nous attaquer au troisième point (X2,Y2) de coordonnées relatives 0, - 2 (Y - YC).

Ligne 58 : Appel du sous-programme interne d'adresse 43871 qui charge DE avec YC.

Ligne 59 : Appel du sous-programme interne d'adresse 43850, déjà étudié à la ligne 53. Cette fois, il va calculer - 2 (Y – YC). Au retour, HL est chargé avec 0 et DE avec - 2 (Y - YC).

Ligne 60 : Inversion de HL et D. Cette fois en effet, c'est l'abscisse qui doit être égale à 0.

Ligne 61 : Appel de la routine &BBED, déjà étudiée. Notre troisième point étant tracé, reste le quatrième, de coordonnées relatives 2 (X – XC), 0.

Ligne 62 : Si vous avez bien suivi l'état de la pile, vous savez qu'il s'y trouve actuellement au sommet la valeur – 2 (X - XC), sauvegardée en ligne 55. La ligne 62 charge cette valeur dans HL.

Ligne 63 : Appel du sous-programe interne d'adresse 43856 (ligne 74). Notons que ce programme est en partie le même que celui qui est appelé aux lignes 53 et 59.
Le signe de HL est inversé, HL et DE sont échangés et HL est chargé avec 0. Au retour de cette routine, HL est donc chargé avec 0 et DE avec 2 (X - XC).

Ligne 64 : Tracé du quatrième point (X3.Y3).
Nos quatre points étant tracés, nous allons passer à l'angle suivant après avoir vérifié l'état du compteur. C'est le rôle des lignes 65 à 67.

Ligne 65 : HL est chargé avec l'adresse du placard Angle.

Ligne 66 : Une nouvelle instruction : "Décrémenter le contenu de l'emplacement mémoire adressé par HL." L'angle est donc diminué de 1.

Ligne 67 : Encore une nouvelle instruction : "Retour conditionnel de sous-programme." Si le résultat de l'opération de la ligne 66 est inférieur à °. alors le retour au BASIC est effectué, sinon le programme se poursuit en séquence.

Ligne 68 : Saut relatif de –106 (en ligne 27). Le programme va ainsi boucler )Usqu'à ce que toutes les valeurs de l'angle, de 90 à 0, aient été traitées.
Les trois blocs suivants sont les trois sous-programmes déjà étudiés :

Lignes 69 à 77 : Calcul de -2(X - XC) ou -2(Y - YC).

Lignes 78 à 80 : Chargement de DE avec XC.

Lignes 81 à 83 : Chargement de DE avec YC.
Nous pouvons maintenant étudier les lignes 1 à 17 qui rendent optionnel le paramètre PV (plein / vide) et protègent le programme en provoquant un retour immédiat au BASIC s'il n'y a pas quatre ou cinq paramètres.

Détaillons tout d'abord la procédure qui va nous permettre de dessiner un cercle plein.
Reconsidérons la figure du début. Le processus de tracé des quatre points doit être maintenant bien clair pour tout le monde :

1. Tracé du point (X,Y).
2. Tracé du point (X1,Y1) relativement à X,Y.
3. Tracé du point (X2,Y2) relativement à (X1,Y1).
4. Tracé du point (X3,Y3) relativement à (X2,Y2).
Mais que se passerait-il si l'on y apportait les modifications suivantes :
1. Tracé du point (X,Y).
2. Tracé d'une ligne relative d'extrémité (X1.Y1).
3. Tracé du point (X2.Y2) relativement à (X1,Y1).
4. Tracé d'une ligne relative d'extrémité (X3,Y3).
Eh bien, tout simplement ceci :

En procédant ainsi, les lignes tracées les unes contre les autres, au fur et à mesure que a varie de 90 à 0, formeront un cercle plein.

Le point (X1,Y1) est tracé en ligne 57 grâce à la routine &BBED et le point (X3.Y3) en ligne 64 grâce à la même routine. Il suffirait donc de remplacer cette routine &BBED par la routine &BBF9 qui trace une ligne de la position du curseur jusqu'à la position relative indiquée.

Les lignes 57 et 64 se situent en mémoire comme ceci :

43823 : CD    ;43840 : CD
43824 : ED    ;43841 : ED
43825 : BB    ;43842 : BB

On peut donc se contenter de charger les cases mémoire 43824 et 43841 avec &F9 pour obtenir un appel non plus à &BBED, mais à &BBF9

C'est ce que réalise le bloc de lignes 5 à 17 :

Ligne 5 : Cette ligne nous permet une découverte extrêmement importante : il faut savoir en effet qu'au moment de l'appel CALL le nombre de paramètres qui se trouvent effectivement derrière l'instruction est automatiquement chargé dans l'accumulateur. Cette ligne 5 effectue une comparaison (déjà étudiée) entre l'accumulateur et le chiffre 4. Si le résultat est 0, cela voudra donc dire qu'il y a exactement quatre paramètres derrière l'instruction CALL.

Ligne 6 Si le résultat de l'opération de la ligne 5 est 0, alors saut relatif de 22. Cela signifie en effet que le paramètre PV est omis, et que le cercle doit être vide. Si ce n'est pas le cas, le programme se poursuit en séquence.

Ligne 7 : Comparaison entre l'accumulateur et 5. Ici se trouve la protection évoquée plus haut : à ce point du programme, nous savons déjà qu'il n'y a pas quatre paramètres. Nous vérifions maintenant s'il y en a cinq. Si c'est le cas, le résultat de l'opération sera 0, sinon il sera différent de 0.

Ligne 8 : S'il n'y a ni quatre ni cinq paramètres, c'est donc qu'il y a une erreur dans le format d'appel. Dans ce cas, cette instruction "Retour de sous-programme si non nul" provoque le retour au BASIC.
Dans le cas contraire, c'est que le paramètre PV a été mis, et qu'il va donc falloir le tester.

Ligne 9 : Littéralement : "OU exclusif logique entre l'accumulateur et lui-même." Sans entrer dans les détails, il suffit de savoir que cette instruction nous sert à mettre l'accumulateur à 0 (c'est plus simple que d'utiliser l'instruction de chargement).

Ligne 10 : Comparaison entre A (chargé avec 0) et le paramètre PV.

Ligne 11 : Si le résultat de l'opération de la ligne 10 est 0, alors le cercle doit être vide et cette ligne provoque un saut relatif de 10 (en ligne 16). Sinon, le cercle doit être plein et le programme se poursuit en séquence. Voyons d'abord ce dernier cas.

Ligne 12 : Chargement de HL avec l'adresse 43824, celle qui doit être modifiée de manière à obtenir l'appel de la routine traçant une ligne au lieu d'un point.

Ligne 13 : Chargement de la case mémoire adressée par HL avec la donnée 249 (&F9).

Lignes 14 et 15 : Même processus, mais avec l'adresse 43841.

Lignes 16 et 17 : Deux incrémentations successives de IX ; voyons pourquoi : Nous avons dit que la partie principale du programme a été écrite en posant comme hypothèse que l'instruction CALL ne serait suivie que de quatre paramètres (il fallait bien choisir entre quatre et cinq puisque PV est optionnel). Cette hypothèse implique bien entendu que le registre IX est pointé au départ comme le montre la partie gauche du tableau ci-après :

Si l'instruction CALL est suivie de cinq paramètres, par contre le pointage de IX est tel que montré dans la colonne de droite.

Les pointages sont donc différents selon le cas, ce qui pose problème puisque le programme est commun.
La double décrémentation des lignes 16 et 17 apporte la solution en rendant ces pointages identiques. Ainsi, si nous utilisons le programme en transmettant cinq paramètres et que par exemple YC doive être chargé, nous ne serons plus obligés d'utiliser IX + 6 et IX + 7, puisque a valeur 2 aura été au préalable ajoutée à IX. Nous utiliserons donc

IX + (6 - 2) et IX + (7 - 2), soit IX + 4 et IX + 5, comme dans le cas où il y a quatre paramètres.
Le saut relatif de la ligne 11 s'explique de la même manière.
Revenons maintenant aux lignes 1 à 4.

Elles initialisent le programme en chargeant les cases mémoire 43824 et 43841 avec la donnée 237 (&ED). Après ces lignes, le programme est donc un programme "cercle vide". Pourquoi ces lignes ?
Imaginons qu'elles n'existent pas et que dans un programme BASIC, vous ayez à utiliser le programme cercle plein. Les lignes 12 à 15 vont faire les modifications nécessaires et cela marchera. Mais si jamais, dans le même programme BASIC, vous avez à utiliser ensuite le programme "Cercle vide", cela ne marchera plus, et pour cause : si la modification vide – plein est prévue, il n'en est pas de même pour l'inverse plein
– vide et vous ne pourrez plus dessiner que des cercles pleins. C'est pourquoi les lignes 1 à 4 initialisent systématiquement le programme "Cercle vide" avant le test éventuel du paramètre PV.
Remarque

Revenons un court instant aux lignes 20 et 65. La première charge l'emplacement mémoire 43895 avec 90 (il s'agit de l'angle de départ). La ligne 65 charge le registre HL avec le contenu de l'emplacement mémoire d'adresse 43895.

Mais attention : comme il s'agit d'un registre double, L sera chargé avec (43895), et H avec (43896). Or, ce dernier emplacement n'est en rien modifié par la ligne 20, puisque le chargement se fait alors grâce à un registre simple. Si donc, au moment ou le programme a été chargé, il n'y avait rien (donc 0) à cet emplacement, tout ira bien et HL sera correctement chargé avec la valeur de l'angle. Mais si un programme est déjà venu occuper cette adresse, il se peut que l'emplacement 43896 soit toujours chargé avec une valeur quelconque. Dans ce cas, et pour éviter que HL soit chargé avec une valeur incorrecte, il faudra insérer, avant ou après le programme de chargement, la ligne :

POKE 43896,0

Naturellement, cette précaution pourrait aussi être facilement intégrée dans le programme lui-même.
L'étude de ce programme étant terminée, voici quelques exemples de son utilisation :

100 CLS:DEG
110 FOR 1 = 110 TO 10 STEP -11
120 C = C+1: IF C = 4 THEN C=1
130 CALL 43680,200,200,1,C : CALL 43680,400,200,1,C 1
140 NEXT I

Évidemment, une fois un programme en langage machine au point, on peut toujours s'amuser à le "torturer" un peu.
Essayez par exemple de supprimer le DEG de la ligne 100. Ou bien laissez le DEG mais insérez la ligne suivante :

105 POKE 43722,50

Ou encore, enlevez le DEG et insérez :

105 POKE 43722,5

Un dernier exemple enfin, encore plus spectaculaire. Insérez la ligne :

105 POKE 43722,5 : POKE 43834,&F9

et modifiez le "I = 110" de la ligne 110 en "I=165". Essayez une fois avec lé DEG et une fois sans.
Il reste à signaler que le programme fonctionne indifféremment dans les trois modes, et à parler un peu de sa vitesse d'exécution.

Pour un cercle vide, un programme BASIC aura un temps d'exécution d'environ 12,8 secondes, alors que notre programme en langage machine en aura un d'environ 2,8 secondes. Le gain de temps n'est certes pas négligeable, mais on ne peut pas dire non plus que ce soit extraordinaire.

Cette relative lenteur est due, comme nous l'avons déjà dit, aux routines Sinus et Cosinus. La difficulté est incontournable, tout au moins d'une manière parfaitement élégante, à moins de fabriquer de toutes pièces un algorithme sinus et cosinus, ce qui est un autre problème.

Néanmoins, pour les "mordus" du cercle, le programme suivant propose une autre solution et exécute la même tâche en un peu plus d'une demi-seconde. Mais on n'a rien sans rien, et cela va nous coûter quelque 910 octets, non pas à cause du programme lui-même, rassurez-vous, mais tout simplement parce que nous allons avoir besoin d'un énorme placard !

★ ANNÉE: ???
★ AUTEUR: JEAN-CLAUDE DESPOINE

Page précédente : Nouvelles Instructions 007
Je participe au site:

» Vous avez remarqué une erreur dans ce texte ?
» Aidez-nous à améliorer cette page : en nous contactant via le forum ou par email.

CPCrulez[Content Management System] v8.732-desktop/c
Page créée en 740 millisecondes et consultée 1429 fois

L'Amstrad CPC est une machine 8 bits à base d'un Z80 à 4MHz. Le premier de la gamme fut le CPC 464 en 1984, équipé d'un lecteur de cassettes intégré il se plaçait en concurrent  du Commodore C64 beaucoup plus compliqué à utiliser et plus cher. Ce fut un réel succès et sorti cette même années le CPC 664 équipé d'un lecteur de disquettes trois pouces intégré. Sa vie fut de courte durée puisqu'en 1985 il fut remplacé par le CPC 6128 qui était plus compact, plus soigné et surtout qui avait 128Ko de RAM au lieu de 64Ko.