Matrice et liste - Page 1

Salut a tous,
Quelqu'un sait comment manipuler,creer des matrice et liste en asm ??
Je suis en panne
Merci beaucoup
@++

Y'a aucune structure pré-faite, tu dois le faire toi. Enfin une liste ca n'est rien qu'un tableau à 1 dimension, une matrice à 2 dimensions.
Pour une liste, trouve une buffer de la taille que tu veux, et pour accéder au n-ième élément de ta liste, ca se trouve à l'adresse

adresse_de_ta_liste + n*taille_d_un_élément

oui ? non ?

Tout est en détails içi :
http://paxl.org/~tift/tuts/chapitre6.htm
Mais c'est exactement ce que pacHa à dit.

Merci beaucoup a vous deux c'est exactement ce que je voulais

re-salut,
Le tuto de la tift ne montre pas comment placer un nombre dans une liste ou dans une matrice...
Quelqu'un sait comment faire ??
merci

bha tu l'écris à l'adresse_qui_va_bien (début + taille_du_type_de_donné*position pour une liste, début + taille_d_une_ligne*i + taille_du_type_de_donné*j pour un lément (i,j) d'une matrice, avec taille_d_une_ligne = taille_du_type_de_donné*nombre_de_donné_par_ligne )

Salut @very,
Merci de ta reponse mais tu pourrais donner un exemple parce que la je comprends pas trop

Bha je vois pas coment faire plus compréhensible.... (et je serais presque incapable de te donner le code précis, j'ai quasiment jamais codé en asm z80 )
Tu sais écricre une valeur à une adresse ?

Tu connait le 'type' (typiquyement int, faut un octet pour un int ..) donc la place mémoir occupé par une variable de ton type (ici 1 octet pour un entier sur 0-255 ), et après, il "suffit" de compter le nombre d'élément avant celui où t'écris pour savoir l'adresse de celui que tu dois écricre.

( genre si tu veux enregistrer le 42ém élement d'une liste de variables de type int, faut aller à l'adresse début+41*8 en décimal. En effet, début+0 correspond au 1er élement de la liste, début+8 au 2nd, etc... )

Salut @very
,

Je sais pas pourquoi tout le monde rajoute "@" alors que c'est pas la même couleur... Moi j'ai jamais fait la faute lol

ça arrive régulièrement , donc bon .

Salut jbay, est ce que ta compris l'explication de very parce que en tout cas moi pas , en plus comme j'aimerais bien moi aussi utiliser des matrices se serait pas mal si quelqu'un me filait un petit coup de pouce.

J'ai trouvé ca sur le tutorial asmGuru, mais je n'arrive pas à l'utiliser , Help ! :

Tutorial 24: Matrices!!
Symbol Table Tutorial 5.


Introduction.
From lists to matrices…this tutorial is how to store numbers to matrices. Predictably…I must thank Ian again for his massive contribution to figuring out matrices.


Matrices.
If you don't know what matrices are, they are (most of the time), 2-dimensional arrays, or lists within lists if its easier explain that way. An example of a matrix is:

2, 3, 4
3, 2, 4
1, 7, 4
1, 1, 0

That is a 3x4 matrix. Matrices are useful for a lot of things…especially in 3D programming (anyone for Quake-Ti?!)


New Commands.
_puttomat - bc is rol/col, de is address, op1 is number.


Code.
Ok, let's get stuck into this code:

...standard stuff...
_errundefined .equ 467Bh
.org 9327h
     call _zerooop1         ; clear op1
     ld hl,op1              ;
     ld (hl),$02            ;
     inc hl                 ;
     ld (hl),$5C            ;
     inc hl                 ;
     ld (hl),$00            ;
     call _chkfindsym       ; look up list
     jp c,_errundefined     ; error if not found
     push de
     ld hl,500
     call _setxxxxop2
     call _op1exop2
     pop de
     ld bc,$0101              ; row 1 col 1
     call _puttomat         ; store it
     ret
.end
end

Ian loaded the name a rather interesting way…note how he used the actually token bytes, not the token equates. It is just as feasible to use the equates instead. Also notice how he pushes de (the address of the list), because the _setxxxxop2 and _op1exop2 screw around with the value of de, then then pops it later. Also, note, his orignal fault in the program was he was calling $11 for the row/col. You must have a 0 before the single digit…Ian's orignal program was trying to access (0,11) and was getting an "ERR: Link" message.


Conclusion.
That should just about finish us up on Symbol table tutorials…ah, perhaps not. The symbol table has so many uses.
All tutorials Copyright (c) James Matthews 1998, unless specified.

Arg, svp, personne veut vraiment m'aider, je suis paumé avec les matrices, mais j'en ai absolument besion pour mon prochain programme, aidez moi par pitié, ca me déprime!!!

Honnètement, je ne les ai jamais utilisées en assembleur... Je ne peux, en l'état actuel des choses, pas t'aider.

Bon, j'essayerais de me passer d'elles alors, merci quand même de ta reponse

Bha le principe des structures de données en bas niveau, c'est asser universel, après si tu te dévrouille un peu en asm z80 tu devrais pourvoir l'implémenter sans trop de pbs..

On va comencer par une liste d'entier pour faire simple. (les matrices ne sont que des listes de listes)
Tu sais faire en sorte d'écricre/lire une variable à une valeur précise de ta mémoire ?
Bon, ben le principe, c'est:
-tu te démerde pour avoir un endroit en mémoir ou y'a assez de place pour toute ta liste, et tu connais l'adresse de cet endroit, qu'on notera..heu $lst (ça sa dépend du language..)
-Un liste, c'est ça: var1-var2-var3-var4-var5-....
Il faut que tu te dise que c'est la même chose dans ta représentation mémoire: t'a une varibale, et juste après, t'a la variable suivante de la liste. Par exemple si tu veux une liste d'entier entre 0 et 255, chaque octect représentera une variable
- Tu accède à la première valeur de ta liste avec $lst. Pour accéder à la seconde, il suffit de se "décaller" par rapport à la première, ok ?
Bon, pour avoir l'adresse de la seconde variable, il faut donc aller à $lst+(taille_d'une_variable) , c'est à dire ici $lst+8 (en décimale) si t'es encore avec tes entiers coder sur un octet.
- Pour accèder aux autres, bha c'est le même principe que pour la 2nd:
$lst pour la 1er
$lst+8 pour la 2nd
$lst+8+8 pour la 3ém
$lst+8+8+8 pour la 4ém
$lst+(i-1)*8 pour accéder à la i_ém valeur.

-En génral, on utilise un pointeur qui pointe vers l'indexe courant de la liste.( celui auquel tu veux accéder/dernier que tu a accèder) Donc tu modifie vers quoi pointe ton pointeur au vu de ce que j'ai expliqué dessu, et voilà..

Bon, si t'arrive à comprendre et coder ça, bha les matrices c'est le même principe avec un chouilla en plus. (en bref: Pour un élément (i,j) $mat+(i-1)*(taille_ligne)+(j-1)*(taille_élément) )

Merci , je vais essayé avec ca

Oui c'est bon merci j'ai compris , seulement un problème, je nomme mon adresse de départ "liste"
si je veux stocker un element de la liste dans le registre a je mettrait par exemple:
ld a,(liste+8)

Admettons maintenant que je veuille remplacer le 8 par une lettre.
Seulement lorsque je met :
ld b,8
ld a,(liste+b)

ca ne marche pas

bha là j'en sais trop rien c'est une question d'asm z80 donc je ne pourai que moyenement t'aider... (faut voir niveau de l'homogéneité, tu n'a surement pas le droit d'additioner ton b avec ton list: list c'est une adresse (codé en dur par le compilo ?), b un registre) mais essaye essaye de faire l'opération d'addition avant..
Sinon, essaye d'avoir une vraie variable de type pointeur que tu modifie. (au début tu l'initie à list bien sur)

