begin process at 2008 09 05 18:22:14
1 237 429 membres
369 nouveaux aujourd'hui
14 313 membres club

Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum.
Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

RECURSIVITE EN ASM


Information sur la source

Description

ce programme illustre la recursivite en assembleur
on utilise comme example la fonction de "FIBONACCI" et la "FACTORIEL"

Source

  • DONNE SEGMENT
  • MESSAGE DB 10,13,"*********CE PROGRAMME CALCULE LE SUIT DE FIBONACCI EN ASSEMBLEUR*******",10,13,'$'
  • UN_NUMERO DB 10,13," ENTRER LE RANG : ",'$'
  • RESULTAT DB 10,13," VIOCI LE RESULTAT ",'$'
  • MSGFACTO DB 10,13," ET POUR LE FACTORIELLE LE RESULTATA EST : ",'$'
  • MSGERREUR DB 10,13,"ENTRER UN NOMBRE SVP",'$'
  • DONNE ENDS
  • CODE SEGMENT
  • ASSUME CS:CODE,DS:DONNE
  • debut:
  • MOV AX,DONNE
  • MOV DS,AX
  • LEA DX,MESSAGE
  • MOV AH,09H
  • INT 21H
  • LEA DX,UN_NUMERO
  • INT 21H
  • MOV BX,0
  • MOV CX,10
  • ;LECTURE ET CONVERTION DES DU NOMBRE LU DANS LE REGISTRE BX
  • LECT:
  • MOV AH,01H ;on lit un caractaire
  • INT 21H
  • CBW
  • CMP AL,13 ; si c'est ENTRER on va la suit du programme
  • JE SUIT
  • CMP AL,30H ;SINON ON VERIFIE SI C'EST UN CHIFFRE
  • JL ERREUR
  • CMP AL,39H
  • JA ERREUR
  • SUB AL,30H ;si oui on lui soustrait 30H
  • XCHG AX,BX
  • MUL CX ;on multiplie le resultat deja obtenu par 10
  • JC SUIT
  • ADD AX,BX ;ON L'ADDITIONNE AVEC LE NOMBRE LU
  • XCHG AX,BX ; on met le resultat dans bx
  • JMP LECT
  • SUIT:
  • MOV CX,BX ;ON MET DANS CX LE RAG
  • PUSH CX
  • CALL FIBO
  • MOV DX,OFFSET RESULTAT
  • MOV AH,09H
  • INT 21H
  • CALL AFFICHE
  • POP CX
  • CALL FACTO
  • MOV BX,AX
  • LEA DX,MSGFACTO
  • MOV AH,09H
  • INT 21H
  • CALL AFFICHE
  • JMP FIN
  • ERREUR:
  • LEA DX,MSGERREUR
  • MOV AH,09H
  • INT 21H
  • FIN:
  • MOV AH,01H
  • INT 21H
  • MOV AH,4CH
  • INT 21H
  • ;*************************************************
  • ; LA PROCEDURE NON RECURSIVE DE FIBONACCI
  • ;*************************************************
  • FIBO:
  • XOR AX,AX
  • JCXZ RETOURE
  • MOV BX,AX
  • INC AX
  • CMP CX,1
  • JBE RETOURE
  • TANQUE:
  • PUSH AX
  • ADD AX,BX
  • POP BX
  • LOOP TANQUE
  • RETOURE:
  • RET
  • ;***************************************************
  • ; LA PROCEDURE D'AFFICHAGE DU RESULTAT
  • ;***************************************************
  • AFFICHE:
  • mov cl,10
  • MOV AX,BX
  • MOV SI,0
  • MOV DX,0
  • convert:
  • INC SI
  • div CX
  • cmp AX,0
  • je BOUCLE
  • ADD DL,30H
  • PUSH DX
  • CWD
  • JMP CONVERT
  • BOUCLE:
  • ADD DX,30H
  • PUSH DX
  • BCL:
  • POP DX
  • MOV AH,02H
  • INT 21H
  • DEC SI
  • CMP SI,0
  • JNE BCL
  • ret
  • ;*******************************************************************
  • ;******************************************************************
  • ;**** LA FONCTION FACTORIELLE RECURSIF ****
  • ;******************************************************************
  • FACTO:
  • XOR AX,AX
  • INC AX
  • FACTORIELLE:
  • JCXZ RET_PROG
  • MUL CX
  • DEC CX
  • CALL FACTORIELLE ;ICI LE CALL EST SEULLEMENT FAIR ILLUSION A LA RECURSIVITE
  • ; LE RESULTAT RESTERA LE MEME AVEC UN JMP MAIS TRES EFFICASSE
  • RET_PROG:
  • ret
  • ;**** FIN DE LA PROCEDURE ******
  • CODE ENDS
  • END debut
