[FASM] Porównywanie ciągów znaków

0

Treść zadania:
Program ma zawierać procedurę, dokonującą porównania dwóch ciągów znaków. Oba ciągi znaków zakończone są '$'. Procedura otrzymuje OFFSET przeszukiwanego stringa w DX i szukanego w rejestrze BX. Procedura w AL zwraca dodatkowy parametr przekazany w AH jest nr elementu do końca stringa DX, od którego procedura ma przeszukiwać string DX i ostatecznie zwrócić indeks ostatniego wystąpienia stringu BX w DX.

Prosiłbym o nakierowanie gdzie robię błąd

                 sts segment 'stack' stack                
    	db 512 dup(0)                    
sts ends                                 
                                         
dane segment                             
                         
napis1 db 100h DUP (?)  
napis2 db 100h DUP (?)                                          
                                                                
dlugosc1 dw 0      
dlugosc2 dw 0                                                   
                                                                
licznik dw 0       
indeks dw 0  
indeks2 dw 0     
l dw 0             
                   
tekst1 db "Podaj pierwszy ciag znakow", 0dh,0ah, "$"
tekst2 db 0dh,0ah, "Podaj drugi ciag znakow", 0dh,0ah, "$"
tekst3 db 0dh,0ah, "Podaj nr indeksu", 0dh,0ah, "$"
tekst4 db 0dh,0ah, "nr indeksu:", 0dh,0ah, "$"
tekst5 db 0dh,0ah, 0dh,0ah, "nacisnij dowolny klawisz...$"
                                                                
ends   	                                                        
                                                                
prog segment                                                    
 assume cs:prog,ds:dane,ss:sts                                  
P486N                                                           
                                                                
odczytaj1:                                                                                                              
                                                                
        mov     ah,0                                            
        int     16h                                             
                                                                
        cmp     al,'$'                                          
        je      koniec1                                                                                                 
                                                                          
        cmp     al,'A'                                                    
        jl      odczytaj1                                                    
                                                                          
        cmp     al,'Z'                                                    
        jle     wczytaj1                                         
                                                                          
        cmp     al,'a'                                                    
        jl      odczytaj1                                                    
                                                                          
        cmp     al,'z'                                                    
        jg     odczytaj1                                                                                 
                                                                
wczytaj1:                                                        
        mov     si,licznik                                                  
        add     [napis1+si],al                                  
                                                                
        add     dlugosc1,1                                       
                                                                
        mov     ah,0eh                                          
        int     10h                                             
                                                                
        add     licznik,1                                       
                                                                
powtorz1:                                                        
        jmp     odczytaj1                                        
                                                                
koniec1:                                                                                                                                   
        mov     si,licznik                                                
        add     [napis1+si],al                                  
                                                                                                                                
RET                                                             
                                                                
                                                                
                                                                
odczytaj2:   ;odczytaj druga liczbe                                                                                                                   
                                                                
        mov     ah,0                                            
        int     16h                                             
                                                                
        cmp     al,'$'                                          
        je      koniec2                                                                                                 
                                                                          
        cmp     al,'A'                                                    
        jl      odczytaj2                                                    
                                                                          
        cmp     al,'Z'                                                    
        jle     wczytaj2                                         
                                                                          
        cmp     al,'a'                                                    
        jl      odczytaj2                                                    
                                                                          
        cmp     al,'z'                                                    
        jg     odczytaj2                                                                                 
                                                                
wczytaj2:                                                        
        mov     si,licznik                                                  
        add     [napis2+si],al                                  
                                                                
        add     dlugosc2,1                                       
                                                                
        mov     ah,0eh                                          
        int     10h                                             
                                                                
        add     licznik,1                                       
                                                                
powtorz2:                                                        
        jmp     odczytaj2                                        
                                                                
koniec2:                                                                                                                                   
        mov     si,licznik                                               
        add     [napis2+si],al                                                                
RET                                
   
wczytaj_indeks:																									     																															   
   	mov	dx,0	                                                            
	mov     bx,10	    								                                                    
	mov	cx,3	                                               
										       			  			    
petl:		   								                                                    
    	mov	ax,dx                                                                   
	mul	bx	                                                                                       
	mov	dx,ax                                                     
		   			     
czytaj: 				     					       
	mov	ah,0                                                 
	int	16h								       
										       
	cmp	al,'0'	                                       
	jl	czytaj                           
			     											       
	cmp	al,'9'                                                
	jg	czytaj								        
			      							        
	sub	al,48	           
	mov	ah,0	                                      
										        
	add	dx,ax                         
		   									
	add	al,48 
	mov	ah,0eh          
	int	10h										  
		    		    							
	loop	petl 
RET                                 
                                    
porownaj:                           
        mov     l,0                            
        mov     bp,dx  
                                                                                 
        mov     cx,dlugosc1       
                                                                             