Bon les codeurs asm on vous attends ^^

Comment peut on avoir une variable de type pointeur ??

Si je met

ld a,(matrice+pointeur)

Ca ne marche pas non plus

Bha je t'ai dis que je ne connais pas précisément l'asm z80, y'a p-t des astuces de guerre à utiliser, donc bon, je pense que tu peux attendre le 1er codeur ams qui passe. (sinon re-créer un topic pour stimuler un peu les codeurs qui ne lisent plus celui-ci).

ld a,(matrice+"valeurdepointeur")

Voila ce qu'il faudrait. ^^

Sinon j'ai trouvé un registre sp (stack pointeur) , mais je ne sais pas comment il marche et même pas s'il y a un rapport avec ce que l'ont cherche.


Ps : oui je vais peu etre essayer de recreer un nouveau topic ^^

C'est fait

Là, ça dérape un peu...

Le stack pointeur risque de poser quelques problèmes si tu l'utilises n'importe comment, en effet, comme son nom le confirme, il s'agit d'un registre qui contient l'adresse du haut de la pile. Donc, si tu modifies son contenu, tout "ret" ou "pop" ressortira une adresse erronée... Ceci ne signifie pas que tu ne puisses pas l'utiliser, mais il faut faire très attention.

Ensuite, je risque de tomber en désaccord avec certains, mais je pense que la notion de "pointeur" n'a rien à faire en asm. En C ok (et c'est sûrement pour cela que very y fait allusion), mais le C est un langage moins souple que l'asm (d'un point de vue programmation bas niveau... Le C est plus souple sur bien d'autres aspects et c'est un langage que je respecte). On peut évidemment utiliser des "pointeurs" en asm, mais ça ne correspond alors à rien de physique et c'est cela qui me pose problème : quand on définit un pointeur en C, le compilateur reconnaît clairement la variable comme un pointeur puisqu'elle est définie ainsi, alors qu'en asm, une variable (qu'elle se trouve sous la forme d'un registre ou d'une adresse) ne sera considérée comme un pointeur que si on l'utilise comme tel (avec les parenthèses).
Conclusion : je pense que le C se comprend bien avec l'aide de l'assembleur (notamment les pointeurs justement), mais pas forcément l'inverse...

