;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 "$"

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