DONNE SEGMENT 

MESSAGE   DB 10,13,"*********CE PROGRAMME CALCULE LE SUIT DE FIBONACCI EN ASSEMBLEUR*******",10,13,'$'
UN_NUMERO DB 10,13,"	ENTRER LE RANG :  ",'$'
RESULTAT  DB 10,13,"			VIOCI LE RESULTAT ",'$'
MSGFACTO  DB 10,13,"      ET POUR LE FACTORIELLE LE RESULTATA EST : ",'$' 
MSGERREUR DB 10,13,"ENTRER UN NOMBRE SVP",'$'
DONNE ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DONNE
debut:
MOV AX,DONNE
MOV DS,AX

LEA DX,MESSAGE
MOV AH,09H
INT 21H
LEA DX,UN_NUMERO
INT 21H
MOV BX,0
MOV CX,10
 ;LECTURE ET CONVERTION DES DU NOMBRE LU DANS LE REGISTRE BX
LECT:
  MOV AH,01H ;on lit un caractaire
  INT 21H
  CBW
  CMP AL,13  ; si c'est ENTRER on va la suit du programme
  JE  SUIT    
  CMP AL,30H ;SINON ON VERIFIE SI C'EST UN CHIFFRE
  JL  ERREUR
  CMP AL,39H
  JA  ERREUR
  SUB AL,30H ;si oui on lui soustrait 30H
  XCHG AX,BX
  MUL  CX    ;on multiplie le resultat deja obtenu par 10
  JC   SUIT
  ADD  AX,BX ;ON L'ADDITIONNE AVEC LE NOMBRE LU
  XCHG AX,BX ; on met le resultat dans bx
  JMP  LECT
SUIT:
   MOV  CX,BX ;ON MET DANS CX LE RAG
   PUSH CX
   CALL FIBO
   MOV  DX,OFFSET RESULTAT
   MOV  AH,09H
   INT  21H
   CALL AFFICHE
   POP CX
   CALL FACTO
   MOV  BX,AX
   LEA  DX,MSGFACTO
   MOV  AH,09H
   INT  21H
   CALL AFFICHE
   JMP  FIN
ERREUR:
   LEA DX,MSGERREUR
   MOV AH,09H
   INT 21H
FIN:
  MOV AH,01H
  INT 21H
  MOV AH,4CH
  INT 21H
;*************************************************
;   LA PROCEDURE NON RECURSIVE DE FIBONACCI
;*************************************************
FIBO:
  XOR AX,AX
  JCXZ RETOURE
  MOV BX,AX
  INC AX
  CMP CX,1
  JBE RETOURE
TANQUE:
  PUSH AX
  ADD  AX,BX
  POP  BX
  LOOP TANQUE
RETOURE:
  RET
;***************************************************
;   LA PROCEDURE D'AFFICHAGE DU RESULTAT
;***************************************************
AFFICHE:
  mov cl,10
  MOV AX,BX
  MOV SI,0
  MOV DX,0
convert:
   INC SI
   div CX
   cmp AX,0
   je BOUCLE
   ADD DL,30H
   PUSH DX
   CWD
   JMP  CONVERT
BOUCLE:
   ADD  DX,30H
   PUSH DX
BCL:
   POP DX
   MOV AH,02H
   INT 21H
   DEC SI
   CMP SI,0
   JNE BCL
   ret
