Tableaux - Page 1

Bonjour,
Je recherche de la doc sur les tableaux en asm.
J'ai déjà lu Zguide et j'aimerai savoir où je peut trouver une autre doc. (ou alors vous m'expliquez ce que je comprend pas!!)
C pas très dur je pense mais ya qqs points de détails que je trouve obscurs...

Bon je t'explike:

tout d'abord il faudra pointé un registre d'adresse sur ton tableau exemple pour pouvoir se déplacé!

ensuite il te faut ton x et ton y pour la variable rechercé ou valeur,et surtout la dimensuion d'une ligne et la taille des données (octet,word,l.word!).

Voici un exemple:
je veus mettre le nombre se trouvant à tab[1,1]

;je peus faire!

move.w #1,d0 ;X
move.w #1,d1 ;Y
sub.w #1,d0
sub.w #1,d1
;Comme le tableau commence à [0,0] et non à tab[1,]
lea table(pc),a0 ;je charge mon tableau dans a0 =>a0 pointe sur le tableau!

;Calcul du nombre d'octet à ajouté!
mulu.w #5,d1 ;pour me mettre sur la bonne ligne
mulu.w #2,d0 ;je multplie par 2 car j'ai des doubles octets soit des words!
add.w d0,d1 ;je calcule enfin le nombre d'octets à ajouté!
clr.w d3
move.w 0(a0,d0.w),d3 ;je mets dans d3 ce que je recherchais!
;et voilà j'ai dans d3 ce que je recherchais normalement!

Si tu ne comprend pas ce que je viens d'expliké et tu ne piges pas le ZGuide alors là c'est que tu ne piges rien du tout à l'assembleur bien que le ZGuide me semble t'il que ça routine est buggé!

;mais comme je suis newbie comme toi il se peut que j'ai vraiment mal expliké mais j'ai fait ce que j'ai pu!

@+

si tu n'as rien compris a ce que dit zlk (encore KEKEBOSS ?), ne t'en fait pas ...

En fait l'idée est toute simple, il s'agit de calculer l'adresse d'un element dans le tableau.
Pour ca il te faut: la largeur du tableau (Xmax), la taille d'un element du tableau (size), l'adresse de depart du tableau (tab), et bien sur les coordonnées de l'element que tu charche (X et Y...
Pour plus d'efficaté, notre tableu ira de tab[0][0] à tab[Xmax-1][Ymax-1].

En suite tu multiplie simplement Y par Xmax et par size et tu ajoute ca a tab pour avoir le debut de la ligne, puis tu ajoute encore Y*size, pour avoir ton elemnt dans la ligne ...

Et voila !

Pour l'implementation, je te laisse faire les traveau pratiques, c'est pas tres dur ...

que dire de plus ?

Je ne sais pas!

Dark Angel planté mon gars c'est pas moi!

Mais t'es pas loin!

elephant boy...

Bon, je revient à la charge!!!
En effet, je n'était pas là hier.
Bon, merci Dark Angel, mais c bon tous cela j'avais compris. C'était juste des détails. Tout d'abord à quoi sert le 0 quand il remplit ou vide son tableau:
move.w #xxx,0(d0,a0)
Cela veut dire qu'il commence à 0,0, et si on met un move.w #xxx,1(d0,a0) il commencera ligne 1 et colonne 1????

Bon, voici mon véritable pb. Par quoi on multiplie pour avoir la taille (dans zguide il multiplie par 2 pour des mots donc je suppose que c'est:
- *1 pour ds.b
- *2 pour ds.w
- *4 pour ds.l

Sinon, il fait un décallage dans son exemple. C plus rapide???
Merci de vos future réponse et excusez moi de mon ignorance

Bon, je pense que pour les multiplicateur, je me suis pas trompé!!
Mais personne veut m'expliquer le coup du 0(x,x)??

N(x,y) <=> a N + x + y
C tout.
-128 < N < 127

C'est parceque le 68000 ne supporte pas le mode d'adresse (an,dn), seulement x(an,dn) ...

l'adresse 0(an,dn) parmet d'avoir l'adresse an+dn, sans avoir a faire l'addition ... (regarde dans zguide, il y a une artie sur les mode d'adressage)

Le nombre avant la parenthèse ajoute un nombre d'octet a l'adresse.

Exemple si je veus effacé l'octet placé à la ligne numéroté 1 de mon ecran et pointé sur le deuxieme octet.

Je peus faire:
move.l #$4c00 ;depart de l'ecran <=>a0 pointe sur l'ecran!
move.b #2,d0
comme une ligne fait 30 octets
clr.b 30*1(a0,d0.b) ;voilà c'est fait!
Mais on pouvait faire aussi!

lea 32(a0),a0
clr.b (a0)

C bon, G compris
Mais g un autre pb.
On dirait qu'il veut lire que les colonnes paires: 0 2 4 6
des que je suis censé aller sur une impaire : adress error puis toutes les ribambelles d'erreurs.
Si qqn sait d'où cela vient, je suis interressé d'autant que je veut sortir un beta rapidement. (même si c'est un projet plutot modeste)

C'est parceke t'es placé à une adresse impair!
Certainement parceque tu fais un move.w ou un move.l à une adresse impair ce qui est pas possible à moins de faire move.b

Mais ça dépend de ce que tu as ds le tableau!

Mais...Si tu as bien compris ce qu'on t'as dit la haut tu ne devrais pas avoir ce genre de probleme!

C bon c résolu!!!
Je faisait un move.w dans un tableau en ds.b
Maintenant ca va marcher!!!

Tu peus faire un move.w ds un tableau en ds.b cela ne pose point de probème sauf si t'es placé à une adresse impair!

Au fait si je fais:
clr.l d1
clr.l d0
move.w #$FEFF,d0
move.w d0,d1

le Motorolla va le codé comment
l'octet de poid fort ou l'octet de poid faible d'abord ?

qu'est ce que j'aurais dans le d0.b

$FE ou $FF?

comme c'est du big indian, cela doit être
d0.w $FEFF
D1.w $FEFE
donc :
d0.b=$FE

J'epère que c'est bon

Eh ben oui!
j'ai vérifié ds le ZGuide!

ZGuide Ruleeez!

houlàlà, ya un truc que g pas compris...

si je fais:

lea data(pc),a0
move.w #4,d0
move.w 0(a0,d0.w),d1

data:
dc.w 12,250,3210,2,56,99

j'aurai quoi dans d1 ?
2 ?
sinon, comment je dois faire ?

avec des espaces en début de ligne, bien sûr...
à chaque fois j'oublie que ça prend pas les espaces seuls... et merde !

>zlk
>GugusG

: Dans un registre, accéder à un mot ou un octet accède à la fin du registre. Ce n'est pas la même chose qu'en mémoire!

 clr.l d1 ;D'ailleurs, moveq.l #0,d1 serait plus rapide et aussi petit.
;d1 = $00 00 00 00
 clr.l d0 ;Idem.
;d0 = $00 00 00 00
 move.w #$FEFF,d0 
;d0 = $00 00 FE FF
 move.w d0,d1
;d1 = $00 00 FE FF

Donc d0.b contient $ff.

>SbiBI

Non, tu aurras 250 dans d1.w.
Pour avoir 2:
1. Tu dois d'abord faire un add.w d0,d0 (plus rapide que lsl.w #1,d0) pour multiplier d0 par 2.
2. L'offset serait de 3 mots, pas de 4!

Voilà un code correct:

 lea data(pc),a0
 moveq.l #3,d0 ;plus rapide que "move.w", mais détruit le long entier!
 add.w d0,d0 ;pour multiplier par 2
;Évidemment pour une constante comme celle-ci, il vaut mieux de multiplier par 2 tout de suite (et remplacer 3 par 6) plutôt que de mettre cette dernière instruction.
 move.w 0(a0,d0.w),d1

D'ailleurs, pour cet exemple:

 lea data(pc),a0
 move.w 6(a0),d1

suffirait.
[edit]Edité par Kevin Kofler le 21-06-2001 à 19:57:22[/edit]

oki, merci, mais je dois incrémenter la position de lecture dans a0 dans une boucle, donc je suis obligé de passer par un registre que j'incrémente et qui me donne la position dans a0...

si g bien compris, l'offset pour avoir la première valeur de a0 serait 0 ?
la cinquième, 4
la sixième, 5
etc..

.
[edit]Edité par SbiBI le 22-06-2001 à 15:48:16[/edit]

>KEVIN
Tu as surement raison, je ne te contredirai pas
Mais j'ai regardé A68k et c vrai que c pas clair au début mais si tu dit qu'on prend le registre par la fin, alors t'a raison!!!

et on peut pas faire directement
move.w d0(a0),d1

puiskon peut écrire
move.w 4(a0),d1

?

non
move.w 0(a0,d0.w),d1

Ok, merci

[edit]Edité par SbiBI le 22-06-2001 à 16:02:12[/edit]

cf les mode d'adresseages dans ZGuide