★ CODING ★ CLASSEURS WEKA ★ Comment exploiter toutes les ressources et augmenter les performances de votre AMSTRAD CPC ★

4/1.6.4 - Utilisation des vecteurs du système d'exploitation sous Basic (14e Complément)Coding Classeurs Weka
4/0 - Langages du CPC

4/1.6 - Basic approfondi

4/1.6.4 Utilisation des vecteurs du système d'exploitation sous Basic

I. Présentation

Dans les entrailles de la mémoire RAM des AMSTRAD CPC se trouvent des points d'accès à des routines intéressantes du moniteur du système d'exploitation.

Les points d'accès (appelés points d'entrée ou encore vecteurs) sont situés à partir de l'adresse &BBOO et sont composés de sauts aux adresses de traitement dans la ROM moniteur. Vous trouverez en partie 4, chapitre 2.7, page 1 et suivantes, la liste détaillée de ces vecteurs, de leurs conditions d'appel et des résultats en sortie de la routine.

Les programmeurs confirmés en langage d'assemblage utilisent en général ces vecteurs, ce qui leur évite de réécrire des routines complètes assurant la même fonction.

Le programmeur en Basic, hésitant à utiliser l'Assembleur et son rebutant code machine, se sent quelque peu frustré à l'idée d'être privé de l'accès à ces vecteurs. Bien sûr, certains sont accessibles directement à partir du Basic, par exemple la commande souvent utilisée : CALL &BB06 rend un grand service en économisant les lignes de programme suivantes :

10 A$ = inkey$
20 IF A$ = " " THEN GOTO 10

gourmandes en mémoire. Mais les vecteurs de ce type sont rares et ne permettent pas une utilisation complète de leurs possibilités.

Si vous étudiez les caractéristiques de cette routine (voir Partie 4, chapitre 2.7, page 1 ), vous pourrez remarquer que le code du caractère frappé se trouve sauvegardé dans le registre A au retour, mais celui-ci est inaccessible sous Basic.

De même, la routine SCR-SW-ROLL à l'adresse &BC50 (voir Partie 4, chapitre 2.7, page 38) permet d'effectuer un scrolling vertical haut ou bas d'une partie de l'écran, mais nécessite les coordonnées de la fenêtre à déplacer dans les registres D, E, H, L du Z80, ainsi que le sens dans le registre A: encore une fois impossible avec le Basic LOCOMOTIVE.

Votre ouvrage Comment exploiter les ressources de votre AMSTRAD vous apporte maintenant une solution à la fois pratique et facile à retenir pour résoudre ce problème sous Basic. Si vous ne vous laissez pas abuser par un premier abord d'utilisation relativement lourde, et lisez attentivement les conseils de programmation, vous tirerez un très grand profit de cette nouvelle possibilité.

La solution retenue, afin de conserver à cette possibilité un lien avec l'Assembleur, est de créer une nouvelle instruction RSX possédant une syntaxe quasiment identique à l'instruction CALL.

Cette nouvelle instruction sera appelée ùCALL (le caractère ù, est la barre verticale ou le caractère u accentué, selon les modèles, et se trouvent sur le caractère arobas ou a accentué), et servira à passer tous les paramètres nécessaires.

La commande aura la forme suivante :

ùCALL,adresse,àa%,àF%,àB%,àC%,àD%,àE%,àH%,àL%

adresse = adresse du vecteur appelé

àA% = pointeur de la variable A%, qui sera assimilée au registre accumulateur.

àF% = pointeur de la variable B%, qui sera assimilée au registre de drapeau (ou flags). Ce registre permet de connaître certains résultats, nous en parlerons plus loin.

àB% = pointeur de la variable B%, qui sera assimilée au registre B.

De même pour àC%, àD%, àE%, àH%, àL% et les registres C, D, E, H et L.

Il est vrai que cette instruction est au premier abord lourde à frapper, mais si vous la situez dans une ligne de sous-programme, vous n'aurez à la frapper qu'une fois pour toute, et y faire appel quand vous le désirez.

Comme vous pouvez le remarquer, les registres affectés du Z80 sont remplacés ici par des variables portant un nom identique, et accompagnées du symbole % pour une gestion plus simple au niveau du programme Assembleur.

II. Le programme Assembleur

Afin de créer cette nouvelle instruction, il nous faut, hélas, utiliser le code machine. Le programme a donc été développé sous Assembleur, et ce paragraphe permettra au programmeur en langage machine de comprendre son fonctionnement.

