mais pourquoi ????? - Page 1

bon j'en ai marre je ne comprend PAS pourqoi ce putain de code de m***e ne marche pas !!!
ça doit juste mettre une chaîne sur la pile et la ressortir mais ca ne marche PAAAAAS et je comprend pas pourquoi ......

void ts (unsigned char *s asm("%a0"),unsigned char *r asm("%a1"))
{
asm("
 move.b #0,-(%a7)    |valeur reference

boucle:

 tst.b (%a0)
 bne pas_fin
 jsr vide_stack
 bra fin
pas_fin:

 move.b (%a0)+,-(%a7) |on met dans la pile 
 bra boucle
 
vide_stack:
 tst.b (%a7)         |tant qu'on est pas arrivé a la valeur ref
 beq fin_vide_stack
 move.b (%a7)+,(%a1)+ |on desempile la pile
 bra vide_stack

fin_vide_stack:
 rts

fin:
 move.b (%a7)+,(%a1)
");
 
}
void _main(void)
{	
clrscr();
unsigned char t[50];
memset(&t[0],0,50);
unsigned char *s=malloc(6);
strcpy(s,"pk???");
*(s+5)=0;
ts(s,&t[0]);
printf("%c,%c,%c",t[0],t[1],t[2]);
ngetchx();
  free(s);
}

merci pour votre aide

-

-

move.b -> tu ne peu pas empiler un byte sur la pile

kuaaaaa? y fô que je fasse ma propre pile alors ???????

comment cela se fait-il ?

et pis en fait la fnc vide_estack dont j'ai besoin pour un programme bcoup plus gros, la ct un test pour savoir pk ca marchait pas ...

ct juste un test pour que vous puissiez voar que ca marche pas du tou

mais comment fait la ti alors ?

elle fait toujours par deux octets minimum, quitte à n'en utiliser qu'un seul sur les deux
le processeur n'accepte pas de lire plus d'un octet à partir d'une adresse impaire => on évite au maximum de faire en sorte d'avoir des adresses impaires

-

mais bon, en principe son prog devrait marcher nan ? move.b d0,-(a7) = move.b d0,-2(a7);subq.w #2,a7 et move.b (a7)+,d0 = move.b (a7),d0;addq.w #2,a7, si mes souvenirs sont bons...

et la justification d'orion est inexacte, puisqu'on utilise la pile superviseur dans ce cas, et que ça ne fait une différence que si le code qui touche à la pile était déjà en mode superviseur... (et on peut supposer que du code superviseur ne fait pas n'importe quoi)

donc je peux utiliser sr ?

sinon a quoi est du la barre noire toute seul a l'erreur (quand bug il ya )?(ss rien de marqué)

que y a un plantage assez méchant pour que des données du tios soient corrompues :]

Pour le move.b d0,-(a7) ça décrémentera effectivement a7 de 2, pas de risque de plantage de ce côté, faut juste se méfier quand on lit les données dans la pile après ...

la question est de savoir s'il le met à -2(a7) ou à -1(a7), si c bien -2(a7) comme je le pense, je vois pas pkoi le programme planterait

en fait je crois qu'il étend le signe et empile un word
mais le problème ne vient peut être pas de là

ben non justement, si c comme j'ai dit le move.b #0,-(a7) fera ce qu'il faut...

bon ok pk ce code pour faire un expr postfix ne marche pas ?

#include <tigcclib.h>


unsigned char postfix(const unsigned char * s asm("%a0"),unsigned char *r asm("%a1"),unsigned char *pile asm("%a2"))
{
asm("

 move.b #0,-(%a2)

boucle: 
 cmp.b #40,(%a0)
 bne pas_parenthese_ouvrante
 adda.l #1,%a0
 move.b #0,-(%a2)
 bra boucle
pas_parenthese_ouvrante:

cmp.b #41,(%a0)
 bne pas_parenthese_fermante
 bsr vide_operande
 bra fin
 adda.l #1,%a2
 bsr vide_operande
 adda.l #1,%a0
 bra boucle1 
pas_parenthese_fermante:

 move.b (%a0)+,(%a1)+
boucle1:
 tst.b (%a0)
 beq fin
 
 cmp.b #43,(%a0)
 bne pas_plus
 bsr vide_operande
 move.b (%a0)+,-(%a2)
 bra boucle
pas_plus:

 cmp.b #45,(%a0)
 bne pas_moins
 bsr vide_operande
 move.b (%a0)+,-(%a2)
 bra boucle
pas_moins:
 
 cmp.b #42,(%a0)
 bne pas_fois
 move.b (%a0)+,-(%a2)
 bra boucle
pas_fois:

 cmp.b #48,(%a0)
 bne pas_div
 move.b (%a0)+,-(%a2)
 bra boucle
pas_div:

vide_operande:
 tst.b (%a2)
 beq fin_vide_operande
 move.b (%a2)+,(%a1)+
 bra vide_operande

fin_vide_operande:
 rts

fin:
 bsr vide_operande
 move.b (%a2)+,(%a1)
finfin:
");	
}



void _main(void)
{	
	clrscr();
	unsigned char t[50],p[50];
	
	memset(&t[0],0,50);
	memset(&p[0],0,50);
	
	postfix("2*(3+5)",&t[0],&p[50]);
	printf("%s",&t[0]);
	ngetchx();

}

t1 mais comment on a fait pour pas le voir
jsr empile l'adresse de retour

Et tu ferais mieux d'essayer d'optimiser à fond pour réduire le nb de sauts, parce que là c'est complètement illisible...

ou ca jsr, y'a pas de jsr ds mon code??!!


 |tant qu'on arrive pas a la valeur reference  beq fin_vide_operande   move.b (% a2)+,(% a1)+ |on vide  bra vide_operande    fin_vide_operande:   rts    fin:   bsr vide_operande |on vide une derniere fois  move.b (% a2)+,(% a1) |et on termine par 0bon j'ai vraiment tout commenté, je ne comprend absolument pas pk les parenthese ne marche pas, pas de jsr ni de conneries, j'ai fait un test sur papier en suivant le raisonnement de mon prgm , normalement pas de probleme, mais pourquoi ca ve pas marcher ???move.b #0,-(% a2)  |la valeur reference   boucle:      cmp.b #40,(% a0)   |si c'est une parenthese ouvrante , alors ...  bne pas_parenthese_ouvrante   adda.l #1,% a0      |on passe au caractere suivant  move.b #0,-(% a2) |on met une valeure stop pas_parenthese_ouvrante:    cmp.b #41,(% a0)  |si c une parenthese fermante  bne pas_parenthese_fermante   bsr vide_operande |on vide les operateurs une fois  adda.l #1,% a2     |on saute la valeur stop  bsr vide_operande |et on revide une derniere fois  adda.l #1,% a0  |et on passe au caractere suivant  bra boucle1     |mais ce sera ptet un operateur alors pas de move a1 tt de suite pas_parenthese_fermante:     move.b (% a0)+,(% a1)+  | c un chiffre, on le met ds le retour boucle1:   tst.b (% a0)  |si c la fin c la fin  beq fin      cmp.b #43,(% a0) |si c +  bne pas_plus   bsr vide_operande  |on vide les operateurs  move.b (% a0)+,-(% a2) |et on le met sur la pile  bra boucle pas_plus:     cmp.b #45,(% a0) |si c - idem que +  bne pas_moins   bsr vide_operande   move.b (% a0)+,-(% a2)   bra boucle  pas_moins:      cmp.b #42,(% a0) |si c un produit  bne pas_fois    |on empile par dessus  move.b (% a0)+,-(% a2)    bra boucle  pas_fois:      cmp.b #48,(% a0) |idem pour le /  bne pas_div   move.b (% a0)+,-(% a2)   bra boucle  pas_div:    vide_operande: |on vide la pile des operateurs  tst.b (% a2)

ah oui, si y'a des bra partout, c justement pour optimiser, pour faire le (-) de cmp possible, et pour les arguements , c les meme que pour le post 19

et j'emploie la methode expliqué sur ce site : http://www.info.ucl.ac.be/notes_de_cours/LINF1251/projet/shunting.html
et j'avais pas fais gaffe, en fait je cherchais a tester jsr et bsr et a la fin c tombé sur jsr ... dsl en plus c bien marqué dans le a68kguide que c'est empilé sur la stack
mais la j'utilise ma propre pile , alors pk ca marche pas ?

t'as essayé de tracer le truc ?

matthieu :
ou ca jsr, y'a pas de jsr ds mon code??!!

Je parlais du 1er truc, qui ne marche pas à cause de ça (mais qui sans ça devrait marcher).

ah oui, si y'a des bra partout, c justement pour optimiser, pour faire le (-) de cmp possible, et pour les arguements , c les meme que pour le post 19

euh c pas ce qu'on appelle qqch d'optimisé

essaye, à chaque fois que tu as un "bra", de recopier ce qui suit le label de destination (en en recopiant le moins possible, évidemment) : dans certains cas, ça ne fait que grossir le programme (dans ce cas-là tu gardes le bra), dans d'autres, la version non-recopiée ne sert plus à rien et tu auras éliminé un "bra" inutile

non mais la y'a pas d'autre solution, je dois tester si c'est soit un plus, soit un - soit un * soit un / tu ve que je fasses comment? (toutes les suggestions sont les bienvenu vu mon niveau en asm)

sinon flanker(#lueur d'espoir#), l'erreur semble se situer lorsque l'on ferme la parenthese apres le cmp #41,a0

void ts (unsigned char *s asm("%a0"),unsigned char *r asm("%a1")) 
{ 
asm(" 
 move.b #0,-(%a7)    |valeur reference 
 
boucle: 
 
 tst.b (%a0) 
 bne pas_fin 
 jsr vide_stack 
 bra fin 
pas_fin: 
 
 move.b (%a0)+,-(%a7) |on met dans la pile  
 bra boucle 
  
vide_stack: 
 tst.b (%a7)         |tant qu'on est pas arrivé a la valeur ref 
 beq fin_vide_stack 
 move.b (%a7)+,(%a1)+ |on desempile la pile 
 bra vide_stack 
 
fin_vide_stack: 
 rts 
 
fin: 
 move.b (%a7)+,(%a1) 
");

Ce n'est pas de l'assembleur inline valide! Correct:

void ts (unsigned char *s asm("%a0"),unsigned char *r asm("%a1"));
asm(" 
.globl ts
ts:
 move.b #0,-(%a7)    |valeur reference 
 
boucle: 
 
 tst.b (%a0) 
 bne pas_fin 
 jsr vide_stack 
 bra fin 
pas_fin: 
 
 move.b (%a0)+,-(%a7) |on met dans la pile  
 bra boucle 
  
vide_stack: 
 tst.b (%a7)         |tant qu'on est pas arrivé a la valeur ref 
 beq fin_vide_stack 
 move.b (%a7)+,(%a1)+ |on desempile la pile 
 bra vide_stack 
 
fin_vide_stack: 
 rts 
 
fin: 
 move.b (%a7)+,(%a1)
 rts
");

bon alors personne ne peu resoudre mon probleme ?

apres tout plein de test je ne suis pas parvenu a situer l'erreur, j'ai l'impression qu'elle est completement aleatoire ... je reposte le code au cas où

void ts (const unsigned char *s asm("%a0"),unsigned char *r asm("%a1"))  ;

asm(" 
.globl ts 
ts: 
move.b #0,-(% a2)  |la valeur reference
 
boucle:    
 cmp.b #40,(% a0)   |si c'est une parenthese ouvrante , alors ...
 bne pas_parenthese_ouvrante 
 adda.l #1,% a0      |on passe au caractere suivant
 move.b #0,-(% a2) |on met une valeure stop
pas_parenthese_ouvrante: 
 
cmp.b #41,(% a0)  |si c une parenthese fermante
 bne pas_parenthese_fermante 
 bsr vide_operande |on vide les operateurs une fois
 adda.l #1,% a2     |on saute la valeur stop
 bsr vide_operande |et on revide une derniere fois
 adda.l #1,% a0  |et on passe au caractere suivant
 bra boucle1     |mais ce sera ptet un operateur alors pas de move a1 tt de suite
pas_parenthese_fermante: 
 
 move.b (% a0)+,(% a1)+  | c un chiffre, on le met ds le retour
boucle1: 
 tst.b (% a0)  |si c la fin c la fin
 beq fin 
  
 cmp.b #43,(% a0) |si c +
 bne pas_plus 
 bsr vide_operande  |on vide les operateurs
 move.b (% a0)+,-(% a2) |et on le met sur la pile
 bra boucle
pas_plus: 
 
 cmp.b #42,(% a0) |si c un produit
 bne pas_fois    |on empile par dessus
 move.b (% a0)+,-(% a2)  
 bra boucle 
pas_fois: 
   
vide_operande: |on vide la pile des operateurs
 tst.b (% a2) |tant qu'on arrive pas a la valeur reference
 beq fin_vide_operande 
 move.b (% a2)+,(% a1)+ |on vide
 bra vide_operande 
 
fin_vide_operande: 
 rts 
 
fin: 
 bsr vide_operande |on vide une derniere fois
 move.b (% a2)+,(% a1)
 rts |et on termine par 0");

void _main(void) 
{	 
clrscr(); 
unsigned char t[50],p[50]; 
	 
memset(&t[0],0,50); 
memset(&p[0],0,50); 
	 
postfix("2*(3+5)",&t[0],&p[50]); 
printf("%s",&t[0]); 
ngetchx(); 
}