Stocker le code d'une touche, dans une variable c++, à partir de code assembleur.

Version imprimable

Salut,
j'ai un code en assembleur qui lit les interruptions et qui et les convertit au caractère ASCII correspondant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
/*
 *	keyboard.s
 */
 
.text
.globl _keyboard_interrupt
 
/*
 * these are for the keyboard read functions
 */
size	= 1024		/* must be a power of two ! And MUST be the same
			   as in tty_io.c !!!! */
head = 4
tail = 8
proc_list = 12
buf = 16
 
mode:	.byte 0		/* caps, alt, ctrl and shift mode */
leds:	.byte 2		/* num-lock, caps, scroll-lock mode (nom-lock on) */
e0:	.byte 0
 
/*
 *  con_int is the real interrupt routine that reads the
 *  keyboard scan-code and converts it into the appropriate
 *  ascii character(s).
 */
_keyboard_interrupt:
	pushl %eax
	pushl %ebx
	pushl %ecx
	pushl %edx
	push %ds
	push %es
	movl $0x10,%eax
	mov %ax,%ds
	mov %ax,%es
	xorl %al,%al		/* %eax is scan code */
	inb $0x60,%al
	cmpb $0xe0,%al
	je set_e0
	cmpb $0xe1,%al
	je set_e1
	call key_table(,%eax,4)
	movb $0,e0
e0_e1:	inb $0x61,%al
	jmp 1f
1:	jmp 1f
1:	orb $0x80,%al
	jmp 1f
1:	jmp 1f
1:	outb %al,$0x61
	jmp 1f
1:	jmp 1f
1:	andb $0x7F,%al
	outb %al,$0x61
	movb $0x20,%al
	outb %al,$0x20
	pushl $0
	call _do_tty_interrupt
	addl $4,%esp
	pop %es
	pop %ds
	popl %edx
	popl %ecx
	popl %ebx
	popl %eax
	iret
set_e0:	movb $1,e0
	jmp e0_e1
set_e1:	movb $2,e0
	jmp e0_e1

Ce que je voudrais faire c'est récupérer cette touche dans cette fonction (en insérant le code assembleur dans le code c++.)

Code:

1
2
3
4
 
void FenClient::readKey() {
 
}

Quelqu'un sait t'il comment faire ?

Merci d'avance.

Bon j'ai essayé cela (pour récupérer l'interruption clavier) :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
void FenClient::readKey() {
    while(true){
        char kin;
        asm(
            "mov al, 16h;"
            "movb %%al, %0;"
            :"=r"(kin));
        printf("key : %c\n", kin);
    }
}

Mais il me dit Error : too many references for mov.

29/01/2016, 11h07
kolodz

Potentiellement le manque de \n
Sachant que le ; en assembleur n'indique pas la fin de ligne, mais le début d'un commentaire. Enfin de mémoire...
29/01/2016, 13h23
Invité
Ok j'ai essayé cela :
Code:

1 2 3 4 5 6 asm( "mov al, 16h \n" "movb %%al, %0" :"=r"(kin)); printf("key : %c\n", kin);
Mais, même message d'erreur. :/

Je ne m'y connais pas beaucoup en assembleur alors je cherche des tutoriels par ci par là mais pour l'instant je n'ai rien trouvé qui fonctionne sur ma machine pour ce que je souhaite faire. :/

J'ai un processeur intel core i5.
29/01/2016, 14h03
stendhal666

http://en.cppreference.com/w/cpp/language/asm

tu as consulté ça? Il semble que la syntaxe varie en fonction des compilateurs. Cependant la syntaxe gcc a l'air supportée par d'autres compilateurs et le lien donne deux exemples. Le séparateur de ligne semble être \n\t
29/01/2016, 15h02
ternel

Au passage, l'assembleur n'est pas portable d'un processeur à l'autre. Comme on a déjà du mal à mettre d'accord les compilateurs entre eux sur la norme...
29/01/2016, 15h28
Invité

Oui, je ne parviens pas à trouver un code assembleur compatible avec ma machine, tellement il y en a des différents.

Je n'ai bien sûr pas non plus le manuel de mon processeur pour la syntaxe du langage. (Et comme ça varie fort d'un processeur à l'autre et que on a du mal à ce mettre d'accord sur les normes hé bien...)
29/01/2016, 15h34
ternel

Et si ca venait de ce que ce n'est pas la bonne façon d'obtenir l'information?
29/01/2016, 17h27
bacelar

Heu, les gars, vous en connaissez encore beaucoup des de OS qui laissent les programmes utilisateurs faire des bidouilles avec les vecteurs interruptions ???
Moi pas, depuis le bon vieux DOS tout pourri.
Il sort de quel musée ce bout de code ???
29/01/2016, 18h46
Invité

Non ça n'existe plus ce genre d'OS en effet, on est toujours obligé de passer par la console du programme pour gérer les interruptions.

A moins de créer son propre OS ?

Mais c'est beaucoup plus de boulot.

Si je ne me trompe pas je devrais le faire en assembleur x86.
29/01/2016, 19h00
bacelar

Citation:

par la console du programme pour gérer les interruptions.

:question::question::question::question:

C'est quoi votre question, au bout du compte ???
29/01/2016, 20h01
Christophe

D'après le code asm, je pense que c'est pour appeler l'interruption BIOS int 0x16 en mode réel et je ne vois pas l'appel à l'int 0x16.

Par ailleurs:

Code:

mov al, 16h

ça c'est de la syntaxe Intel, en assembleur inline il faut utiliser la syntaxe at&t (même pour de l'assembleur x86) ce qui devrait donner quelque chose comme :

Code:

movb $16,%al

Je ne suis pas sûr à 100% de la syntaxe.

De plus stendhal666 a raison, il faut mettre des \n en fin de lignes, et il y a une codification pour le passage de paramètre entre la partie asm et C :
http://asm.developpez.com/cours/asminline/

Tu ne peux pas copier-coller du code assembleur sans le comprendre.

Tu pourras utiliser l'int 0x16 sous MS-DOS, mais sous Windows ou Linux c'est hors de question (comme l'a indiqué bacelar). Le processeur en mode protégé, la fonction BIOS int 0x16 sera inaccessible à moins de repasser temporairement en mode réel, ce qui est ni fait ni à faire et que l'OS t'interdira, on utilisera plutôt la fonction équivalente de l'OS.

Pourquoi ne pas utiliser getchar() ou un équivalent ?