Probleme de vecteur

Probleme de vecteur - ASM - Programmation

Marsh Posté le 26-01-2006 à 20:48:49    

Bonjour,
 
J'ai ecrit un programme mais il reste une erreur que je ne trouve pas car pour moi mon programme doit marcher.
Je rentre un mot, il me dit si c'est un palindrome puis me demande si je veux recommencer. Je recommence et la la chaine de caractere ne s'arrete pas la ou je met le '$' et contient aussi les lettres de ma saisie precedente.
SVP tester:
 
Metter ca:  ESOPE reste ici et se repose
                puis recommencer
                et taper kayak   :fou:  
 
Merci
 

Code :
  1. .MODEL SMALL 
  2. .STACK 
  3. .DATA
  4.  
  5.    titre DB "PALINDROME$"
  6.    slign DB "----------$"
  7.    carintro DB "Entrer une chaine de caracteres : $"
  8.    carchaine DB "La chaine de caractere est $" 
  9.    carjuste DB "LA CHAINE QUE VOUS AVEZ ENTREE EST UN PALINDROME !$"
  10.    carsym DB "La symetrie de la chaine est $" 
  11.    carfaux DB "LA CHAINE QUE VOUS AVEZ ENTREE N'EST PAS UN PALINDROME !$" 
  12.    recommencer DB 'Appuyer sur ENTER pour recommencer ou sur ESC pour arreter$'
  13.    mot1 DB 250, ?, 251 dup('$')
  14.    mot2 DB 250 dup('?')
  15. .CODE 
  16. MAINPROG :
  17.  
  18.    MOV AX, @DATA 
  19.    MOV DS, AX
  20.    MOV AH, 0Fh
  21.    INT 10h
  22.    MOV AH, 0h
  23.    INT 10h
  24.    MOV DH, 3
  25.    MOV DL, 30
  26.    MOV AH, 02h
  27.    INT 10h
  28.    MOV AX, 0900h
  29.    LEA DX, titre
  30.    INT 21h
  31.    MOV DH, 4
  32.    MOV DL, 30
  33.    MOV AH, 02h
  34.    INT 10h
  35.    MOV AX, 0900h
  36.    LEA DX, slign
  37.    INT 21h
  38.  
  39.    MOV DH, 6
  40.    MOV DL, 0
  41.    MOV AH, 02h
  42.    INT 10h
  43.    MOV AX, 0900h 
  44.    LEA DX, carintro 
  45.    INT 21h                     
  46.    MOV AH, 0Ch
  47.    MOV AL, 0Ah
  48.    LEA DX, mot1
  49.    INT 21h
  50.  
  51.    MOV SI, 2
  52.    MOV DI, 0
  53.  
  54. COMPARAISON:
  55.    CMP mot1[SI], '$'
  56.    JE FIN1
  57.  
  58.    CMP mot1[SI], 30h
  59.    JB PONCTU
  60.    CMP mot1[SI], 39h
  61.    JBE VEC2
  62.  
  63.    CMP mot1[SI], 41h
  64.    JB PONCTU
  65.    CMP mot1[SI], 5Ah
  66.    JBE VEC2
  67.  
  68.    CMP mot1[SI], 61h
  69.    JB PONCTU
  70.    CMP mot1[SI], 7Ah
  71.    JBE VEC2
  72.  
  73.    CMP mot1[SI], 82h
  74.    JB PONCTU
  75.    CMP mot1[SI], 97h
  76.    JBE VEC2
  77.  
  78. PONCTU:
  79.    INC SI
  80.    JMP COMPARAISON
  81. VEC2:
  82.    MOV AL, mot1[SI]
  83.    MOV mot2[DI], AL
  84.    INC SI
  85.    INC DI
  86.    JMP COMPARAISON
  87. FIN1:
  88.  
  89.    MOV AL, mot1[SI]
  90.    MOV mot2[DI], AL
  91.  
  92.    MOV DH, 8
  93.    MOV DL, 0
  94.    MOV AH, 02h
  95.    INT 10h
  96.  
  97.    MOV AX, 0900h
  98.    LEA DX, carchaine
  99.    INT 21h
  100.  
  101.    MOV DH, 8
  102.    MOV DL, 27
  103.    MOV AH, 02h
  104.    INT 10h
  105.  
  106.    MOV AX, 0900h
  107.    LEA DX, mot2
  108.    INT 21h
  109.    MOV SI, 0
  110. PALIN:
  111.    CMP SI, DI
  112.    JBE COMP_SI
  113.    PUSH SI
  114.    JMP FIN2
  115. JMP_DI:
  116.    
  117.    JMP COMP_DI
  118.  
  119. JMP_MAJU:
  120.    JMP MAJUSC_SI 
  121.  
  122. COMP_SI:
  123.    CMP mot2[SI], 61h
  124.    JB JMP_DI
  125.    CMP mot2[SI], 7Ah
  126.    JBE JMP_MAJU
  127.  
  128.    CMP mot2[SI], 82h
  129.    JE E_SI
  130.  
  131.    CMP mot2[SI], 83h
  132.    JE A_SI
  133.  
  134.    CMP mot2[SI], 84h
  135.    JE A_SI
  136.  
  137.    CMP mot2[SI], 85h
  138.    JE A_SI
  139.  
  140.    CMP mot2[SI], 88h
  141.    JE E_SI
  142.    CMP mot2[SI], 89h
  143.    JE E_SI
  144.    CMP mot2[SI], 8Ah
  145.    JE E_SI
  146.    CMP mot2[SI], 8Bh
  147.    JE I_SI
  148.    CMP mot2[SI], 8Ch
  149.    JE E_SI
  150.  
  151.    CMP mot2[SI], 8Dh
  152.    JE E_SI       
  153.    CMP mot2[SI], 93h
  154.    JE O_SI
  155.  
  156.    CMP mot2[SI], 94h
  157.    JE O_SI
  158.  
  159.    CMP mot2[SI], 95h
  160.    JE O_SI
  161.    CMP mot2[SI], 96h
  162.    JE U_SI
  163.  
  164.    CMP mot2[SI], 97h
  165.    JE U_SI
  166.  
  167. A_SI:
  168.    MOV mot2[SI], 'A'
  169.    JMP COMP_DI
  170. E_SI:
  171.    MOV mot2[SI], 'E'
  172.    JMP COMP_DI
  173. I_SI:
  174.    MOV mot2[SI], 'I'
  175.    JMP COMP_DI
  176. O_SI:
  177.    MOV mot2[SI], 'O'
  178.    JMP COMP_DI
  179. U_SI:
  180.    MOV mot2[SI], 'U'
  181.    JMP COMP_DI 
  182.  
  183. MAJUSC_SI:
  184.    SUB mot2[SI], 20h
  185.    JMP COMP_DI
  186. JMP_VERIF:
  187.    JMP VERIF
  188. MAJUSC:
  189.    JMP MAJUSC_DI 
  190. COMP_DI:
  191.    CMP mot2[DI], 61h
  192.    JB JMP_VERIF
  193.    CMP mot2[DI], 7Ah
  194.    JBE MAJUSC
  195.  
  196.    CMP mot2[DI], 82h
  197.    JE E_DI
  198.  
  199.    CMP mot2[DI], 83h
  200.    JE A_DI
  201.  
  202.    CMP mot2[DI], 84h
  203.    JE A_DI
  204.  
  205.    CMP mot2[DI], 85h
  206.    JE A_DI
  207.  
  208.    CMP mot2[DI], 88h
  209.    JE E_DI
  210.    CMP mot2[DI], 89h
  211.    JE E_DI
  212.    CMP mot2[DI], 8Ah
  213.    JE E_DI
  214.    CMP mot2[DI], 8Bh
  215.    JE I_DI
  216.    CMP mot2[DI], 8Ch
  217.    JE E_DI
  218.  
  219.    CMP mot2[DI], 8Dh
  220.    JE E_DI       
  221.    CMP mot2[DI], 93h
  222.    JE O_DI
  223.  
  224.    CMP mot2[DI], 94h
  225.    JE O_DI
  226.  
  227.    CMP mot2[DI], 95h
  228.    JE O_DI
  229.    CMP mot2[DI], 96h
  230.    JE U_DI
  231.  
  232.    CMP mot2[DI], 97h
  233.    JE U_DI
  234.  
  235. A_DI:
  236.    MOV mot2[DI], 'A'
  237.    JMP VERIF
  238. E_DI:
  239.    MOV mot2[DI], 'E'
  240.    JMP VERIF
  241. I_DI:
  242.    MOV mot2[DI], 'I'
  243.    JMP VERIF
  244. O_DI:
  245.    MOV mot2[DI], 'O'
  246.    JMP VERIF
  247. U_DI:
  248.    MOV mot2[DI], 'U'
  249.    JMP VERIF
  250.  
  251. MAJUSC_DI:
  252.    SUB mot2[DI], 20h
  253. VERIF:
  254.    MOV AL, mot2[SI]
  255.    CMP mot2[DI], AL
  256.    JNE FIN3
  257.    INC SI
  258.    DEC DI
  259.    JMP PALIN
  260.  
  261. FIN2:
  262.    MOV DH, 10
  263.    MOV DL, 0
  264.    MOV AH, 02h
  265.    INT 10h
  266.    MOV AX, 0900h
  267.    LEA DX, carjuste
  268.    INT 21h
  269.    MOV DH, 12
  270.    MOV DL, 0
  271.    MOV AH, 02h
  272.    INT 10h
  273.  
  274.    MOV AX, 0900h
  275.    LEA DX, carsym
  276.    INT 21h
  277.    MOV DH, 12
  278.    MOV DL, 29
  279.    MOV AH, 02h
  280.    INT 10h
  281.  
  282.    POP SI
  283.    MOV mot2[SI], '$'
  284.  
  285.    MOV AX, 0900h
  286.    LEA DX, mot2
  287.    INT 21h
  288.  
  289.    JMP RECOMMENCE
  290. FIN3:
  291.    MOV DH, 9
  292.    MOV DL, 0
  293.    MOV AH, 02h
  294.    INT 10h
  295.    MOV AX, 0900h
  296.    LEA DX, carfaux
  297.    INT 21h
  298.  
  299. RECOMMENCE:
  300.    MOV DH, 15
  301.    MOV DL, 5
  302.    MOV Ah, 02h
  303.    INT 10h
  304.  
  305.    MOV AX, 0900h
  306.    LEA DX, recommencer
  307.    INT 21h
  308.  
  309.    MOV AH, 01h
  310.    INT 21h
  311.  
  312.    CMP AL, 1Bh
  313.    JE QUIT
  314.    JMP MAINPROG
  315.  
  316. QUIT:
  317.  
  318.    MOV AX, 4C00h
  319.    INT 21h
  320. END