;*******************************************************************
;******************************************************************
;**** LA FONCTION FACTORIELLE RECURSIF                         ****
;******************************************************************
FACTO:
  XOR AX,AX
  INC AX
FACTORIELLE:
  JCXZ RET_PROG
  MUL  CX
  DEC  CX
  CALL FACTORIELLE   ;ICI LE CALL EST SEULLEMENT FAIR ILLUSION A LA RECURSIVITE
                     ; LE RESULTAT RESTERA LE MEME AVEC UN JMP MAIS TRES EFFICASSE
RET_PROG:
  ret

;****  FIN DE LA PROCEDURE    ******
CODE ENDS
END debut
  • signaler à un administrateur
    Commentaire de patatalo le 11/08/2005 22:38:40 administrateur CS

    pourquoi c'est en 16 bits ?

  • signaler à un administrateur
    Commentaire de BruNews le 11/08/2005 22:43:54 administrateur CS

    On se demande pourquoi les gens associent ASM et moyen-âge, c'est pourtant pas obligatoire.

  • signaler à un administrateur
    Commentaire de Nasman le 12/08/2005 09:34:27

    Merci pour la source (plus il y en aura sur le site et plus on pourra progresser). Cependant je trouve dommage que pour un tutoriel la partie récursivité soit un peu noyée dans le reste. C'est peut-être le prix à payer pour avoir un programme complet qui fonctionne et qui affiche des résultats.

    Pour ma part je pense qu'il serait préférable (pour une question de clarté)de scinder les différents éléments du programme en plusieurs tutoriels du genre :
    -comment saisir des données au clavier
    -comment afficher un message
    -comment convertir une chaine de caractère en nombres
    -comment convertir un nombre en chaine ascii
    -comment appeler un sous programme
    -la gestion de la pile
    -le passage de paramètres entre plusieurs applications (asm et langage évolué).
    -optimisation d'un programme (les trucs et astuces genre xor ax,ax...)en vue de le rendre plus compact ou plus rapide

    En règle générale, moins il y en a dans un programme et plus il est facile à comprendre - c'est le but recherché d'un tutoriel.

    Pour terminer il est vrai que le 16 bits est un peu dépassé à l'heure des 32 et 64 bits mais il est vrai que l'enseignement de l'assembleur s'effectue trop souvent sur du 16 bits.

  • signaler à un administrateur
    Commentaire de patatalo le 12/08/2005 11:20:58 administrateur CS

    salut,

    j'aime pas trop la recursivité par call car il y a des risques de debordement de pile ( surtout en 16 bits ) ce qui oblige a calculer le nombre max de recursivité par rapport à la taille de la pile.

    @++

  • signaler à un administrateur
    Commentaire de Nasman le 12/08/2005 12:04:21

    La récursivité génère un système de boucles imbriquées. Il est souvent plus économique d'utiliser une boucle, comme par exemple
              mov cx,n      
              mov ax,1
    fact      mul ax,cx      ;effectue fact(n)=n.fact(n-1)
              loop fact      ;si cx>0 on continue sinon fini
                             ;ax contient le résultat

  • signaler à un administrateur
    Commentaire de vecchio56 le 13/08/2005 09:43:09 administrateur CS

    Fibonacci est pourtant l'exemple type de fonction qu'on ne fait pas récursivement. Ici le débordement arrivera très vite

  • signaler à un administrateur
    Commentaire de BruNews le 13/08/2005 10:06:41 administrateur CS

    La récursivité implique:
    - 1 ou plusieurs PUSH (EIP au minimum).
    - 1 JMP.
    - 1 ou plusieurs POP.
    - 1 JMP de retour.
    On peut donc poser comme principe général que l'itération sera quasi toujours plus performante que la récursivité.

Ajouter un commentaire

Pub



Appels d'offres

Snippets en rapport

CalendriCode

Septembre 2008
LMMJVSD
1234567
891011121314
15161718192021
22232425262728
2930     

Téléchargements

Logiciels à télécharger sur le même thème :

Boutique

Boutique de goodies CodeS-SourceS