;student: Petr Sopf
;login: xsopfp00

%include "rw32-2017.inc"

%macro WRITE_ARRAY 4
	push esi
	push ecx
	push eax
	mov esi,%1
   	mov ecx,%2
%%writeElement:
  	lods%3
   	call Write%4
   	cmp ecx,1
   	jbe %%skipComma
   	mov al,','
   	call WriteChar
%%skipComma:
   	loop %%writeElement

   	call WriteNewLine
   	pop eax
   	pop ecx
   	pop esi
%endmacro

%macro F13_CALL 3
	mov esi,%2
	mov ecx,%3
	call %1
%endmacro

%macro F2_CALL 5
	push %5
	push %4
	push %3
	push %2
	call %1
	add esp,16
%endmacro

section .data
    A1_1 dd 1245184,983040,1048576,393216,1048576
    A2_1 dd 1245184,983040,1048576,393216,1048576
    B2 dd 14420540,1800817106,2491283952,4231953432,2101597154
    A3_1 dw 1792,768,1024,-1536,1024

section .text
;
;--- �kol 1 ---
;
;Naprogramujte funkci "getMax", kter� v poli 32bitov�ch ��sel bez znam�nka nalezne maximum a vr�t� jeho hodnotu.
;
;unsigned int getMax(ESI, ECX)
;  - vstup:
;    - ESI: ukazatel na za��tek pole 32bitov�ch prvk� bez znam�nka
;    - ECX: po�et prvk� pole (32bitov� hodnota bez znam�nka)
;  - v�stup:
;    - EAX: hodnota 32bitov�ho maxima bez znam�nka
;  - funkce mus� zachovat obsah v�ech registr�, krom� registru EAX a p��znakov�ho registru

getMax:
    push ebx
    mov ebx, -1

    loopArray:
        inc ebx
        cmp eax, [esi+4*ebx]
        jl isGreater
        jmp next

        isGreater:
            mov eax, [esi+4*ebx]

        next:
            cmp ebx, ecx
            jl loopArray

      pop ebx
    ret

;
;--- �kol 2 ---
;
;Naprogramujte funkci "addX", kter� k jednotliv�m prvk�m pole A p�i�te hodnotu x a jednotliv� v�sledky ulo�� do pole B.
;
;D�lka pol� je d�na parametrem N. Funkce mus� b�t naprogramov�na s vyu�it�m p�ed�v�n� parametr� na z�sobn�ku tak,
;�e parametry funkce se ukl�daj� na z�sobn�k od posledn�ho do prvn�ho (zprava doleva),
;parametry ze z�sobn�ku ukl�z� volaj�c� a v�sledek funkce se vrac� v registru EAX.
;
;int addX(unsigned int *pA, unsigned int N, unsigned int x, unsigned int *pB)
;  - vstup:
;    pA: ukazatel na pole A (pole A obsahuje 32bitov� hodnoty bez znam�nka)
;     N: po�et prvk� pole A (32bitov� ��slo bez znam�nka)
;     x: hodnota x (32bitov� ��slo bez znam�nka)
;    pB: ukazatel na pole B (pole B bude obsahovat 32bitov� hodnoty bez znam�nka)
;  - v�stup:
;    - EAX =  0: v p��pad�, �e nenastala ��dn� chyba
;    - EAX = -1: v p��pad�, �e je neplatn� ukazatel *pA (tj. pA == 0)
;    - EAX = -2: v p��pad�, �e je neplatn� ukazatel *pB (tj. pB == 0)
;  - funkce mus� zachovat obsah v�ech registr�, krom� registru EAX a p��znakov�ho registru

addX:
   push ebx
   push ecx
   push edx

   mov ebp, esp
   sub esp, 4

   mov eax, [ebp+16];A
   mov ecx, [ebp+20];N
   mov edx, [ebp+28];B

   mov ebx, 0
   loopClear:
    mov [edx+ecx*4-4], ebx

    loop loopClear

   mov ebx, [ebp+24];x
   mov ecx, [ebp+20];N

   cmp eax, 0
   je errorA

   cmp edx, 0
   je errorB

   loopall:
    add [edx+ecx*4-4], ebx
    mov ebx, [eax+ecx*4-4]
    add [edx+ecx*4-4], ebx
    mov ebx, [ebp+24]
    loop loopall

   jmp end

   errorA:
       mov eax, -1
       jmp end

   errorB:
       mov eax, -2
       jmp end

   end:
       mov esp, ebp
       pop edx
       pop ecx
       pop ebx
       ret

;
;--- �kol 3 ---
;
;Naprogramujte funkci "sort", kter� vzestupn� (od nejmen��ho k nejv�t��mu) se�ad� pole 16bitov�ch prvk� se znam�nkem A.
;
;Uk�zka algoritmu �azen� v jazyce C:
;
;int *pA, i, j, N;
;for(i = 0; i < N; i++) {
;    for(j = i + 1; j < N; j++) {
;        if (pA[i] > pA[j]) { tmp = pA[i]; pA[i] = pA[j]; pA[j] = tmp; }
;    }
; }
;
;void sort(short *pA, unsigned int N)
;  - vstup:
;    ESI: ukazatel na pole A (pole A obsahuje 16bitov� hodnoty se znam�nkem)
;    ECX: po�et prvk� pole A (32bitov� ��slo bez znam�nka)
;  - funkce mus� zachovat obsah v�ech registr�, krom� registru EAX a p��znakov�ho registru

sort:
    push eax
    push ebx
    push ecx
    push edx

    sub ecx, 1

    mov eax, 0 ; i=0
    firstFor:
        cmp eax, ecx
        jge done

        mov ebx, eax ; j = i
        secondFor:
            inc ebx
            push ecx
            mov ecx, 0
            mov edx, 0
            mov dx, [esi+2*eax] ;pA[i]
            cmp dx, [esi+2*ebx]
            jg greater ;pA[i] > pA[j]
            jmp endSecond

            greater:
                mov cx, dx ;tmp = pA[i]
                mov dx, [esi+2*ebx]
                mov [esi+2*eax], dx ;pA[i] = pA[j];
                mov [esi+2*ebx], cx

            endSecond:
                pop ecx
                cmp ebx, ecx
                jl secondFor ;j < N

        cmp eax, ecx
        jl incEax ;i < N

    done:
        pop edx
        pop ecx
        pop ebx
        pop eax
        ret

    incEax:
        inc eax
        jmp firstFor

main:
    mov ebp, esp; for correct debugging
    push ebp
    mov ebp,esp

    WRITE_ARRAY A1_1, 5, d, UInt32
    F13_CALL getMax, A1_1, 5
    call WriteUInt32
    call WriteNewLine

    WRITE_ARRAY A2_1, 5, d, UInt32
    WRITE_ARRAY B2, 5, d, UInt32
    F2_CALL addX, A2_1, 5, 4127762612, B2
    call WriteUInt32
    call WriteNewLine
    call WriteFlags
    WRITE_ARRAY A2_1, 5, d, UInt32
    WRITE_ARRAY B2, 5, d, UInt32

    WRITE_ARRAY A3_1, 5, w, Int16
    F13_CALL sort, A3_1, 5
    call WriteInt16
    call WriteNewLine
    WRITE_ARRAY A3_1, 5, w, Int16

    pop ebp
    ret