Reply

Marsh Posté le 26-01-2006 à 20:48:49   

Reply

Marsh Posté le 26-01-2006 à 22:18:55    

:hello:  
- La variable mot1 est initialisée avec des dollars.
- Puis le mot saisi vient dans mot1.
- Une boucle a lieu jusqu'au dollar qui se trouve à la fin de mot1.
- Un traitement complémentaire à lieu.
- L'utilisateur choisi de recommencer
- Il saisi un deuxième mot, qui vient dans mot1
et là il y a un problème parce que mot1 n'est pas terminé par un dollar.
Il faudrait que juste après la saisie (ligne 57) il y ait quelques lignes de code supplémentaires qui retirent le nombre de caractères saisis (ce nombre est mis par la fonction DOS dans le deuxième octet de mot1) par exemple dans di, et qui inscrive un dollar à mot1+di+1. Ou bien, plus simplement, il faudrait que le test ait lieu sur le carriage return au lieu d'avoir lieu sur le dollar, car la chaine saisie est stockée avec un carriage return à la fin.
 :)


Message édité par olivthill le 26-01-2006 à 22:20:07
Reply

Marsh Posté le 27-01-2006 à 09:28:59    

Je te remercie beaucoup. J'avais pas penser a verifier 0Dh, moi je pensais que c'était la meme chose.
 
