CHAPITRE 2SAUTS, SOUS-PROGRAMME ET ETIQUETTES Peu de programmes réels se déroulent en une phase régulière et interrompue sans saut ou branchement en quelque étape. Ce chapitre traite de ces commandes de sauts et de leurs utilisations. Puis, le chapitre en vient à étudier les flags qui permettent à ces sauts d'être conditionnels et inconditionnels. les étiquettes symboliques sont également abordées. Celles-ci sont une caractéristique puissante et utile de l'assembleur et aident considérablement au développement des programmes. SAUTS INCONDITIONNELS Ceux-ci ordonnent au programme de sauter bon gré mal gré - pas de conditions. Le jeu d'instructions du Z80 contient cinq sauts de cette catégorie; pour le moment nous nous occuperons seulement de deux de ceux-ci. Les trois autres seront présentés plus loin. Le premier à prendre en considération est : JP nn Sauter (JumP) à l'adresse spécifiée nn Par exemple, JP 200 signifie de sauter à la case mémoire 200. Mis dans un programme JP se présente de la manière suivante : 
Figure 2.1 Utilisation de JP dans un programme Une telle routine de saut n'accomplit en fait pas grand chose, mais elle pourrait, par exemple, être utilisée pour imbriquer un peu de code dans un programme. En figure 2.1 par exemple, les commandes ' ADD A,1', 'CALL 47962' et 'JP 30005' on été effectivement insérées dans le programme. Nous allons maintenant taper ce programme sur l'ordinateur. N'oubliez pas de tapez ENTER à la fin de chaque ligne, et de sélectionner ' l'pour commencer à entrer un programme, et d'entrer 10 comme numéro de ligne de départ. Notez bien que la première ligne du programme n'est pas ENT. Etant donné que le programme saute à des cases mémoire spécifique, le départ exact du programme doit être connu. ORG 30000 fait que l'assembleur stocke le code machine en mémoire, en commençant à la case mémoire 30000. Reportez-vous à l'annexe 6 pour plus de détails. PROGRAMMES 2.1 ORG 30000
LD A,83
JP 30006
RET
ADD A,1
CALL 47962
JP 30005
Maintenant assemblez le programme avec l'option A, sélectionnez l'option 2.
L'affichage de l'écran du programme devrait ressembler à quelque chose comme ça : ------------------------------------------------
! CASE ! NUMERO ! CODE ! CODE !
! MÉMOIRE ! DE LIGNE ! OBJET ! SOURCE !
------------------------------------------------
! 7530 ! 10 ! ! ORG 30000 !
! 7530 ! 20 ! 3E53 ! LD A,83 !
! 7532 ! 30 ! C33675 ! JP 30006 !
! 7535 ! 40 ! C9 ! RET !
! 7536 ! 50 ! C601 ! ADD A,1 !
! 7538 ! 60 ! CD5ABB ! CALL 47962!
! 753B ! 70 ! C33575 ! JP 30005 !
------------------------------------------------FIGURE 2.2 Le premier nombre dans la colonne case mémoire semble ne pas correspondre à 30000, là où le programme devrait commencer. C'est parce que les cases mémoire sont représentées en hexadécimal. Ne vous en occupez pas pour le moment, rappelez-vous simplement que 30000 est 7530 en hexadécimal, 30006 est 7536 et 30005 est 7535. Quand des sauts sont utilisés de cette manière, il est nécessaire d'indiquer qu programme l'endroit où il doit sauter, soit une adresse, d'où JP 30006. Le calcul de ces adresses est tout ce qu'il y a de plus simple si on le fait systématiquement, comme nous le démontrerons plus loin. Observez la figure 2.2, les nombres et les lettres dans la deuxième colonne, le code objet, sont ce à quoi ressemble le langage assembleur après qu'il ait été assemblé - soit le code machine. Chaque paire de caractère alphanumériques (autrement dit de nombre et/ou de lettres) dans cette colonne représente une partie du langage assembleur initial. Ainsi, '3E' représente 'LD A' et '53' représente '83' (Ne vous demandez pas pour quelle raison! C'est en hexadécimal et nous l'expliquerons dans un chapitre ultérieur.) Pour les nombres en langage assembleur plus grands que 255, quatre alphanumériques - code machine sont requis. Ainsi, 'C3' représente 'JP' et '3075' représente '30000'. Comment cela peut-il nous aider à calculer les adresses auxquelles il faut sauter ? Hé bien, chaque paire de chiffre remplit une case mémoire - un octet de mémoire. Par conséquent, puisque l'ont sait que la première instruction du programme se trouve ne case mémoire 30000 (grâce à ORG 30000), il nous suffit de compter les paires d'alphanumérique - code machine. Par exemple, pour sauter à l'instruction ' ADD A,1', il nous faudrait sauter à la case mémoire contenant 'C6'. Donc, en commençant par 30000, qui contient '3E', nous avons 53, C3, 36, 75, C9, et puis C6. Il y a donc 6 cases mémoire à compter de 30000, c'est donc en 30006. Par conséquent le programme devra sauter à 30006. Il est convenu qu'avant d'entrer 30006 dans les instructions JP, ce ne sera pas à vous de calculer '3675'. Malgré cela, comme vous savez que l'adresse en code machine sera composée de quatre caractères (deux octets), cela ne vous posera pas de problème à condition d'écrire votre programme sur une feuille avant de le taper, - ce qui est une bonne méthode de toute façon. Les annexes contiennent des tables indiquant combien d'octets sont requis par chaque instruction, ce qui vous aidera à calculer les adresses de sauts. Voici une décomposition du programme: ORG ;N'utilise pas de mémoire, il est là pour être utilisé par l'assembleur, et ; on l'appelle une 'directive assembleur' LD A,83 Demande 2 octets - le premier est le code objet pour LD A, et le second est la ; donnée. JP 30006 Demande 3 octets - un pour son code objet, C3, les deux autres sont la case ; mémoire à laquelle il faut sauter. RET ;Ne demande qu'un octet pour son code objet, C9. ADD A,1 Demande 2 octets. Le premier, C6, est le code objet pour 'ADD A', et le second est la ; donnée. CALL 47962 Cette instruction demande 3 octets, CD est le code objet et 5A et BB la case mémoire ; qui est appelé. JP 30005 C'est la même chose que JP 30006, sauf que la case mémoire à laquelle il faut ; sauter est différente. En comptant le nombre d'octets nous pouvons calculer la longueur du programme: le programme 2.1 est long de 14 octets. En utilisant l'opérateur JP nous pouvons sauter dans toute case mémoire de 0 à 65535. Si la case mémoire à laquelle il faut sauter est située entre +129 ou -126 octets par rapport à la case mémoire actuelle, on peut utiliser le saut relatif au lieu de l'instruction de saut. L'avantage de cette instruction alternative est qu'elle est plus rapide, puisqu'elle utilise deux octets seulement en mémoire par opposition aux trois octets qu'utilise l'instruction JP. JR e Saut (JumP) relatif à l'adresse e Par exemple, si vous êtes à l'adresse 30000,et que vous voulez sauter à l'adresse 30045, vous écrirez JR 30045 Vous ne direz pas JR 39, l'ordinateur calculera automatiquement le décalage sur un octet. Notez bien que JR ne peut être utilisé que si vous sauter à une adresse allant de +129 ou -126 de la case mémoire contenant le 'JR' proprement dit. LE REGISTRE D'INSTRUCTION Avant d'aller plus loin, il faut observer la façon dont l'instruction de saut accomplit sa tâche. Observez la figure 2.2, on peut voir que le programme commence à la case mémoire 30000. Dans le corps du programme nous lui demanderons de sauter aux cases mémoires 30006 et 30005. Comment fait l'ordinateur pour repérer l'endroit où il se trouve? Dans le microprocesseur Z80 il y a un registre de 16 bits appelé le compteur de programme (Program Counter:PC). Ce registre contient l'adresse de l'instruction en cours. Lorsqu'un programme machine est lancé, le compteur de programme est fixé sur la première case mémoire du programme. Après exécution de la première instruction, le compteur de programme est mis à jour, de façon à ce qu'il pointe sur l'instruction suivante. Ainsi, une instruction de saut charge dans PC l'adresse à laquelle il faut sauter, autrement dit : il le pointe sur la nouvelle instruction. L'effet en est que le programme continue l'exécution à partir d'une instruction contenue dans la case mémoire sur laquelle l'adresse de saut était pointée. D'autres instructions sont disponibles pour modifier le contenu du PC et de ce fait modifient le cours du programme, nous vous les présenterons lorsque cela sera nécessaire. La figure 2.3 illustre l'exécution du programme précédent. ------------------------------------------
! programme ! PC avant ! PC après !
! ; ! exécution ! exécution !
!------------!------------!--------------!
! ORG 30000 ! ? ! 30000 !
! LD A,83 ! 30000 ! 30002 !
! JP 30006 ! 30002 ! 30006 !
! ADD A,1 ! 30006 ! 30008 !
! CALL 47962 ! 30008 ! 30011 !
! JP 30005 ! 30011 ! 30005 !
! RET ! 30005 ! Retour à !
! ; ! ; ! l'assembleur !
!------------!------------!--------------!Jusqu'ici l'ordinateur a sauté inconditionnellement à une autre section de code. Bien qu'utile, cela le serait encore plus si l'on pouvait faire sauter l'ordinateur si s'est vérifiée une certaine condition. On peut faire cela avec le groupe d'instruction de sauts conditionnels. SAUTS CONDITIONNEL Tout programme demandant un test de certaines conditions nécessite des sauts conditionnels. En BASIC, l'analogie est la commande IF...THEN. Soit: 10 IF X=Y THEN GOTO 500 Cette ligne fait que l'ordinateur compare les variables X et Y et si elles sont identiques il va à la ligne 500. Le Z80 accomplit cette opération en utilisant un registre spécial, le registre de flags. Le registre de flags est une registre de huit bits comme l'accumulateur et les registres B, C, D, E, H et L, mais il est utilisé tout différemment. Alors que les autres registres sont utilisés pour mémoriser et manipuler des octets, 3e registre de flags est traité comme s'il contenait huit bits individuels qui sont utilisés comme signaux ou flags. Le Z80 ne traite normalement qu'un flag a la fois, en fixant la valeur du bit soit à 0 soit a 1. Il peut également tester un flag pour déterminer s'il est mis (1) ou annulé (0). Par exemple un des flags est le flag 1 ou flag Zéro, Chaque fois qu'une opération arithmétique est réalisée et qu'elle produit un résultat de zéro, le flag zéro est mis a 1 - sinon il sera annulé à '0', indiquant ainsi que l'opération précédente n'a pas eu zéro pour résultat. De nombreuses autres instructions peuvent fixer ce flag, l'une d'elles étant; DEC d DECrémente le registre d Cette instruction décrémente le contenu de 'd'où 'd'est un des registres suivants: B,C,D,E,H,L,A Si après décrémentation du registre spécifié, le résultat est égal à zéro, alors le flag zéro est mis, ou sinon annulé. Notez que l'instruction DEC est appelée OPERATEUR, et d, l'OPERANDE; ainsi l'OPERATEUR travaille sur l'OPERANDE. Quelques OPERATEURS tels que LD A,10 demandent deux OPERANDES, ici, A et 10. Continuons la programmation. Le programme 2.2 affichera dix A sur l'écran. PROGRAMME 2.2 ORG 30000
LD C,10
LD A,65
CALL 47962
DEC C
JR NZ,30004
RETTapez ce programme et assemblez-le avec l'option A, puis l'option 2, Pour lancer le programme, revenez en BASIC avec X et tapez CALL 30000. Vous verrez dix A s'afficher sur l'écran. Pour revenir à l'assembleur appuyez sur la touche 'point décimal'du pavé numérique. Observons le programme, la seule ligne qui n'a pas été encore rencontrée est JR NZ. Cet opérateur teste l'état actuel du flag zéro et fait un saut relatif (Jumps Relative) à 30001 si la dernière instruction arithmétique a un résultat non-zéro. Ainsi le programme met le contenu de l'accumulateur sur l'écran, DECremente le registre C et vérifie si le flag zéro a été mis par l'instruction de DECrémentation. S'il ne l'a pas été, autrement dit si c'est Non Zéro, il fait alors un saut relatif a 30004, sinon il va à la ligne suivante du programme où il RETourne au programme principal (ici le Basic). JR NZ,e Saut relatif, si résultat Non Zéro, à l'adresse e EXERCICE 2.1 Réécrivez le Programme 2.2 pour utiliser le registre B à la place du registre C. Une réponse possible est donnée dans le chapitre solutions. EXERCICE 2.2 Pourquoi avons-nous utilisé JR NZ,e au lieu de l'instruction alternative JP NZ,e? La réponse de cet exercice se trouve dans le chapitre solutions. Remarque: comme on pouvait le Penser, une instruction pour INCrémenter un opérande existe également: INCrémenter l'opérande d Jusque la l'ordinateur a été programmé pour sauter inconditionnellement ou en cas de résultat zéro d'une opération. Dans les deux cas il est nécessaire de savoir à quelle case mémoire il faut sauter. Alors que ceci est possible pour des programmes courts, cela devient de plus en plus difficile de calculer ces adresses de sauts, sans parler du gaspillage de temps, lorsque la longueur des programmes s'accroît. Pour surmonter cela on utilise des étiquettes. ETIQUETTES L'utilisation des étiquettes permet au programme d'être dirigé sur une Instruction nommée, sans qu'il soit nécessaire de calculer les adresses de sauts. Un terme plus fantaisiste pour étiquette est ETIQUETTE SYMBOLIQUE, car l'étiquette elle-même est symbolique de la Position en mémoire. Par exemple, l'instruction JP LOOP: fera que l'assembleur remplacera LOOP (boucle) par une adresse, qui a été assignée auparavant à LOOP, chaque fois qu'il rencontrera cette étiquette. Pour dire à l'assembleur qu'une étiquette est une étiquette, Il est nécessaire de faire suivre l'étiquette d'un double point (:). D'autre part les étiquettes doivent être inférieures ou égales à six caractères, Ainsi, par exemple, si le programme devait sauter à la case mémoire contenant l'instruction DEC C, les lignes de programme suivantes seraient utilisées. .
.
JP LOOP
.
. LOOP : DEC C
.
. D'autres conventions doivent être observées lorsque l'on utilise les étiquettes. Le double point, par exemple, doit suivre le dernier caractère de l'étiquette (pas d'espace entre eux). D'autre part, un espace doit suivre le double point. C'est simplement pour permettre à l'assembleur de trouver où l'étiquette se termine. Ne vous tracassez pas si vous oubliez cela, l'assembleur repérera toute erreur et vous en informera. En résumé: ; ETIQUETTES 1 Une étiquette doit être constituée de 6 caractères au maximum, 2 Un double point doit immédiatement suivre l'étiquette. 3 Un espace doit suivre le double point. 4 L'étiquette ne doit pas contenir d'espace. Par exemple : LOOP: TEST: NXTCHR: sont des étiquettes correctes. Les suivantes ne le sont pas : LOOP : BACKONE: NEXT L: Pour illustrer l'utilisation des étiquettes, nous réécrirons le programme 2.1 en utilisant des étiquettes. Notez que la directive ENT peut être utilisée au lieu de la directive ORG , puisque aucun saut absolu n'est utilisé. PROGRAMME 2.3 ENT LD A, 83 JP NXT: END: RET NXT: ADD A,1 CALL 47962 JP END: Lorsque vous listez le programme ci-dessus, vous verrez qu'il est affiché avec les étiquettes sur la gauche du corps principal du programme, le rendant plus facile à lire, il se présente ainsi: ENT LD A,83 JP NXT: END: RET NXT: ADD A,1 CALL 47962 JP END Pour faciliter la frappe des programmes, ceux-ci seront présentés de cette manière tout au long du livre. Néanmoins, vous les taperez bien sur normalement. En utilisant les Instructions présentées Jusqu'ici, il est possible de sauter inconditionnellement ou conditionnellement à n'importe quel endroit de la mémoire, ou en utilisant une commande de saut relatif, à n'importe quelle adresse située entre +129 ou -126 de l'adresse actuelle. Des étiquettes peuvent également être utilisées pour faciliter le calcul des adresses de sauts. Toutes ces commandes seront désormais combinées pour afficher les nombres de un à neuf sur l'écran. Rappelez-vous, au chapitre 1 nous avons vu que le code ASCII pour T était 84. Bien, les nombres de un a neuf ont aussi un code. Regardez la table ASCII (dans le manuel BASIC appendice 3) et regardez si le code de 1 est bien 49 et celui de neuf est 57. Vous êtes d'accord? Maintenant combinez ce que l'on a appris jusque la pour résoudre le problème, c'est à dire; Comment mettre le contenu de l'accumulateur sur l'écran, le charger, et l'incrémenter. Et aussi, comment décrémenter un registre et tester si zéro. Si vous avez une idée pour amener l'ordinateur à afficher les nombres de 1 à 9 sur l'écran, fermez le livre et essayez; si vous n'en avez pas, ne vous tracassez pas nous expliquerons tout cela. L'organigramme suivant explique la solution: Problème : Afficher les nombres de 1 à 9 sur l'écran.  Traduit en un programme, cela donne : PROGRAMME 2.4 ENT ;Fixe le début du programme, LD C,9 Charger dans C le nombre de caractères à inscrire, soit 9, LD A,49 Charge dans A le code de "1", NXT: CALL 47962 Affiche le contenu de l'accumulateur sur l'écran, INC A Ajoute 1 au contenu de A, chargeant ainsi dans A le code de "2" DEC C Décrémente le registre d'instructions, JR NZ,NXT: Si DEC C a un résultat autre que zéro, faire un saut relatif à la case adressée ; Par l'étiquette NXT. RET ;Si C=0 alors retour a l'assembleur. Avant de le lancer, examinons-le étape par étape: ---------------------------------------------------
!Numéro ! Accumulateur ! Registre C ! Flag Z !
!d'étape ! ; ! ; ! ;!
---------------------------------------------------
! 1 ! 49 ! 9 ! 0 !
! 2 ! 50 ! 8 ! 0 !
! 3 ! 51 ! 7 ! 0 !
! 4 ! 52 ! 6 ! 0 !
! 5 ! 53 ! 5 ! 0 !
! 6 ! 54 ! 4 ! 0 !
! 7 ! 55 ! 3 ! 0 !
! 8 ! 56 ! 2 ! 0 !
! 9 ! 57 ! 1 ! 0 !
! 10 ! 58 ! 0 ! 1 !
----------------------------------------------------le flag Z est mis (1)le programme se termine et revient à l'assembleur, (Etape 10) Maintenant assemblez et lancez le programme. EXERCICE 2.3 Ecrivez un programme qui inscrira l'alphabet sur l'écran. (Pour vous aider, sachez que le code de A est 65). Une réponse possible est donnée au chapitre solutions. Jusque là, seul le flag zéro, un des 9 flags possibles, a été utilisé. Voici les autres. LES FLAGS Le flag de retenue (Carry Flag (C)) Ce flag est mis lorsque une addition ou une soustraction a pour résultat une retenue. Il est aussi utilisé dans certaines instructions de décalage et de rotation. Flag de soustraction (N) Ce flag est plutôt utilisé par le Z80 que par des programmes pour certaines opérations arithmétiques. Flag de Parité/Dépassement (P/V) Ce flag a deux fonctions distinctes, la première pour indiquer la parité d'un résultat. La "parité" du résultat est obtenue en ajoutant tous les Uns de sa représentation binaire. Si le résultat est pair alors la parité est mise, sinon elles est annulée, c'est à dire = 0. Le flag est également mis lorsque des dépassements se produisent lors de certaines opérations arithmétiques. Le flag de demi-retenue (H) Le flag de demi-retenue est utilisé par le Z80 pour des Instructions "Décimales Codées en Binaires", Ne vous en occupez pas pour le moment. Le flag Zéro (Z) Le flag zéro est mis lorsque une opération a pour résultat zéro, et en tant que tel, est utilisé très souvent pour des comparaisons. Le flag Signe (S) Ce flag indique le signe du résultat arithmétique ou d'un octet qui est transmis. Fondamentalement, il teste le bit 7 d'un octet, et il est mis s'il est égal a un et annulé dans l'autre cas. SOUS-PROGRAMMES De même que nous avons comparé l'Instruction JP avec l'instruction BASIC IF X=Y THEN 500, il existe une instruction Z80 similaire à l'instruction BASIC GOSUB 500. Cette instruction, CALL, a déjà été utilisée pour inscrire le contenu de l'accumulateur sur l'écran. CALL nn Appel (CALL) de la routine commençant à l'adresse mémoire nn ; (nn peut être représenté par une étiquette). Comme en BASIC, une instruction de retour (return) est requise a la fin du sous-programme. RET ; Retour du sous-programme appelé en dernier. Voyons comment ces instructions peuvent être utilisées dans un programme. Problème : Inscrire sur l'écran les caractères ASCII de 200 a 250, en utilisant un sous-programme 'imprimer les caractères'. PROGRAMME 2.5 ; ENT ; LD A,200 A= 1er code ASCII ; LD B,50 ;B= compte NXT: CALL PRINT: Appel routine d'impression ; DEC B ;Décrémenter le compte ; INC A ;Code ASCII suivant ; JR NZ,NXT: Si B=0 sauter a NXT ; RET PRINT: CALL 47962 ; RET Assemblez-le puis lancez-le. Pour aider à la compréhension du programme l'étiquette PRINT a été assignée au sous-programme d'impression. Outre les appels inconditionnels il existe des appels conditionnels, de même qu'il y a des sauts conditionnels et inconditionnels. CALL cc,nn ; Appel du sous-programme commençant à l'adresse mémoire nn, si la condition ce est remplie. Les conditions oui font que la routine est appelée sont exactement les mêmes que celles utilisées pour des sauts conditionnels. Lorsqu'une instruction CALL est exécutée, le contenu actuel du registre d'instructions est sauvegardé. Le registre d'instructions reçoit alors l'adresse d'appel nn, Quand le Z80 a terminé le sous-programme, c'est à dire a atteint une instruction RET, le registre d'instructions reçoit la valeur sauvegardée du registre d'instructions. Problème : Afficher 100 "A" sur l'écran, mais afficher un espace pour chaque dizaine de A affichée. Problème : Inscrire sur l'écran les caractères ASCII de 200 à 250, en utilisant un sous-programme 'imprimer les caractères'. PROGRAMME 2.5 ; ENT ; LD A,200 A= 1er code ASCII ; LD B,50 ;B= compte NXT: CALL PRINT: Appel routine d'Impression ; DEC B ;Décrémenter le compte ; INC A ;Code ASCII suivant ; JR NZ,NXT: Si B=0 sauter à NXT ; RET ; CALL 47962 ; RET Assemblez-le puis lancez-le. Pour aider à la compréhension du programme l'étiquette PRINT a été assignée au sous-programme d'impression. Outre les appels inconditionnels il existe des appels conditionnels, de même qu'il y a des sauts conditionnels et inconditionnels. CALL cc,nn Appel du sous-programme commençant à l'adresse mémoire nn, ; si la condition ce est remplie. Les conditions qui font que la routine est appelée sont exactement les mêmes que celles utilisées pour des sauts conditionnels. Lorsqu'une instruction CALL est exécutée, le contenu actuel du registre d'instructions est sauvegardé. Le registre d'instructions reçoit alors l'adresse d'appel nn. Quand le Z80 a terminé le sous-programme, c'est à dire a atteint une instruction RET, le registre d'instructions reçoit la valeur sauvegardée du registre d'instructions. Problème Afficher 100 "A" sur l'écran, mais afficher un espace pour ; chaque dizaine de A affichée. Représentation de la solution d'un organigramme :  Figure 2.5 Conversion en programme : ; ENT
; LD C,100 C= 1er compte
; LD B,10 ;B= 2ème compte
; LD A,65 ;A= "A"
NXT: CALL 47962 Affiche un 'A'
; DEC B
; CALL Z,PSPC Si B=0 afficher un espace
; DEC C
; JR NZ,NXT: 100 'A' sont affichés? Si non, sauter à l'espace
; suivant (NXT).
; RET ; Retour a l'assembleur
PSPC: LD A,32 ;A=ASCII pour un espace.
; CALL 47962 Afficher un espace
; LD A,65 ;A="A"
; LD B,10 ;Recharger B comme compte
; RET ; Retour au programme principalEssayez maintenant de lancer le programme et voilà, une centaine de A apparaissent sur l'écran séparés tous les 10 par un espace. Cette forme d'appel conditionnel est très pratique car elle facilite considérablement récriture de programmes structurés. RESUME Le compteur de programme (PC) est un registre de 16 bits, contenant l'adresse mémoire de l'instruction en cours à l'intérieur du programme. Le registre de flags contient 8 bits, qui reflètent l'état de la section arithmétique du Z80. Des étiquettes peuvent être utilisées dans les Instructions de saut. Une étiquette doit contenir moins de sept caractères, et être terminée par un double point immédiatement suivi par un espace. Il existe deux formes principales de sauts, conditionnelle et inconditionnelle. Ces deux formes peuvent être encore divisées chacune en sauts absolus, c'est a dire, JP NXT ou sauts relatifs: JR NXT. Deux types d'appel de sous-programmes (CALL) existent, conditionnel et inconditionnel. Toute instruction d'appel doit être associée à une instruction RET. Il existe deux formes principales de sauts, conditionnelle et inconditionnelle. Ces deux formes peuvent être encore divisées en sauts absolus, c'est à dire, JP NXT ou saut relatif :JR NXT. Deux types d'appel (CALL) existent, conditionnel et inconditionnel. Toute instruction d'appel doit être associée à une instruction RET. Dans un contexte, vous comprendrez la liste suivante d'instructions, même si vous ne comprenez pas tout a fait les conditions de flag. JP nn JP cc,nn JR e JR Z,e JR NZ,e nn est une adresse absolue ou une étiquette ce est l'un des opérandes indiquant quel flag doit être testé est une adresse absolue, sauf qu'elle est limitée à -126 ou +129 octets à partir de l'adresse en cours. Une étiquette peut également être utilisée. ce condition NZ Non-Zéro Z Zéro NC Pas de retenue C Retenue PO Parité impaire PE Parité paire P Positif M Négatif Et aussi : INC r DEC r Où r est un registre de 8 bits parmi ceux-ci: B,C,D,E,H,L,A. On peut mieux définir opérande et opérateur en utilisant un exemple: LD ;A,83----------
! ; ! ; !
------------ -------------- !
! opérateur! ! opérande 1 ! !
------------ -------------- !
; --------------
; ! opérande 2 !
; --------------CPCrulez[Content Management System] v8.7-desktop/c
Page créée en 181 millisecondes et consultée 2591 foisL'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. |
| 