Concernant ceci :

ld b,8 ld a,(liste+b)

c'est normal : l'instruction ld a,(XXXX) ne peut contenir qu'une adresse à la place des XXXX.
Tu peux écrire :
ld bc,8
ld hl,liste
add hl,bc
ld a,(hl)


Un conseil important, vérifie toujours la validité de tes instructions avec un "Z80 opcode list" machin-chose ou "reference list", c'est une liste de toutes les instructions possibles avec les registres utilisables pour chaque instruction.

Merci beaucoup pour ta reponse (très complete en + ), j'ai juste une question au niveaux des registre : a quoi servent les parenthèse :?

Ps : Dsl, pour avoir creé 2 posts c'étais peu etre pas une très bonne idée finalment , merci en tt cas

joe14> On parle sans problème de pointeur en assembleur. ( ce n'est pas pasque je ne code pas en asm z80 que je ne sais pas ce qu'est l'asm en génral, que je ne code jamais en asm, et que je ne m'informe pas sur le sujet)
On s'en fout de savoir si c'est typé/touça par le compilo/language, et bien sur que si que ça correspond physiquement. (ça ne reste qu'une variable qui a pour but de stoquer une adresse (au demeurant physique).). D'ailleurs, on palre tout le temps de 'pointeur' (au sens général comme je viens de le définir) lorsque tu regarde des trucs genre la doc sur ticalc des Tis z80, et c'est plus que très utilisé. (notemment par le système d'exploitation).
De toute façon c'est utilisé par n'importe quel système dès qu'il doit un minimum organiser ses fichiers...

Donc c'est quoi qui te choque...que j'appelle ça pointeur ? (si tu veux j'appelle ça "variable valant une adresse mémoir non-insignifiante" Que je l'embrouille avec qqch qu'il ne conais pas ?
Historiquement, la notion de pointeur vient bien de l'asm et à été transcrite dans des languages de plus au niveau comme le C qu'après. (d'ailleurs, on a coutume de dire que les pointeurs, ça "desend" d'un niveau quand même par rapport à des 'style de programmation' C qui peuvent faire penser à certains basic ).

là, ce n'est pas très compliqué, il s'agit d'avoir une variable qui contient comme valeur l'adresse de la valeur courante de la liste/matrice.


( aun passage, quite à te payer quelques warning , tu peux faire des trucs bien crades en C avec des pointeur-pas-vraiment-pointeurs, et ça passe...)
PS: j'en ai pas fait beaucoup de C. j'ai une visions de l'informatique et de la programmation bien plus général que venant d'un langage particulier (là c'est aussi le fait d'avoir testé un peu tout..), et la notion de pointeur est une notion universelle qui est utilisé de l'asm jusu'a...Maple je crois bien même (même si bon, c'est des faux pointeurs, c'est interprété, ..), donc non ça ne 'vient' pas du C mes coneseils. Le coup du pointeur sur l'indice courant, c'est ce qu'ils font tout le temps en asm dès qu'ils ont des structures un peu travaillé, j'y peux rien moi

Réponse très intéressante et argumentée . Cependant, je persiste à dire qu'il est réducteur de faire d'une variable asm un pointeur. De même que le fait de devoir affecter un type à une variable, cela reste pour moi, une limitation des langages de haut niveau.

a quoi servent les parenthèse :?

ld a,b ;charge le contenu du registre b dans l'accumulateur.
ld a,(hl) ;charge le contenu de la case mémoire dont l'adresse est stockée dans hl dans a.

Le fait de mettre des parenthèses indique que l'on considère le contenu de la case mémoire dont l'adresse est entre les parenthèses ou dont l'adresse est conteue dans le registre (de 16 bits donc) indiqué entre les parenthèses.

ld hl,adr1
ld a,(hl) ;stocke le contenu de la case mémoire relative à l'adresse adr1 dans a.

Cependant, je persiste à dire qu'il est réducteur de faire d'une variable asm un pointeur. De même que le fait de devoir affecter un type à une variable, cela reste pour moi, une limitation des langages de haut niveau.

Bha après je ne suis pas contre le bricolage/récupération de variable/changement dynamique de type/tout ce que tu veux. mais t'utilise une certaine variable un certain temps comme un pointeur. Après, c'est une question de simplicité du langage ( celui que je parle, pas de prog..)

C'est vrai. Je suis d'accord.