Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : C - Console.device
(Article écrit par Max et extrait d'Amiga News Tech - mars 1991)
|
|
Le port IDCMP (Intuition Direct Communication Message Port) de toute fenêtre Intuition
est un moyen simple mais pas très efficace de recevoir des caractères en provenance du clavier
et d'en écrire dans ladite fenêtre.
En effet, le drapeau "RAWKEY" ne renvoie que les codes clavier des touches, nous obligeant pour
la conversion en ASCII à l'emploi de tables minimisant la compatibilité internationale du programme,
et le drapeau "VANILLAKEY" renvoie bien le code ASCII, mais oublie au passage de prendre en compte
les touches spéciales telles que F1-F10 ou encore Help. La seule solution lorsque l'on désire traiter
la console avec tous les égards qu'elle mérite consiste donc à utiliser le périphérique logique qui lui est dédié,
autrement dit le console.device.
Device ? Vous avez dit "device" ?
Avant tout, un bref rappel de ce qu'est un périphérique logique (device) semble s'imposer. Un périphérique logique a la même structure qu'une
bibliothèque : il est composé d'un bloc de données et d'un bloc de sauts à des routines internes.
Vous trouverez la définition de la structure Device dans le fichier "exec/devices.h"
pour les programmeurs en C, et "exec/devices.i" pour les 68000eurs.
Pour communiquer avec un quelconque périphérique logique, on utilise une autre structure définie dans "exec/io.h"
(resp. "exec/io.i") :
Il est à noter que certains périphériques logiques utilisent des structures IO étendues : c'est le cas du trackdisk.device
par exemple, qui utilise une structure nommée IOExtTD et définie dans "devices/trackdisk.h".
La structure Message est celle qui permet au périphérique logique de communiquer avec la tâche qui l'a ouvert.
La première étape à l'ouverture d'un périphérique logique est donc la création d'un "message port". La fonction
CreatePort() de l'Amiga.lib fait ça très bien pour nous :
Ce qui donne en assembleur :
Il ne faudra pas oublier de détruire ce port une fois qu'on n'en aura plus besoin :
La seconde étape consiste à initialiser correctement une structure IOStdReq - ou une structure IO
étendue pour les périphériques logiques en utilisant une - ce qui se fait au moyen de la fonction CreateExtIO()
d'amiga_lib :
Cette structure devra elle aussi être éliminée lorsqu'on n'en aura plus besoin :
Ce n'est qu'alors que l'on pourra appeler la fonction OpenDevice() d'exec.library :
- nom.du.device décrit devinez quoi ? Le nom du périphérique logique que l'on veut ouvrir, oui. Ce peut être "trackdisk_device",
"console.device", "keyboard.device", etc.
- unit désigne l'unité concernée. Par exemple, le trackdisk.device contrôle quatre unités, à savoir
DF0: à DF3:. Le keyboard.device, lui, n'en contrôle qu'une (et pour cause : l'Amiga ne possède qu'un seul clavier !).
Dans le cas du console.device, l'unité pourra être 0 ou -1.
- request est le pointeur sur la structure IOStdReq - ou bien, encore une fois, sur une structure IO étendue
- créée plus tôt.
- flags sera les trois quarts du temps mis à 0.
Console !
"Le terme "console" désigne en informatique le ou les périphérique(s) destiné(s) au dialogue homme/machine,
généralement le clavier pour les entrées et l'écran pour les sorties" (Petit Robert, édition 1991).
Le console.device permet donc la saisie de caractères depuis le clavier et leur édition à l'écran, plus
précisément dans une fenêtre Intuition - car n'oublions pas que toute fenêtre est créée et gérée par Intuition,
même les CON:, RAW: et autres NEWCON:.
Un programme peut désirer ne prendre connaissance que des entrées et effectuer les sorties lui-même au travers
de la graphics.library et de la fonction Text(). C'est le cas de ProWrite ou de GenAm2, l'éditeur du Devpac,
par exemple. Dans ce cas, on ouvre l'unité -1. Mais il est également possible de laisser le console.device
éditer le texte dans la fenêtre. Dans ce dernier cas, il faudra initialiser deux structures IOStdReq et deux
message-ports, un pour chaque sens de la communication.
Pour lire le console.device :
Pour écrire dans le console.device :
On ouvre ensuite la fenêtre, puis le console.device lui-même :
Pour terminer, on relie les deux requêtes ensemble sur le même périphérique logique :
Partant de là, on peut commencer la lecture le port "readPort" et l'écriture sur le port "writePort".
Opérations d'entrées/sorties
Quel que soit le périphérique logique concerné, deux types d'échanges sont possibles : d'une part l'échange "synchrone"
(le périphérique logique ne rend la main qu'une fois sa mission accomplie) et d'autre part l'échange "asynchrone" (le
périphérique logique travaille parallèlement au programme, en multitâche). Cette dernière possibilité est particulièrement
utile lorsque, par exemple, on veut animer une présentation à l'écran tout en chargeant des données depuis
le disque. La tâche incombe toutefois au programme de se renseigner auprès du périphérique logique s'il a terminé son
travail.
Pour en revenir au console.device, il est préférable d'effectuer les sorties (c'est-à-dire l'édition de caractères)
en mode synchrone. Les entrées (lecture de caractère(s) en provenance du clavier) peuvent être faites en
n'importe quel mode, suivant que l'on désire attendre un caractère ou simplement le lire "au vol".
Dans ce dernier cas, il faudra déjà avoir lancé une requête asynchrone de façon à pouvoir examiner le port.
Les fonctions C suivantes peuvent être utilisées :
Lancement d'une requête asynchrone :
Lecture "au vol" d'un caractère (sans attente retourne -1 si aucun caractère n'a été frappé) :
Lecture d'un caractère (avec attente) :
Écriture d'un caractère sur la console :
Écriture d'une chaîne de caractères (terminée par un "\0") :
Écriture d'un tampon mémoire de "lenght" caractères sur la console :
A suivre...
Voilà. La deuxième et dernière partie de cet article traitera des commandes particulières du
console.device, mais en attendant, je vous propose un petit programme de démonstration très largement
inspiré de l'exemple publié dans les RKM.
Mise à jour d'août 2020 : une version en texte et adaptée à
VBCC a été réalisée par Yann-Gaël Guéhéneuc et est disponible sur
obligement.free.fr/files/antconsoledevice1.lha.
|