Encore merci

Reply

Marsh Posté le 31-01-2006 à 07:49:30    

Bonjour
Voici une version linux du programme sans traitement des accents car PC8 ansi et UTF8 n'ont pas le même code c'est du 32 bits (ça fait plus moderne) et c'est commenté (ça aide à la relecture et à la compréhension de ce qui est fait)
J'ai utilisé les balises cpp pour avoir un semblant de prise en compte des tabulations, le résultat est bizare mais reste à peu près lisible.

Code :
  1. ; palindrome.asm
  2. ; créé le 30-1-2006
  3. ; programme effectuant le contrôle du palindrome d'un texte.
  4. ; utilisation : palindrome
  5. ; assemblage : nasm -f elf palindrome.asm
  6. ; édition de lien : ld -o palindrome palindrome.o
  7. ; finition : sstrip palindrome
  8. ; ne fonctionne que sur système linux à processeur 386 ou mieux
  9. BITS  32
  10. SECTION  .data
  11. message1 db "Contrôle de palindrome",10,0
  12. message2 db "... Fin du traitement",10,0
  13. message3 db "Entrer une chaine de caractères : ",0
  14. message4 db "La chaine de caractères est : ",0
  15. message5 db 10,"La chaine que vous avez entrée est un palindrome",10,0
  16. message6 db "La symétrie de la chaine est : ",0
  17. message7 db 10,"La chaine que vous avez entrée n'est pas un palindrome",10,0
  18. message8 db 10,"R(ecommencer) ou A(rréter) ? ",0
  19. merreur1 db 10,"Au moins un caractère n'est pas alphabétique",0
  20. merreur2 db 10,"Il se peut que la chaine comporte des lettres accentuées",0
  21. SECTION  .bss
  22. tpe  resb 256   ; tampon d'entrée
  23. mot1  resb 256   ; chaine d'entrée
  24. mot2  resb 256   ; chaine inversé
  25. SECTION  .text
  26. long_ch:     ; calcule la longueur d'une chaine terminé par un 0
  27. ; entré : edi -> pointe la chaine à mesurer
  28. ; sortie eax -> longueur de la chaine
  29. push edi
  30. xor eax, eax   ; compteur de caractère -> ah
  31. lbl4: scasb     ; a-t-on trouvé le 0 ?
  32. jz lbl3    ; oui
  33. inc ah    ; non -> un caractère de plus
  34. jmp lbl4    ; boucle
  35. lbl3: pop edi
  36. mov al, ah    ; met le résultat en al
  37. xor ah, ah    ; et efface le poids fort
  38. ret
  39. ecrit_mess:     ; écriture d'un message à l'écran
  40. ; entré : ecx -> pointe le message à écrire
  41. ;  ebx -> pointe le fichier ou écrire
  42. ; sortie eax perdu
  43. push edi
  44. push edx
  45. mov edi, ecx   ; pointe la chaine
  46. call long_ch    ; calcule sa longueur
  47. mov edx, eax   ; longueur dans le bon registre
  48. mov eax, 4    ; fonction d'écriture d'une chaine
  49. int 80h    ; écrit le message
  50. pop edx
  51. pop edi
  52. ret
  53. lire:      ; lecture de l'entrée standard
  54. ; entrée : edi -> pointe le tampon de lecture
  55. ;  eax -> nombre de caractères à lire
  56. ; sortie : eax -> nombre de caractères effectivement lus
  57. ;  ecx, edx perdus
  58. push ebx
  59. push ebp
  60. xor ebx, ebx   ; entrée standard
  61. push esi
  62. mov ebp, ebx   ; sert de compteur de caractère
  63. push edi
  64. mov esi, eax   ; sauvegarde le nombre de caractère à lire
  65. mov edx, ebx   ; 0
  66. inc edx    ; on ne lit qu'un caractère
  67. lbl41: mov ecx, edi   ; pointe le tampon de lecture
  68. mov eax, 3    ; fonction de lecture de fichier
  69. int 80h    ; lit le caractère
  70. mov al, [edi]   ; charge le caractère lu
  71. cmp al, 10    ; fin de ligne ?
  72. je lbl40    ; oui -> on retourne
  73. inc ebp    ; un caractère lu en plus
  74. inc edi    ; pointe le caractère suivant
  75. cmp ebp, esi   ; a-t-on tout lu ?
  76. jne lbl41    ; non -> on boucle sur la lecture
  77. lbl40: xor eax, eax   ; oui -> 0
  78. mov [edi], al   ; 0 de fin de chaine
  79. pop edi
  80. mov eax, ebp   ; nombre de caractères lus
  81. pop esi
  82. pop ebp
  83. pop ebx
  84. ret     ; ne produit jamais d'erreur
  85. ;filtre -> enlève les espaces et convertit le tout en majuscule
  86. ; entrée : esi -> chaine d'origine
  87. ;  edi -> chaine filtrée
  88. ; sortie eax -> code d'erreur
  89. ;  ecx -> nombre de caractères de la chaine résultante
  90. ;  les autres registres sont préservés
  91. filtre:
  92. push esi
  93. push edi    ; on doit les rendre tel que
  94. xor ecx, ecx   ; cl -> compteur de caractères
  95. lbl10: lodsb     ; charge un caractère
  96. or al, al    ; fin de chaine ?
  97. jz lbl11    ; oui -> fin du traitement
  98. js lbl14    ; caractère > 128 -> code accent ?
  99. cmp al, 33    ; caractère de contrôle ?
  100. jb lbl10    ; oui -> on saute et on boucle
  101. cmp al,'A'    ; caractère non alphabétique ?
  102. jb lbl12    ; oui -> message d'erreur
  103. cmp al, '['    ; caractère majuscule ?
  104. jb lbl13    ; oui -> on va traiter
  105. cmp al, 'a'    ; caractère non alphabétique ?
  106. jb lbl12    ; oui -> message d'erreur
  107. cmp al, 'z'    ; caractère minuscule ?
  108. ja lbl14    ; non -> message d'erreur
  109. and al, 0dfh   ; conversion du caractère en majuscule
  110. lbl13: stosb     ; écrit le caractère dans la destination
  111. inc ecx    ; un caractère de plus dans la chaine
  112. jmp lbl10    ; on boucle sur le caractère suivant
  113. lbl11: stosb     ; remet le 0 de fin de chaine
  114. pop edi
  115. pop esi    ; restaure les pointeurs de chaine
  116. ret     ; eax vaut 0 -> pas d'erreur
  117. lbl12: mov al, 1    ; erreur 1 -> caractère non alphabétique
  118. pop edi
  119. pop esi    ; restaure les pointeurs de chaine
  120. ret     ; retour avec erreur
  121. lbl14: mov al, 2    ; erreur 2 -> caractère probablement accentué
  122. pop edi
  123. pop esi    ; restaure les pointeurs de chaine
  124. ret     ; retour avec erreur
  125. ;inverse -> inversion de la chaine
  126. ; entrée : esi -> chaine à inverser (source)
  127. ;  edi -> chaine inversé (destination)
  128. ;  edx -> longueur de la chaine
  129. ; sortie : eax, edx perdus
  130. inverse:
  131. push esi    ; a rendre tel que
  132. add edi, edx   ; pointe la fin de la chaine
  133. mov [edi], ch   ; met le 0 de fin de chaine
  134. dec edi    ; pointe le dernier caractère
  135. lbl15: lodsb     ; charge un caractère
  136. mov [edi], al   ; l'inverse
  137. dec edi    ; pointe le précédant
  138. dec edx    ; un caractère en moins
  139. jnz lbl15    ; boucle tant qu'il y en a
  140. pop esi
  141. inc edi    ; edi est revenu à sa position de départ
  142. ret
  143. ; vérification du palindrome
  144. ; entrée : esi -> chaine d'origine
  145. ;  edi -> chaine inversé
  146. ;  ecx -> longueur de la chaine
  147. ; sortie : ZF positionné si palindrome
  148. ;  ecx perdu
  149. verif:
  150. push esi
  151. push edi    ; à rendre tel que
  152. xor eax, eax   ; pas d'erreur à priori
  153. shr ecx,1     ; un contrôle sur la moitié suffit
  154. jz lbl16    ; chaine de 1 caractère -> réussite
  155. repe cmpsb    ; effectue le contrôle
  156. lbl16: pop edi
  157. pop esi    ; récupère les pointeurs d'origine
  158. ret
  159. ; mis ici pour obtenir des sauts courts
  160. lbl21: mov ecx, merreur1   ; charge le message d'erreur
  161. call ecrit_mess   ; et l'affiche
  162. jmp lbl27    ; demande la sortie
  163. lbl22: mov ecx, merreur2   ; charge le message d'erreur
  164. call ecrit_mess   ; et l'affiche
  165. jmp lbl27    ; demande la sortie
  166. ; programme principal
  167. GLOBAL _start
  168. _start:
  169. xor ebx, ebx   ; 0
  170. inc ebx    ; sortie standard
  171. mov ecx, message1
  172. call ecrit_mess   ; écrit le texte à l'écran
  173. lbl20: mov ecx, message3   ; pour lire la chaine
  174. call ecrit_mess   ; écrit le texte à l'écran
  175. xor eax, eax   ; 0
  176. mov edi, tpe   ; pointe le tampon d'entré
  177. lbl23: mov al, 254    ; 254 caractères à lire
  178. call lire    ; lit la chaine
  179. or eax, eax   ; y-a-t-il quelque chose de saisie ?
  180. jz lbl23    ; non -> on insiste
  181. mov ecx, message4
  182. call ecrit_mess   ; écrit le texte de présentation de la chaine
  183. mov ecx, edi   ; pointe le tampon d'entrée
  184. call ecrit_mess   ; écrit la chaine lue
  185. mov esi, edi   ; pointe la chaine lue
  186. mov edi, mot1   ; pointe la chaine filtré
  187. call filtre    ; filtre la chaine
  188. cmp al, 1    ; y-a-t-il eu erreur ?
  189. je lbl21    ; oui -> erreur 1 on va l'écrire
  190. ja lbl22    ; oui -> erreur 2 on va l'écrire
  191. mov edx, ecx   ; sauvegarde la longueur filtré
  192. mov esi, edi   ; pointe la chaine filtré
  193. mov edi, mot2   ; pointe la chaine inversé
  194. call inverse    ; inverse la chaine
  195. call verif    ; vérifie si c'est un palindrome
  196. jz lbl24    ; c'en est un
  197. mov ecx, message7   ; c'est un échec
  198. jmp lbl25
  199. lbl24: mov ecx, message5   ; c'est une réussite
  200. lbl25 call ecrit_mess   ; affiche le résultat
  201. mov ecx, message6   ; annonce le résultat
  202. call ecrit_mess   ; et l'affiche
  203. mov ecx, edi   ; pointe la chaine inversé
  204. call ecrit_mess   ; et l'affiche
  205. lbl27: mov ecx, message8   ; demande pour recommencer
  206. call ecrit_mess   ; l'affiche
  207. mov edi, tpe   ; pointe le tampon d'entrée
  208. lbl26: mov al, 1    ; lire 1 caractère
  209. call lire    ; lit 1 caractère
  210. or eax, eax   ; y-a-t-il un caractère ?
  211. jz lbl26    ; non -> on relie
  212. mov al, [edi]   ; charge le caractère lu
  213. and al, 0dfh   ; filtre les minuscules
  214. cmp al, 'R'    ; faut-il recommencer ?
  215. je lbl20    ; oui -> on ressaisit
  216. cmp al, 'A'    ; faut-il arréter ?
  217. jne lbl26    ; non -> on a saisie un mauvais caractère
  218. mov ecx, message2   ; message de sortie
  219. call ecrit_mess   ; l'affiche
  220. xor eax, eax   ; 0
  221. mov ebx, eax   ; sortie sans erreur
  222. inc eax    ; fonction de sortie du programme
  223. int 80h    ; termine le programme


il ne reste plus à ajouter que le code pour le traitement des accents dans les 3 codages principaux.

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed