Stocker les repertoires - Page 1

J'ai besoin de votre aide sur ce programme, qui ne buggue pas. Il essaye de stocker tous les repertoires dans une liste, et de les lire, mais je n'obtiens rien.

include "ams_c"
movem.l d3-d4/a3-a4,-(a7)
lea names(pc),a3
move.w #0,d3
move.w #0,d4
move.w #2,-(a7)
pea 0
jsr SymFindFirst
lea 6(a7),a7

even
while:
move.l a0,a4 ;sauve le SYMSTR *
beq fail
move.l 11(a4),d0
btst #7,d0
beq notafolder
move.l a4,0(a3,d3.w)
addq.w #4,d3
addq.w #1,d4

even
notafolder:

jsr SymFindNext
bra while
even
fail: ;Plus de repertoire

lea counter(pc),a0
move.w d4,a0
move.w #0,d3
move.w #0,d4
even
fordo:
cmp.w counter(pc),d4
beq forend

move.w #1,-(a7)
move.w #0,-(a7)
move.l 0(a3,d3.w),-(a7)
pea titre
jsr DlgMessage
lea 12(a7),a7

addq.w #1,d4
addq.w #4,d3

bra fordo
even
forend:
movem.l (a7)+,d3-d4/a3-a4
rts
even
counter: dc.w 0
even
names: ds.l 20
even
titre: dc.b 'Repertoire',0

*****petit guide

names : liste des noms de repertoire
counter : le nombre d'itérations

a3 : 1 pointeur qui vaut names
a4 : sauvegarde d'un SYM_ENTRY * pendant 1 boucle
d4 : l'itérateur
d3 : l'itérateur *4

Au fait, est ce que les administrateurs pourraient me laisser mettre des espaces en début de ligne?

Bon, ce que je vais mettre ne répondra pas forcément à ta question, mais ça t'aidera :

Luigi a écrit :

include "ams_c"
movem.l d3-d4/a3-a4,-(a7)
lea names(pc),a3
move.w #0,d3 move.w #0,d4

C'est plus rapide (et plus court) d'utiliser clr.w dn au lieu de move.w #0,dn

move.w #2,-(a7)
pea 0
jsr SymFindFirst
lea 6(a7),a7

even while:

C'est à mon avis inutile de mettre un even juste après une instruction. L'adresse sera forcément paire.

move.l a0,a4 ;sauve le SYMSTR * beq fail

En fait, cette instruction donne lieuà des confusions : en réalité, tu utilises là l'instruction movea, et non l'instruction move. Et l'instruction movea n'affecte pas les indicateurs. La dernière instruction exécutée qui modifie les indicateurs est le move.w #2,-(a7) si on se place lors de la première itération, ou le addq.w #1,d4 si on a déjà fait une itération. Autant dire que le bit Z ne sera jamais à 1.

move.l 11(a4),d0
btst #7,d0
beq notafolder
move.l a4,0(a3,d3.w)
addq.w #4,d3
addq.w #1,d4
even
notafolder:
jsr SymFindNext
bra while
even
fail: ;Plus de repertoire
lea counter(pc),a0 move.w d4,a0

Tu charges l'adresse du counter dans a0, puis juste après tu mets d4 dans a0... ce n'est pas normal

move.w #0,d3
move.w #0,d4
even
fordo:
cmp.w counter(pc),d4
beq forend

move.w #1,-(a7) move.w #0,-(a7)

Ce n'est pas important, mais ça peut se simplifier en un pea.l $00000001

move.l 0(a3,d3.w),-(a7)
pea titre
jsr DlgMessage
lea 12(a7),a7

addq.w #1,d4
addq.w #4,d3

bra fordo
even
forend:
movem.l (a7)+,d3-d4/a3-a4
rts
even
counter: dc.w 0
even
names: ds.l 20
even titre: dc.b 'Repertoire',0

Bon, je n'ai pas trouvé d'où venait ton bug... Désolé.
ce que je te conseille pour débugger, c'est d'utiliser VTI (il contient un débugger), c'est très pratique. Et tu vérifies par exemple que ta liste names contient bien les adresses voulues.

