.MODEL      SMALL

Kod             SEGMENT
                ORG         100h
                ASSUME      CS:Kod, DS:Kod, SS:Kod

Start:          jmp         Start2

Napis1          DB          "0$00000000000000", "$"
Napis2          DB          "0$00000000000000", "$"
NapisWynik      DB          "0$00000000000000", "$"
Liczba1         DW          ?
Liczba2         DW          ?
Wynik           DW          ?
Endl            DB          13, 10, "$"
s_Podaj1        DB          "Podaj pierwsza liczbe: ", "$"
s_Podaj2        DB          "Podaj druga liczbe:    ", "$"
s_Wynik         DB          "Wynik dodawania: ", "$"
s_Blad          DB          "Przekroczono zakres!", "$"
s_Poczatek      DB          "Program dodaje dwie liczby z zakresu [-32768...32767]!", "$"

ReadChar        MACRO
                mov         ah, 08h
                int         21h
                ENDM

PrintChar       MACRO       Char
                mov         dl, Char
                mov         ah, 02h
                int         21h
                ENDM

PrintString     MACRO       String
                mov         dx, OFFSET String
                mov         ah, 09h
                int         21h
                ENDM

Start2:
                PrintString s_Poczatek
                PrintString Endl

Poczatek:
                PrintString s_Podaj1

                ;           pobierz pierwsza liczbe
                mov         si, OFFSET Napis1
                call        ReadNum

                PrintString Endl

                ;           przygotuj pierwsza liczbe 16-bitowa
                mov         si, OFFSET Napis1
                call        StrToNum
                mov         Liczba1, ax

                PrintString s_Podaj2

                ;           pobierz druga liczbe
                mov         si, OFFSET Napis2
                call        ReadNum

                PrintString Endl

                ;           przygotuj druga liczbe 16-bitowa
                mov         si, OFFSET Napis2
                call        StrToNum
                mov         Liczba2, ax

                ;           przygotuj wynik dodawania 32-bitowy
                mov         ax, Liczba1
                mov         bx, Liczba2
                call        SumNum

                ;           przygotuj wynik jako ciag znakow
                mov         si, OFFSET NapisWynik
                call        NumToStr

                PrintString s_Wynik
                PrintString NapisWynik

                jmp         Koniec
Blad:
                PrintString s_Blad
                PrintString Endl
                jmp         Poczatek
Koniec:
                mov         ax, 4C00h
                int         21h

;               +++         Read Number
ReadNum:
                mov         cx, 0
                mov         dx, 0
ReadNum_Czytaj:
                ReadChar                            ; wczytaj znak
                cmp         al, 13
                je          ReadNum_Return          ; jesli enter to przejdz na koniec
                cmp         al, 45
                je          ReadNum_Minus
                cmp         al, '0'
                jb          ReadNum_Czytaj          ; jesli mniejsze od '0' to przejdz na koniec
                cmp         al, '9'
                ja          ReadNum_Czytaj          ; jesli wieksze od '9' to przejdz na koniec
                mov         dl, al
                PrintChar   al                      ; wyswietl ten znak
                mov         [si], dx
                inc         si
                mov         cx, 1
                jmp         ReadNum_Czytaj
ReadNum_Minus:
                cmp         cx, 1
                je          ReadNum_Czytaj
                mov         cx, 1
                mov         byte PTR [si], "-"
                inc         si
                PrintChar   "-"
                jmp         ReadNum_Czytaj

ReadNum_Return:
                mov         byte PTR [si], "$"
                ret
;               ---         Read Number

;               +++         String To Number
StrToNum:
                push        si
                mov         ax, 0
                mov         bx, 0
                mov         cx, 10                  ; podstawa
StrToNum_Petla:
                mov         bl, [si]                ; czytaj znak
                inc         si
                cmp         bl, 24h
                je          StrToNum_Koniec         ; jesli '$' to koniec
                cmp         bl, "-"
                je          StrToNum_Petla
                sub         bl, '0'                 ; odejmij kod znaku '0'
                mul         cx                      ; pomnoz przez podstawe
                jc          StrToNum_Zakres
                jo          StrToNum_Zakres
                add         ax, bx                  ; dodaj
                jc          StrToNum_Zakres
                jo          StrToNum_Zakres
                jmp         StrToNum_Petla
StrToNum_Ujemna:
                neg         ax
                jmp         StrToNum_Return
StrToNum_Zakres:
                mov         ax, 0
                pop         si
                jmp         Blad
StrToNum_Koniec:
                pop         si
                mov         bl, [si]
                cmp         bl, "-"
                je          StrToNum_Ujemna
StrToNum_Return:
                ret
;               ---         String To Number

;               +++         Sum Numbers
SumNum:
                mov         dx, 0
                add         ax, bx                  ; dodaj liczby
                jo          SumNum_Po               ; jesli flaga przepelnienia to skocz
                mov         bx, 0
                cmp         bx, ax                  ; jesli liczba jest wieksza od 0 to nie rob nic
                jle         SumNum_Return
                mov         dx, 0FFFFh              ; jesli mniejsza to wstaw jedynki na pierwszych 16 bitach (ujemna)
                jmp         SumNum_Return
SumNum_Po:
                jc          SumNum_Pc               ; jesli flaga przeniesienia to skocz
                jmp         SumNum_Return           ; jesli nie to nic nie rob
SumNum_Pc:
                mov         dx, 0FFFFh              ; wstaw jedynki na 16 pierwszych bitach (ujemna)
                jmp         SumNum_Return
SumNum_Return:
                ret
;               ---         Sum Numbers

;               +++         Number To String
NumToStr:
                mov         cx, 0
                cmp         dx, 8000h
                jae         NumToStr_Minus
NumToStr_Petla1:
                cmp         ax, 0
                je          NumToStr_Petla2
                mov         bx, 10                  ; podstawa
                div         bx                      ; dziel
                push        dx                      ; reszte daj na stos
                mov         dx, 0
                inc         cx
                jmp         NumToStr_Petla1
NumToStr_Petla2:
                cmp         cx, 0
                je          NumToStr_Return
                pop         dx                      ; zdejmij ze stosu
                add         dx, '0'                 ; dodaj kod znaku '0'
                mov         [si], dx                ; wpisz znak
                inc         si
                loop        NumToStr_Petla2
                mov         byte PTR [si], '$'      ; na koniec wpisz '$'
                jmp         NumToStr_Return
NumToStr_Minus:
                mov         byte PTR [si], '-'
                inc         si
                neg         ax
                mov         dx, 0
                jmp         NumToStr_Petla1
NumToStr_Return:
                ret
;               ---         Number To String

Kod             ENDS

                END         Start