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('?')
  16. .CODE 
  18. MAINPROG :
  19.  
  20.    MOV AX, @DATA 
  21.    MOV DS, AX
  23.    MOV AH, 0Fh
  24.    INT 10h
  26.    MOV AH, 0h
  27.    INT 10h
  29.    MOV DH, 3
  30.    MOV DL, 30
  31.    MOV AH, 02h
  32.    INT 10h
  33.    MOV AX, 0900h
  34.    LEA DX, titre
  35.    INT 21h
  37.    MOV DH, 4
  38.    MOV DL, 30
  39.    MOV AH, 02h
  40.    INT 10h
  41.    MOV AX, 0900h
  42.    LEA DX, slign
  43.    INT 21h
  44.  
  45.    MOV DH, 6
  46.    MOV DL, 0
  47.    MOV AH, 02h
  48.    INT 10h
  49.    MOV AX, 0900h 
  50.    LEA DX, carintro 
  51.    INT 21h                     
  53.    MOV AH, 0Ch
  54.    MOV AL, 0Ah
  55.    LEA DX, mot1
  56.    INT 21h
  57.  
  58.    MOV SI, 2
  59.    MOV DI, 0
  60.  
  61. COMPARAISON:
  63.    CMP mot1[SI], '$'
  64.    JE FIN1
  65.  
  66.    CMP mot1[SI], 30h
  67.    JB PONCTU
  68.    CMP mot1[SI], 39h
  69.    JBE VEC2
  70.  
  71.    CMP mot1[SI], 41h
  72.    JB PONCTU
  73.    CMP mot1[SI], 5Ah
  74.    JBE VEC2
  75.  
  76.    CMP mot1[SI], 61h
  77.    JB PONCTU
  78.    CMP mot1[SI], 7Ah
  79.    JBE VEC2
  80.  
  81.    CMP mot1[SI], 82h
  82.    JB PONCTU
  83.    CMP mot1[SI], 97h
  84.    JBE VEC2
  85.  
  86. PONCTU:
  88.    INC SI
  89.    JMP COMPARAISON
  91. VEC2:
  93.    MOV AL, mot1[SI]
  94.    MOV mot2[DI], AL
  95.    INC SI
  96.    INC DI
  97.    JMP COMPARAISON
  99. FIN1:
  100.  
  101.    MOV AL, mot1[SI]
  102.    MOV mot2[DI], AL
  103.  
  104.    MOV DH, 8
  105.    MOV DL, 0
  106.    MOV AH, 02h
  107.    INT 10h
  108.  
  109.    MOV AX, 0900h
  110.    LEA DX, carchaine
  111.    INT 21h
  112.  
  113.    MOV DH, 8
  114.    MOV DL, 27
  115.    MOV AH, 02h
  116.    INT 10h
  117.  
  118.    MOV AX, 0900h
  119.    LEA DX, mot2
  120.    INT 21h
  122.    MOV SI, 0
  124. PALIN:
  126.    CMP SI, DI
  127.    JBE COMP_SI
  128.    PUSH SI
  129.    JMP FIN2
  131. JMP_DI:
  132.    
  133.    JMP COMP_DI
  134.  
  135. JMP_MAJU:
  137.    JMP MAJUSC_SI 
  138.  
  139. COMP_SI:
  141.    CMP mot2[SI], 61h
  142.    JB JMP_DI
  143.    CMP mot2[SI], 7Ah
  144.    JBE JMP_MAJU
  145.  
  146.    CMP mot2[SI], 82h
  147.    JE E_SI
  148.  
  149.    CMP mot2[SI], 83h
  150.    JE A_SI
  151.  
  152.    CMP mot2[SI], 84h
  153.    JE A_SI
  154.  
  155.    CMP mot2[SI], 85h
  156.    JE A_SI
  157.  
  158.    CMP mot2[SI], 88h
  159.    JE E_SI
  161.    CMP mot2[SI], 89h
  162.    JE E_SI
  164.    CMP mot2[SI], 8Ah
  165.    JE E_SI
  167.    CMP mot2[SI], 8Bh
  168.    JE I_SI
  170.    CMP mot2[SI], 8Ch
  171.    JE E_SI
  172.  
  173.    CMP mot2[SI], 8Dh
  174.    JE E_SI       
  176.    CMP mot2[SI], 93h
  177.    JE O_SI
  178.  
  179.    CMP mot2[SI], 94h
  180.    JE O_SI
  181.  
  182.    CMP mot2[SI], 95h
  183.    JE O_SI
  185.    CMP mot2[SI], 96h
  186.    JE U_SI
  187.  
  188.    CMP mot2[SI], 97h
  189.    JE U_SI
  190.  
  191. A_SI:
  192.    MOV mot2[SI], 'A'
  193.    JMP COMP_DI
  194. E_SI:
  195.    MOV mot2[SI], 'E'
  196.    JMP COMP_DI
  197. I_SI:
  198.    MOV mot2[SI], 'I'
  199.    JMP COMP_DI
  200. O_SI:
  201.    MOV mot2[SI], 'O'
  202.    JMP COMP_DI
  203. U_SI:
  204.    MOV mot2[SI], 'U'
  205.    JMP COMP_DI 
  206.  
  207. MAJUSC_SI:
  209.    SUB mot2[SI], 20h
  210.    JMP COMP_DI
  212. JMP_VERIF:
  214.    JMP VERIF
  216. MAJUSC:
  218.    JMP MAJUSC_DI 
  220. COMP_DI:
  222.    CMP mot2[DI], 61h
  223.    JB JMP_VERIF
  224.    CMP mot2[DI], 7Ah
  225.    JBE MAJUSC
  226.  
  227.    CMP mot2[DI], 82h
  228.    JE E_DI
  229.  
  230.    CMP mot2[DI], 83h
  231.    JE A_DI
  232.  
  233.    CMP mot2[DI], 84h
  234.    JE A_DI
  235.  
  236.    CMP mot2[DI], 85h
  237.    JE A_DI
  238.  
  239.    CMP mot2[DI], 88h
  240.    JE E_DI
  242.    CMP mot2[DI], 89h
  243.    JE E_DI
  245.    CMP mot2[DI], 8Ah
  246.    JE E_DI
  248.    CMP mot2[DI], 8Bh
  249.    JE I_DI
  251.    CMP mot2[DI], 8Ch
  252.    JE E_DI
  253.  
  254.    CMP mot2[DI], 8Dh
  255.    JE E_DI       
  257.    CMP mot2[DI], 93h
  258.    JE O_DI
  259.  
  260.    CMP mot2[DI], 94h
  261.    JE O_DI
  262.  
  263.    CMP mot2[DI], 95h
  264.    JE O_DI
  266.    CMP mot2[DI], 96h
  267.    JE U_DI
  268.  
  269.    CMP mot2[DI], 97h
  270.    JE U_DI
  271.  
  272. A_DI:
  273.    MOV mot2[DI], 'A'
  274.    JMP VERIF
  275. E_DI:
  276.    MOV mot2[DI], 'E'
  277.    JMP VERIF
  278. I_DI:
  279.    MOV mot2[DI], 'I'
  280.    JMP VERIF
  281. O_DI:
  282.    MOV mot2[DI], 'O'
  283.    JMP VERIF
  284. U_DI:
  285.    MOV mot2[DI], 'U'
  286.    JMP VERIF
  287.  
  288. MAJUSC_DI:
  290.    SUB mot2[DI], 20h
  292. VERIF:
  294.    MOV AL, mot2[SI]
  295.    CMP mot2[DI], AL
  296.    JNE FIN3
  297.    INC SI
  298.    DEC DI
  299.    JMP PALIN
  300.  
  301. FIN2:
  303.    MOV DH, 10
  304.    MOV DL, 0
  305.    MOV AH, 02h
  306.    INT 10h
  308.    MOV AX, 0900h
  309.    LEA DX, carjuste
  310.    INT 21h
  312.    MOV DH, 12
  313.    MOV DL, 0
  314.    MOV AH, 02h
  315.    INT 10h
  316.  
  317.    MOV AX, 0900h
  318.    LEA DX, carsym
  319.    INT 21h
  321.    MOV DH, 12
  322.    MOV DL, 29
  323.    MOV AH, 02h
  324.    INT 10h
  325.  
  326.    POP SI
  327.    MOV mot2[SI], '$'
  328.  
  329.    MOV AX, 0900h
  330.    LEA DX, mot2
  331.    INT 21h
  332.  
  333.    JMP RECOMMENCE
  335. FIN3:
  337.    MOV DH, 9
  338.    MOV DL, 0
  339.    MOV AH, 02h
  340.    INT 10h
  342.    MOV AX, 0900h
  343.    LEA DX, carfaux
  344.    INT 21h
  345.  
  346. RECOMMENCE:
  348.    MOV DH, 15
  349.    MOV DL, 5
  350.    MOV Ah, 02h
  351.    INT 10h
  352.  
  353.    MOV AX, 0900h
  354.    LEA DX, recommencer
  355.    INT 21h
  356.  
  357.    MOV AH, 01h
  358.    INT 21h
  359.  
  360.    CMP AL, 1Bh
  361.    JE QUIT
  362.    JMP MAINPROG
  363.  
  364. QUIT:
  365.  
  366.    MOV AX, 4C00h
  367.    INT 21h
  369. 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
  4. ; programme effectuant le contrôle du palindrome d'un texte.
  5. ; utilisation : palindrome
  6. ; assemblage : nasm -f elf palindrome.asm
  7. ; édition de lien : ld -o palindrome palindrome.o
  8. ; finition : sstrip palindrome
  9. ; ne fonctionne que sur système linux à processeur 386 ou mieux
  11. BITS  32
  13. SECTION  .data
  14. message1 db "Contrôle de palindrome",10,0
  15. message2 db "... Fin du traitement",10,0
  16. message3 db "Entrer une chaine de caractères : ",0
  17. message4 db "La chaine de caractères est : ",0
  18. message5 db 10,"La chaine que vous avez entrée est un palindrome",10,0
  19. message6 db "La symétrie de la chaine est : ",0
  20. message7 db 10,"La chaine que vous avez entrée n'est pas un palindrome",10,0
  21. message8 db 10,"R(ecommencer) ou A(rréter) ? ",0
  22. merreur1 db 10,"Au moins un caractère n'est pas alphabétique",0
  23. merreur2 db 10,"Il se peut que la chaine comporte des lettres accentuées",0
  25. SECTION  .bss
  26. tpe  resb 256   ; tampon d'entrée
  27. mot1  resb 256   ; chaine d'entrée
  28. mot2  resb 256   ; chaine inversé
  30. SECTION  .text
  32. long_ch:     ; calcule la longueur d'une chaine terminé par un 0
  33. ; entré : edi -> pointe la chaine à mesurer
  34. ; sortie eax -> longueur de la chaine
  35. push edi
  36. xor eax, eax   ; compteur de caractère -> ah
  37. lbl4: scasb     ; a-t-on trouvé le 0 ?
  38. jz lbl3    ; oui
  39. inc ah    ; non -> un caractère de plus
  40. jmp lbl4    ; boucle
  41. lbl3: pop edi
  42. mov al, ah    ; met le résultat en al
  43. xor ah, ah    ; et efface le poids fort
  44. ret
  46. ecrit_mess:     ; écriture d'un message à l'écran
  47. ; entré : ecx -> pointe le message à écrire
  48. ;  ebx -> pointe le fichier ou écrire
  49. ; sortie eax perdu
  50. push edi
  51. push edx
  52. mov edi, ecx   ; pointe la chaine
  53. call long_ch    ; calcule sa longueur
  54. mov edx, eax   ; longueur dans le bon registre
  55. mov eax, 4    ; fonction d'écriture d'une chaine
  56. int 80h    ; écrit le message
  57. pop edx
  58. pop edi
  59. ret
  61. lire:      ; lecture de l'entrée standard
  62. ; entrée : edi -> pointe le tampon de lecture
  63. ;  eax -> nombre de caractères à lire
  64. ; sortie : eax -> nombre de caractères effectivement lus
  65. ;  ecx, edx perdus
  66. push ebx
  67. push ebp
  68. xor ebx, ebx   ; entrée standard
  69. push esi
  70. mov ebp, ebx   ; sert de compteur de caractère
  71. push edi
  72. mov esi, eax   ; sauvegarde le nombre de caractère à lire
  73. mov edx, ebx   ; 0
  74. inc edx    ; on ne lit qu'un caractère
  75. lbl41: mov ecx, edi   ; pointe le tampon de lecture
  76. mov eax, 3    ; fonction de lecture de fichier
  77. int 80h    ; lit le caractère
  78. mov al, [edi]   ; charge le caractère lu
  79. cmp al, 10    ; fin de ligne ?
  80. je lbl40    ; oui -> on retourne
  81. inc ebp    ; un caractère lu en plus
  82. inc edi    ; pointe le caractère suivant
  83. cmp ebp, esi   ; a-t-on tout lu ?
  84. jne lbl41    ; non -> on boucle sur la lecture
  85. lbl40: xor eax, eax   ; oui -> 0
  86. mov [edi], al   ; 0 de fin de chaine
  87. pop edi
  88. mov eax, ebp   ; nombre de caractères lus
  89. pop esi
  90. pop ebp
  91. pop ebx
  92. ret     ; ne produit jamais d'erreur
  94. ;filtre -> enlève les espaces et convertit le tout en majuscule
  95. ; entrée : esi -> chaine d'origine
  96. ;  edi -> chaine filtrée
  97. ; sortie eax -> code d'erreur
  98. ;  ecx -> nombre de caractères de la chaine résultante
  99. ;  les autres registres sont préservés
  100. filtre:
  101. push esi
  102. push edi    ; on doit les rendre tel que
  103. xor ecx, ecx   ; cl -> compteur de caractères
  104. lbl10: lodsb     ; charge un caractère
  105. or al, al    ; fin de chaine ?
  106. jz lbl11    ; oui -> fin du traitement
  107. js lbl14    ; caractère > 128 -> code accent ?
  108. cmp al, 33    ; caractère de contrôle ?
  109. jb lbl10    ; oui -> on saute et on boucle
  110. cmp al,'A'    ; caractère non alphabétique ?
  111. jb lbl12    ; oui -> message d'erreur
  112. cmp al, '['    ; caractère majuscule ?
  113. jb lbl13    ; oui -> on va traiter
  114. cmp al, 'a'    ; caractère non alphabétique ?
  115. jb lbl12    ; oui -> message d'erreur
  116. cmp al, 'z'    ; caractère minuscule ?
  117. ja lbl14    ; non -> message d'erreur
  118. and al, 0dfh   ; conversion du caractère en majuscule
  119. lbl13: stosb     ; écrit le caractère dans la destination
  120. inc ecx    ; un caractère de plus dans la chaine
  121. jmp lbl10    ; on boucle sur le caractère suivant
  122. lbl11: stosb     ; remet le 0 de fin de chaine
  123. pop edi
  124. pop esi    ; restaure les pointeurs de chaine
  125. ret     ; eax vaut 0 -> pas d'erreur
  126. lbl12: mov al, 1    ; erreur 1 -> caractère non alphabétique
  127. pop edi
  128. pop esi    ; restaure les pointeurs de chaine
  129. ret     ; retour avec erreur
  130. lbl14: mov al, 2    ; erreur 2 -> caractère probablement accentué
  131. pop edi
  132. pop esi    ; restaure les pointeurs de chaine
  133. ret     ; retour avec erreur
  135. ;inverse -> inversion de la chaine
  136. ; entrée : esi -> chaine à inverser (source)
  137. ;  edi -> chaine inversé (destination)
  138. ;  edx -> longueur de la chaine
  139. ; sortie : eax, edx perdus
  140. inverse:
  141. push esi    ; a rendre tel que
  142. add edi, edx   ; pointe la fin de la chaine
  143. mov [edi], ch   ; met le 0 de fin de chaine
  144. dec edi    ; pointe le dernier caractère
  145. lbl15: lodsb     ; charge un caractère
  146. mov [edi], al   ; l'inverse
  147. dec edi    ; pointe le précédant
  148. dec edx    ; un caractère en moins
  149. jnz lbl15    ; boucle tant qu'il y en a
  150. pop esi
  151. inc edi    ; edi est revenu à sa position de départ
  152. ret
  154. ; vérification du palindrome
  155. ; entrée : esi -> chaine d'origine
  156. ;  edi -> chaine inversé
  157. ;  ecx -> longueur de la chaine
  158. ; sortie : ZF positionné si palindrome
  159. ;  ecx perdu
  160. verif:
  161. push esi
  162. push edi    ; à rendre tel que
  163. xor eax, eax   ; pas d'erreur à priori
  164. shr ecx,1     ; un contrôle sur la moitié suffit
  165. jz lbl16    ; chaine de 1 caractère -> réussite
  166. repe cmpsb    ; effectue le contrôle
  167. lbl16: pop edi
  168. pop esi    ; récupère les pointeurs d'origine
  169. ret
  171. ; mis ici pour obtenir des sauts courts
  172. lbl21: mov ecx, merreur1   ; charge le message d'erreur
  173. call ecrit_mess   ; et l'affiche
  174. jmp lbl27    ; demande la sortie
  175. lbl22: mov ecx, merreur2   ; charge le message d'erreur
  176. call ecrit_mess   ; et l'affiche
  177. jmp lbl27    ; demande la sortie
  179. ; programme principal
  180. GLOBAL _start
  181. _start:
  182. xor ebx, ebx   ; 0
  183. inc ebx    ; sortie standard
  184. mov ecx, message1
  185. call ecrit_mess   ; écrit le texte à l'écran
  186. lbl20: mov ecx, message3   ; pour lire la chaine
  187. call ecrit_mess   ; écrit le texte à l'écran
  188. xor eax, eax   ; 0
  189. mov edi, tpe   ; pointe le tampon d'entré
  190. lbl23: mov al, 254    ; 254 caractères à lire
  191. call lire    ; lit la chaine
  192. or eax, eax   ; y-a-t-il quelque chose de saisie ?
  193. jz lbl23    ; non -> on insiste
  194. mov ecx, message4
  195. call ecrit_mess   ; écrit le texte de présentation de la chaine
  196. mov ecx, edi   ; pointe le tampon d'entrée
  197. call ecrit_mess   ; écrit la chaine lue
  198. mov esi, edi   ; pointe la chaine lue
  199. mov edi, mot1   ; pointe la chaine filtré
  200. call filtre    ; filtre la chaine
  201. cmp al, 1    ; y-a-t-il eu erreur ?
  202. je lbl21    ; oui -> erreur 1 on va l'écrire
  203. ja lbl22    ; oui -> erreur 2 on va l'écrire
  204. mov edx, ecx   ; sauvegarde la longueur filtré
  205. mov esi, edi   ; pointe la chaine filtré
  206. mov edi, mot2   ; pointe la chaine inversé
  207. call inverse    ; inverse la chaine
  208. call verif    ; vérifie si c'est un palindrome
  209. jz lbl24    ; c'en est un
  210. mov ecx, message7   ; c'est un échec
  211. jmp lbl25
  212. lbl24: mov ecx, message5   ; c'est une réussite
  213. lbl25 call ecrit_mess   ; affiche le résultat
  214. mov ecx, message6   ; annonce le résultat
  215. call ecrit_mess   ; et l'affiche
  216. mov ecx, edi   ; pointe la chaine inversé
  217. call ecrit_mess   ; et l'affiche
  218. lbl27: mov ecx, message8   ; demande pour recommencer
  219. call ecrit_mess   ; l'affiche
  220. mov edi, tpe   ; pointe le tampon d'entrée
  221. lbl26: mov al, 1    ; lire 1 caractère
  222. call lire    ; lit 1 caractère
  223. or eax, eax   ; y-a-t-il un caractère ?
  224. jz lbl26    ; non -> on relie
  225. mov al, [edi]   ; charge le caractère lu
  226. and al, 0dfh   ; filtre les minuscules
  227. cmp al, 'R'    ; faut-il recommencer ?
  228. je lbl20    ; oui -> on ressaisit
  229. cmp al, 'A'    ; faut-il arréter ?
  230. jne lbl26    ; non -> on a saisie un mauvais caractère
  231. mov ecx, message2   ; message de sortie
  232. call ecrit_mess   ; l'affiche
  233. xor eax, eax   ; 0
  234. mov ebx, eax   ; sortie sans erreur
  235. inc eax    ; fonction de sortie du programme
  236. 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