Au fait, est ce que les administrateurs pourraient me laisser mettre des espaces en début de ligne?

Tu peux utiliser la balise pre pour faire ça.

ok,merci. Par contre pour VTI, ca me semble un peu compliqué

Ah, je viens de trouver quelque chose d'autre :

Luigi a écrit :
move.l 11(a4),d0 btst #7,d0

Tu dois mettre move.b 11(a4),d0.

jackiechan
a écrit : Autant dire que le bit Z ne sera jamais à 1

Je pense que tu as trouvé l'erreur: je cherche des repertoires, et justement, ce bit doit être à un. Par contre tu tres trompé, vu le deroulement du programme, mon bit 7 est à 0 et le flag z est à 1

On ne parle pas du même bit.
Là je parlais du bit Z du CCR, pas du bit correspondant au flag folder.

Oups, j'ai retiré ce que j'ai dit : une grosse betise

Quand tu testes ton programme en gardant l'instruction movea.l a0,a4, au moment du beq fail le programme fait quoi ?
Parce que d'après moi, il ne devrait pas effectuer le branchement vers fail puisque les instructions précédentes ne peuvent pas armer le bit Z du CCR...
Mais pourtant, après tu lis un longword à une adresse impaire, donc tu devrais avoir un ADRESS ERROR, et d'après ce que tu as dit, tu n'en as pas...

Ou tu vois que je lis un long à une adresse impaire? Parce que le prog ne plante pas. De plus, si tu teste avec le déboguage que j'y ai apporté, il me retourne directement un echec, cad directement un saut à fail

Le move.l 11(a4),d0 lit forcément une adresse impaire, parce que a4 contient une adresse paire.

As-tu fait les changements dont je t'ai parlé : move.l a0,d0 avant le beq fail, et move.b 11(a4),d0 ?

C'est bizarre que ça branche vers fail... J'ai du me tromper qqpart, mais je ne trouve pas où

Sinon, je peux toujours me remettre à utiliser la routine de Bihi, et me remettre à une routine de menu à plus tard (Intégrée dans n'importe quel prog, on n'a plus les problèmes de mémoire comme dans side)

BOn,je sais ce que je vais faire : découper les étapes et rajouter des expérimentations supplémentaires. J'ai pas le choix...si j'ai du mal c'est pas pour rien

Mais continue à essayer de débugger cette fonction !
Mets toi dès maintenant à VTI, le débuggeur n'est vraiment pas compliqué : en haut à gauche, tu as les instructions, en bas à gauche, la mémoire (tu peux lire à l'adresse que tu veux), en bas à droite, les handles et la pile, et en haut à droite, les registres...

Et tu n'as toujours pas répondu : est-ce que tu as fait les modifications dont je t'ai parlé ?