Ceux qui ne sont pas intéressés par la programmation en Assembleur pourront passer directement au paragraphe suivant, décrivant le chargeur Basic permettant l'utilisation de l'instruction.

Le principe

Il faut savoir que lors de l'exécution d'une instruction ajoutée au Basic (RSX), dès l'entrée dans la routine en langage machine, les paramètres l'accompagnant sont empilés dans une pile spéciale, appelée PILE PARAMETRE, pointée par le registre d'index IX (initialement positionné à la valeur &BFFF). Le nombre de paramètres transmis est sauvegardé automatiquement dans le registre A.

L'organisation de la pile, suite à notre instruction, vous est donnée par le tableau 1.

Tableau 1 : Organisation de la pile paramètre après l'instruction

CALL,&adresse,@A%,@F%,@B%,@C%,@D%,@E%,@H%,@L%

Pile paramètre

IX+&11

Adresse haute

Adresse de la routine

IX+&10

Adresse basse

IX+&0F

Adresse A% haut

Registre A

IX+&0E

Adresse A% bas

IX+&0D

Adresse F% haut

Registre flags

IX+&0C

Adresse F% bas

IX+&0B

Adresse B% haut

Registre B

IX+&0A

Adresse B% bas

IX+&09

Adresse C% haut

Registre C

IX+&08

Adresse C% bas

IX+&07

Adresse D% haut

Registre D

IX+&06

Adresse D% bas

IX+&05

Adresse E% haut

Registre E

IX+&04

Adresse E% bas

IX+&03

Adresse H% haut

Registre H

IX+&02

Adresse H% bas

IX+&01

Adresse L% haut

Registre L

IX+&00

Adresse L% bas

Le principe consistera donc, dans l'ordre, à :

— récupérer les paramètres affectant les registres,
— récupérer et placer l'adresse de saut au vecteur,
— effectuer le saut avec les registres positionnés,
— récupérer les paramètres rendus par la routine,
— retourner au Basic.

L'organigramme

(Organigrammes pages 5 et 6)

On remarquera la sauvegarde provisoire des paramètres dans la pile système, car les registres sont momentanément utilisés pour le traitement.

L'adresse est récupérée et placée en mémoire juste après le code d'une instruction CALL.

Les registres sont dépilés juste avant d'effectuer le saut.

Au retour de la routine, on empile à nouveau les registres pour les récupérer un à un et les réaffecter dans les variables grâce aux pointeurs transmis.

On remarquera aussi la remise à sa valeur initiale de la valeur du point IX de la pile paramètre (ayant été incrémenté &11 fois, il faut lui retirer ensuite cette valeur — nous verrons dans le programme comment retirer ce nombre au registre HL).

LE PROGRAMME ASSEMBLEUR

Voici le programme Assembleur accompagné de larges commentaires pour en faciliter la compréhension.



Commentaires :

