;Zadanie 13
;Napisać program, który pobiera z wejścia dwa łańcuchy znakowe, 
;a następnie sprawdza, czy zawierają tą samą liczbę liter, 
;wypisyjąc na ekran stosowny komunikat.
;Program powinien móc wielokrotnie powtarzać operację z różnymi ciągami 
;znaków oraz zakończyć pracę po wciśnięciu przez użytkownika klawisza [ENTER].
;Wykorzystać procedury i stos. Aplikacja ma być idiotoodporna!!!!!!

;Ważne:
;1. Może wprowadzić wszystko.
;2. Sprawdza tylko litery

org 100h

%define bufSize 20

section .text
	
	Start:
		
	
;=================================Procedury=================================
		
		menu:
			mov dx, iMenu
			call wyswietlIQ

			call pralka
			
			
		ret
		
		pralka:
			call nowaLinia
			mov dx,qPierwszy
			call wyswietlIQ
			
			mov dx,firstBuf
			call wczytajCiag
			
			call nowaLinia
			mov bx,[firstBuf.text]
			
			call iloscZnakow
			
			mov dl,[jakaszmienna]
			mov ah,2
			int 21h
			;mov [tempBuf],bx
			;mov dx,tempBuf.text
			;call wyswietlIQ
			;call nowaLinia
			;mov dx, firstBuf.text
			;call wyswietlIQ
			
			call czyKoniec
		
		iloscZnakow:
        pusha                   ;wrzuca wszystkie rejestry na stos
       
        mov bx,0                ;w bx będzie nasza ilość liter w ciągu znaków
        mov di,2                ;do indeksowania
        mov cl,[firstBuf+1]        ;w cl mamy ile znaków jest w buforze, będzie to licznik pętli p
		
p:
        mov dl,[firstBuf+di]       ;do dl przenosimy di+1 element bufora - min. 2, bo 1 i 2 mają odpowiednio maksymalną długość ciągu i faktyczną długość ciągu
        cmp dl,65               ;sprawdzamy, czy di+1 element jest większy/równy niż 65             
        jge costam              ;65 w ASCII to "A". Sprawdzamy po prostu, czy to nie jest jakiś dziwny znak przed "A"
 
poczymstam:                     ;to jest po to, żeby można było do czegoś skoczyć po sprawdzeniu, czy di+1 element jest literą
        inc di                  ;zwiększamy di, żeby sprawdzić następny element
        dec cl                  ;zmniejszamy licznik pętli
        cmp cl,0                ;porównujemy cl do 0
        jg p                    ;jeśli cl większe to robi wszystko od nowa
       
                                ;tutaj już czynią się rzeczy po skończeniu pętli. W bx jest ilość liter w ciągu
        mov [jakaszmienna],bx   ;przenosimy zawartość bx do jakiejś zmiennej - bx zostanie nadpisane po popa
        popa                    ;z powrotem wyrzucamy wszystkie stosy
ret
 
 
costam:                         ;cośtam ma dalej sprawdzać, czy di+1 element jest liczbą
        cmp dl,90
        jle cos                 ;jeśli di+1 element jest "Z" (90 w ASCII to "Z"), to idziemy do czegoś
 
        cmp dl,97               ;jeśli di+1 element nie jest dużą literą, to zaczynamy sprawdzać. W tym celu sprawdzamy, czy jest to jakaś litera po "a"
        jge cosinnego           ;jeśli to jest coś po "a" lub to jest to "a", to wszystko idzie do czegoś innego
 
        jmp poczymstam          ;jeśli to nie jest żadna litera, to po prostu wracamy. Jeśli wygodniej, to można użyć ret'a
 
cos:                            ;coś ma po prostu zwiększyć bx, w którym siedzi ta liczba liter w ciągu
        inc bx                  ;zwiększamy bx
        jmp poczymstam          ;wracamy. Może być też ret
 
cosinnego:                      ;jeśli program doszedł do tego momentu, to oznacza, że di+1 element jest czymś po "a"
        cmp dl,122              ;sprawdzamy, czy di+1 element jest małą literą (122 to "z", więc patrzymy, czy dl jest czymś pomiędzy "a", a "z")
        jle cosjeszczeinnego    ;jeśli jest, to idziemy do czegoś jeszcze innego (w sumie można było iść od razu do czegoś, ale lubię utrudniać ludziom życie, coś jeszcze innego działa identycznie jak coś)
 
        jmp poczymstam          ;jeśli to nie jest mała litera, tylko coś po niej, to wracamy
   
 
cosjeszczeinnego:               ;patrz: coś
        inc bx
        jmp poczymstam
 
 
jakaszmienna db 0               ;w tej zmiennej przechowywana jest długość ciągu znaków (samych liter), trzeba sobie przenosić jej zawartość do różnych rejestrów przed kolejnymi użyciami procedury iloscZnakow, bo się będzie nadpisywać
		
		czyKoniec:
			call nowaLinia
			mov dx,qKoniec
			call wyswietlIQ
			
			call wczytajZnak
			cmp al,13
			je koniec
			jne pralka
		
		wczytajCiag:
			mov ah, 0ah
			int 21h
		ret
		
		wczytajZnak:
			mov ah, 1
			int 21h
		ret
		
		wyswietlIQ:
			mov ah,9
			int 21h
		ret
		
		nowaLinia:
			mov ah,02
			mov dl,0ah
			int 21h
		ret
		
		koniec:
			mov ax, 4C00h
			int 21h
		

;===========================================================================
section .data
;=================================Informacje================================
iMenu db "Program porownuje ilosc liter w podanych przez uzytkownika ciagach znakow.",0ah,0dh,"Maksymalna dlugosc ciagu to 20 znakow.$"
;===========================================================================

;=================================Pytania===================================
qPierwszy db "Podaj pierwszy ciag znakow: $"
qDrugi db "Podaj drugi ciag znakow: $"
qKoniec db "Czy chcesz porownac kolejne dwa ciagi znakow?",0ah,0dh,"TAK - Enter/Nie - cokolwiek.$"
;===========================================================================

;=================================Bufory====================================
firstBuf: 
	.wartosc: db bufSize
	.ilosc: db 0
	.text: times bufSize+1 db "$"

secondBuf: 
	db bufSize
	.ilosc: db 0
	.text: times bufSize+1 db "$"

tempBuf:
	db bufSize
	.ilosc: db 0
	.text: times bufSize+1 db "$"

;===========================================================================