petla:                             
        mov     si,indeks ;
                                   
        mov     al,ds:[bp+si]
        mov     si,l                         
                                                                                            
        cmp     al,[bx+si]                                                                                                               	   
           	                     	                                                                                                                                    
        jne     nierowne                                        
                                                                
rowne:                                                          
        add     l,1                             
        mov     ax,l                            
                                                    
        cmp     ax,dlugosc2                                                                         
        jne     koniec_petli                                     
                                                                 
dodaj_licznik:                                                   
        mov     ax, indeks
        mov     indeks2,ax                                       
        mov     l,0                                              
        jmp     koniec_petli                                     
                                                                 
nierowne:                                                        
        mov     l,0                
        mov     si,l               
        cmp     al,[bx+si] 
        je      rowne                                                                                   
                                                                 
koniec_petli:                                                    
        add     indeks,1                                         
        loop    petla                                            
                          
        mov     ah,0                                                
        mov     ax,indeks2                      
kon:                                                                     
RET                       
                                                                                                 
wyswietl:	    						 				                            
	mov ah,0    			
	mov bl,10                       
	div bl                          
		                        
	mov dl,ah	
	add dl,30h                                        
	push dx 					       
							       
	mov ah,0					       
	div bl		
	add ax,3030h					       
	push ax 					       
	mov dl ,al					       
							       
	mov ah,2	 ;wyswielt setki
	int 21h 		        
				
	pop ax			     
	mov dl,ah	;wyswietl dziesiatki
	mov ah,2			    
	int 21h 			    
					    
	pop dx		       ;wyswietl jednostki
	mov ah,2			   
	int 21h                          
                               
RET	                                                                               
               	                                                 
start:                                                           
       	mov	ax,seg dane                                      
       	mov  	ds,ax                                            
       	                                                         
       	mov     ah,0                        
        mov     al,3                                             
        int     10h                                              
                                                                
        mov     dx,offset tekst1                                
	mov     ah,09h                                          
	int     21h                                             
                                                                                 
        mov     licznik,0                                                         
        call    odczytaj1                                
                                                                 
        mov     dx,offset tekst2                                
	mov     ah,09h                                          
	int     21h                                               
                                                                
        mov     licznik,0                                                        
        call    odczytaj2                                                   
                                     
        mov     dx,offset tekst3                                
	mov     ah,09h                                           
	int     21h                                              
                                                                 
        ;mov     ah,0                                   
        ;int     16h                                              
        ;mov     ah,0 
        call    wczytaj_indeks
        
        mov     bx,dlugosc1   
        ;sub     al,48                                     
        sub     bx,dx ;ax                                           
        mov     indeks,bx   
                                                                                     
        add     al,48                                                         
        mov     ah,0eh             
        int     10h                                              
                                                                 
        mov     ax,indeks                                        
        sub     dlugosc1,ax                                                       
                                                                 
        mov     dx,offset tekst4                                      
	mov     ah,09h                                                
	int     21h                                              
                                                                 
        mov     dx,offset napis1                                 
        mov     bx,offset napis2                                                              
        call    porownaj                                                                                                      
                                                                      
        call    wyswietl                                                        
                                                                       
        mov     dx,offset tekst5                                      
	mov     ah,09h                                                
	int     21h                                                   
                                                                                                                                                                                                                                                            
        mov     ah,0                            
        int     16h                                                   
       	                                                              
 	mov 	ah,4ch                    
	int    	21h                                                   
prog ends                                                             
end start       
0

Nie czytałem twojego kodu ponieważ już w samym pytaniu jest dużo pomyłek i niedomówień co dopiero w kodzie się można spodziewać ?!

  1. Funkcja porównująca dwa stringi to nie to samo co funkcja wyszukująca jeden string w drugim.
  2. Z kąd ci przyszło do głowy, że funkcja wyszukująca jeden string w drugim ma zwracac index OSTATNIEGO wystąpienia ???
    Zwróć pierwsze znalezionwe wystąpienie, nastwepnie w zaleznosci od reakcji usera czy tam innych czynników kończysz przeszukiwanie lub szukasz nastepnego wystapienia.
  3. Od siebie dodam, że dobrze jest zrobić taki myk (nie zaawsze można) z funkcją zamieniającą duże litery na małe - wtedy wyszukujesz frazę bez względu na wielkość liter.
  4. Masz tu implementację w fasmie operacji na łańcuchach znaków. To jest dla ansi oraz unicode lecz możesz podpatrzeć techniki i zastosować je dla swoich dosowych stringów kończonych za pomocą znaku dolara.
    https://docs.google.com/open?id=0Bzkm-XARAFtnV0xDaHBaT3h3Y2M

Zwróć uwagę na funkcje ansiCmpx oraz unicodeCmpx porównują dwa łańcuchy znaków bez względu na wielkość liter.

0

No niestety taką treść zadania dostałem od prowadzącego, dzięki wielkie za odpowiedz zabieram sie do przeglądania link a.

1 użytkowników online, w tym zalogowanych: 0, gości: 1