— Lignes 31 à 33 : le code &C9 (RET) est placé au début de la routine d'installation pour éviter une nouvelle installation, qui provoquerait une erreur.
— Ligne 65 : chacun des registres, ayant été assemblé sous forme de registre double (AF, BC, DE, HL) dans le registre DE, celui-ci est empilé (4 fois donc).
— Lignes 69 à 73 : l'adresse de saut récupérée dans la pile paramètre est sauvegardée juste après le code &CD (CALL) en lignes 87 à 89.
— Ligne 77 : il fallait retirer le nombre hexadécimal &0011 au registre HL pour restaurer le registre IX (étudiez le passage par la pile SP pour l'échange), nous allons en fait utiliser l'opération inverse, c'est-à-dire l'addition, mais cette fois-ci du complément à deux de ce nombre (le complément à deux d'un nombre est un nombre tel que les deux nombres ajoutés, on obtienne zéro, sans tenir compte de la retenue. De plus, le complément à deux d'un nombre s'effectue dans un format donné, ici sur deux octets). Le nombre que nous devons ajouter aura donc la valeur &FFEF.

Les lignes suivant le saut ne devraient pas poser de problème de compréhension, celles-ci reproduisant en fait le phénomène inverse pour redonner aux variables leurs nouvelles valeurs.

Utilisation

Après assemblage, le programme sera sauvegardé sur support entre les adresses &A000 et &A082.

Pour l'utiliser, il suffira, après chargement, de frapper la commande CALL &A000 et la nouvelle instruction

ùCALL,adresse,àA%,àF%,àB%,àC%,àD%,àE%,àH%,àL%

sera initialisée. On n'oubliera pas de réserver la mémoire par un MEMORY &9FFF, afin d'empêcher d'éventuel débordement de variables dans cette zone.

III. Le chargeur Basic

Nous vous proposons ci-après le programme permettant sous Basic de charger les codes de la routine assembleur.


Après chargement et sauvegarde, vous pourrez initialiser la routine en frappant les commandes suivantes :

MEMORY &9FFF CALL &A000

A partir de ce moment, l'instruction

ùCALL,adresse,àA%,àF%,àB%,àC%/àD%,àE%,àH%,àL%

est disponible.

Remarque :

Prenez soin de ne pas oublier la virgule juste après l'instruction ùCALL, sous peine de risquer un plantage lors de l'appel de certains vecteurs.
Conseils d utilisation

Afin de passer les pointeurs de variables à l'instruction sous Basic, il faut en premier lieu, les définir, ce qui implique que votre programme devra comporter, à son tout début, l'affectation de valeur à ces variables, par exemple :

10 A% = 0 : F% = 0 : B% = 0 : C% = 0 20 D% = 0 : E% = 0 : H% = 0 : L% = 0

Nous vous conseillons aussi de placer la nouvelle instruction en fin du programme principal, pour ne pas avoir à la réécrire à chaque utilisation, par exemple :

60000 REM *** SOUS-PROGRAMME ùCALL ***
60010 ùCALL,adresse,àA%,àF%/àB%,àC%,àD%,àE%,àH%,àL% 60020 RETURN

Ainsi, il vous suffira d'affecter les variables nécessaires aux registres selon les valeurs requises lors de l'appel du vecteur, dans votre programme principal, puis d'effectuer un saut au sous-programme, vous pourrez ensuite traiter les différents paramètres rendus.

Les variables non utilisées ne seront pas obligatoirement affectées, mais

Il est obligatoire de spécifier tous les paramètres dans l'instruction ùCALL...

Exemples d utilisations

Nous vous proposons d'abord un programme permettant d'expérimenter les routines qui vous semblent intéressantes avant de les inclure dans un programme.

Signalons d'abord que certains vecteurs ne vous apporteront aucun effet visible sous Basic, car lorsque vous êtes sous l'interpréteur Basic, le moniteur effectue les remises à jour de différents paramètres périodiquement (tous les 1/300® ou 1/50* de secondes). Par exemple le curseur est affecté, ce qui implique qu'il vous sera impossible de l'allumer ou de l'éteindre à volonté.


En reprenant le programme d'expérimentation, il vous suffira de modifier les différents paramètres en ligne 130 et l'adresse du vecteur en ligne 60010.

Le programme vous permet de visualiser après exécution, la valeur décimale, hexadécimale et binaire des différents registres retournés.

L'état binaire est surtout important pour le registre de flags F%, dont les indicateurs (C, Z, S, ...) sont repris au dessous. Voici l'organisation des différents flags dans le registre F% :

S Z NU H NU P/V N C

NU signifiant Non Utilisé.

ùCALL,&BB06

Modifiez la ligne 60010 par

ùCALL,&BB06,àA%,àF%,àB%,àC%,àD%,àE%,àH%,àL%

Après exécution, frappez une touche alphabétique, puis la commande PRINT CHR$(A%), et vous afficherez le caractère frappé.

ùCALL,&BB50,...

Cette routine permet d'effectuer un scrolling d'une partie de l'écran, aussi bien vers le haut que vers le bas.

Les différents registres de la ligne 130 à affecter sont H% pour la première colonne, D% pour la deuxième colonne, L% pour la première ligne, E% pour la deuxième ligne, et B% pour le sens haut ou bas. Vous placerez en ligne 60010 l'adresse &BC50 au lieu de &BB06, ainsi que l'instruction STOP en ligne 175 pour éviter l'affichage des variables.

Après un RUN sur un écran rempli de caractères, vous pourrez observer la zone déplacée.

Bien d'autres utilisations sont encore possibles, les vecteurs sont nombreux, depuis la gestion des unités de cassettes ou disquettes, des fonctions graphiques, et de la gestion des imprimantes (essayez le vecteur en &BD2E, voir Partie 4, Chap. 2.7, page 62), souvenez-vous seulement que certains vecteurs n'auront pas d'effet apparent, à cause de la remise en ordre effectuée par l'interpréteur Basic, et là, seul le langage machine est le dernier recours.

Page précédente : 4/1.6.3 - La gestion des variables dans les Amstrad CPC
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.7-desktop
Page créée en 107 millisecondes et consultée 326 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.