Pas toutes. Je continue (J'ai été emporté par la marée des idées en chaines : ah oui mais... ah oui mais ... ah oui mais...)

Elles sont indispensables !
Le move.l a0,a4 n'affecte pas les indicateurs du CCR, donc ton beq ne vaut rien !
Tu dois absolument passer par un registre de donnée.
Et le move.b 11(a4),d0 l'est aussi, sinon tu auras un adress error...

Argh et pour la balise pre, ne l'applique pas à chaque ligne, mais à toute la source, ça ira plus vite et ça évitera de se taper des sauts de ligne entre chaque ligne de code.

Par contre teste un petit peu cette mini routine (j'avais déja eu le temps de l'écrire quand tu m'avais posté ta réponse)

include "ams_c"
move.w #2,-(a7)
pea 0
jsr SymFindFirst
lea 6(a7),a7
pea $00000001
pea (a0)
pea titre
jsr DlgMessage
lea 12(a7),a7
rts
titre: dc.b 'Voila',0

Attend un peu, je suis en train d'essayer de comprendre
Et la balise s'appliquera à tout le code, meme aux labels

Au fait, pourquoi vous dites que move.l #3,variable est la meme chose mais moins rapide que move.l #3,varaible(pc) ?

J'ai la flemme de tester ta routine, mais d'après ce que je vois, elle prend le premier symbole de la VAT et affiche des caractères à partir du deuxième octet de flags.

move.l 11(a4),d0 ==> move.b 11(a4),d0

J'ai compris pour le pea. Et pour le counter, j'ai oublié que J. Mardell précisait
move <ea>,<ea>

Luigi
a écrit : Au fait, pourquoi vous dites que move.l #3,variable est la meme chose mais moins rapide que move.l #3,varaible(pc) ?

move.l #3,variable(pc) est incorrect de toute façon.

Mais en général, il faut préférer un adressage relatif au PC qu'un adressage absolu, c'est plus petit et plus rapide (dans le cas d'une adresse sur 32 bits). Plus rapide parce que le 68000 est fait comme ça. Pour la petite taille, c'est plus compliqué.

Luigi a écrit :
Et pour le counter, j'ai oublié que J. Mardell précisait move <ea>,<ea>

Je ne comprends pas ce que tu veux dire

merci jackichan! ca marche
(meme si le deboguage ne me donne pas pour l'instant les messages que j'attendais : j'ai fait une petite inversion)

Non le debugging est correct, c'est moi qui ai mal réfléchis, un peu étourdi par les événements (Que c'était dur!)

Grace à toi, je peux esperer progresser dans ma routine géante

Au faite, la mini routine que j'ai donné tout à l'heure, elle ne fonctionne pas parfaitement, mais je ne sais pas pourquoi. Elle est censée retourner le 1er symbol

Elle le fait mal

Tu veux dire qu'elle ne retourne pas toujours le 1er ?

Je suppose que ton bug vient seulement du fait que DlgMessage attend l'adresse d'une chaine de caractères en argument alors que tu lui donnes l'adresse d'un octet de flags. La fonction attend une chaine terminée par un caractère nul, donc je suppose que ta fonction écrit plein de caractères bizarres, non ?

>Post #22
(Le 68kguide de J.Mardell)
Je voulais dire en fait que la destination n'etait pas forcement un registre. De toute facon, j'ai vu que les indirections sur le pc, comme tu me l'as dit , sont interdites en destination (Addressind Methode : x(pc) en source, mais absent en destination)

Ca y est, j'ai corrigé le mini prgm (post #15)

Le programme de stockage de repertoire corrigé
***************************************

include "ams_c"
movem.l d3-d4/a3-a4,-(a7)
lea names(pc),a0
clr.w #0,d3
clr.w #0,d4
move.w #2,-(a7)
pea 0
jsr SymFindFirst
lea 6(a7),a7

while:
move.l a0,d0 ;sauve le SYMSTR *
beq fail
move.l d0,a4
move.b 11(a4),d0
btst #7,d0
beq notafolder
move.l a4,0(a3,d3.w)
addq.w #4,d3
addq.w #1,d4

notafolder:

jsr SymFindNext
bra while

fail: ;Plus de repertoire

move.w d4,counter
move.w #0,d3
move.w #0,d4

fordo:
cmp.w counter(pc),d4
beq forend

pea $00000001
move.l 0(a3,d3.w),-(a7)
pea titre
jsr DlgMessage
lea 12(a7),a7

addq.w #1,d4
addq.w #4,d3

bra fordo
forend:
movem.l (a7)+,d3-d4/a3-a4
rts
even
counter: dc.w 0
even
names: ds.l 20
even
titre: dc.b 'Repertoire',0

OK, mais tu stockes la liste de tes répertoires dans une liste de 20 emplacements. Ce qui fait que si on a plus de 20 dossiers, ça ne fonctionnera pas. Et de toute façon, 20 longword font perdre pas mal de place (80 octets) pour pas grand chose.
Le mieux en fait, c'est de mettre tout ça dans la pile au fur et à mesure. Comme ça, ta liste grandit en fonction du nombre de dossier, et aucune place n'est gaspillée. Mais l'implémentation est plus compliquée.

Sinon, tu peux mettre counter dans un registre (d5 par exemple), plutôt que d'utiliser un emplacement mémoire. Ton prog ira plus vite, et sera probablement plus petit.