Prac №4

; Читаем массив char-ов cо стандартного потока ввода
; в динамическую память.
; считывание прекращается в тот момент, когда в потоке ввода встретилось char
; со значением 0.
; Память выделяем макросом new.

;мой основной код для прака

include console.inc

ALLONG_SIZE equ 2
ZERO_CODE equ 48

.data
    mark_number dd 0
    array_size    dd 0
    array_pointer dd 0
    array_size_for_pair dd 0
    array_pointer_for_pair dd 0

.code

    ;
    ; параметры:
    ; 1. параметр указатель на начало массива.
    ; 2. указатель на размер массива.
    ; возвращаемое значение
    ; 0 - всё хорошо
    ;

read_array proc
    push ebp
    mov ebp, esp

    ;
    ; зарезервируем место на стеке,
    ; для хранения размера выделенной памяти для массива
    ; выделим 4 байта, в дальнейшем к ним обращаться как
    ; [ebp - 4]
    ;выделяем 4 байта: в младшем байте будет лежать наш char, в остальных трех будут лежать нули
    ;

    sub esp, 20

    ;
    ; В регистре ebx будем сохранять текущий размер считываемого  массива.
    ; в edi - будем хранить текущий адрес массива
    ; в esi - считанный элемент массива
    ;

    push ebx
    push esi
    push edi

    mov ebx, 0

    ;
    ; Делаем размер выделенной памяти
    ; равным 0 изначально.
    ; edi указатель на массив проинициализируем 0, чтобы dispose
    ; не  вызывать.
    ;

    mov dword ptr [ebp - 4], 0
    mov dword ptr [ebp - 8], 0
    mov dword ptr [ebp - 12], 0
    mov dword ptr [ebp - 16], 0
    mov dword ptr [ebp - 20], 0

    mov edi, 0

read_elms_loop:

    ;
    ;будем записывать чары в регистр dl
    ;

    outstrln "input elm: "
    inchar dl
    outstr "read elm: "
    outcharln dl

    ;
    ;записываем в esi значение регистра dl, пополненное нулями
    ;

    movzx esi, dl

    cmp esi, ZERO_CODE
    je after_read_elms_loop

    mov ecx, 8

make_fin_reg:
    ;побитово сдвигаем содержимое стека по данным адресам
    shl dword ptr [ebp - 16], 1
    rcl dword ptr [ebp - 20], 1
    loop make_fin_reg

    add dword ptr [ebp - 16], esi
    cmp dword ptr [ebp - 20], '/-:f'
    jne not_slash_pered_fin
    cmp dword ptr [ebp - 12], 1
    je not_fin

not_slash_pered_fin:
    mov eax, '0-:f'
    and eax, 0ffffffh
    and dword ptr [ebp - 20], 0ffffffh
    cmp dword ptr [ebp - 20], eax
    jne not_fin
    cmp dword ptr [ebp - 16], 'in:-'

    jne not_fin
    jmp after_read_elms_loop

not_fin:

    ;проверка /

    cmp esi, '/'
    jne not_slash
    cmp dword ptr [ebp - 8], 1
    je not_one_slash
    mov dword ptr [ebp - 8], 1
    mov dword ptr [ebp - 12], 1
    jmp read_elms_loop

not_one_slash:
    mov dword ptr [ebp - 8], 0
    mov dword ptr [ebp - 12], 0

not_slash:
    mov dword ptr [ebp - 8], 0

    ; cmp esi, SLASH
    ; outintln esi
    ; jne routine

; first_slash:
;     outstr "input elem: (we got first slash)"
;     inchar dl
;     outstr "read elm: "
;     outcharln dl

;     movzx esi, dl

;     cmp esi, ZERO_CODE
;     je after_read_elms_loop

;     cmp esi, '\'
;     je routine

; routine:

    ;
    ; проверяем есть ли место куда положить очередной элемент
    ; если нет, то запускаем выделение памяти
    ;

    cmp ebx, [ebp - 4]
    jb mem_enough
    outstrln "allong mem"

    ;
    ; на сколько байт будем удлиннять память.
    ; удлинняем на 2 элемента, каждый по 4 байта.
    ; Для этого пересчитываем размер из элементов в байты.
    ; затем прибавляем то, на сколько увеличиваем размер памяти.
    ; и проверяем на переполнение.
    ; эта часть кода отвечает за ситуацию, когда текущий размер памяти >= выделенному
    ;

    mov eax, 1 ; в eax помещаем 4 - размер одного элемента
    mul ebx ; mul - умножение на eax того, что мы передали результат в EDX:EAX
    ; теперь в eax хранится число байтов, которое выделено под элементы
    add eax, ALLONG_SIZE ; allong_size = 2
    jc process_overflow ;jc - jump carry flag

    ;
    ; Сохраним новый размер в переменную,
    ; где мы храним размер.
    ;

    add  dword ptr [ebp - 4], ALLONG_SIZE

    ;
    ; Здесь как параметр макроса передаём размер, который лежит в еах,
    ; сам макрос после работы в регистре eax вернёт
    ; новый указатель на выделенную память.
    ; если памяти нет, то вернётся 0
    ;

    push ebx

    outstr "New memory allocation size: "
    outintln eax

    new eax
    cmp eax, 0
    je process_out_of_mem

    outstr "New pointer to array: "
    outintln eax

    outstr "Old pointer to array: "
    outintln edi

    pop ebx

    ;
    ; переписываем старую память в новую.
    ;

    mov ecx, 0

copy_elms_loop:

    cmp ecx, ebx
    jae after_copy_elms_loop ; прыжок, если всё перекопировали

    mov dl, [edi + ecx * 1]
    mov [eax + ecx * 1], dl

    inc ecx
    jmp copy_elms_loop

after_copy_elms_loop:

    ;
    ; меняем указатели и освобождаем старую память.
    ;

    xchg eax, edi
    cmp eax, 0

    je mem_enough

    push ebx
    dispose eax
    pop ebx


mem_enough:

    ;
    ; Помещаем новый элемент в выделенную память.
    ;

    mov edx, esi

    mov [edi + 1 * ebx], edx

    inc ebx

    jmp read_elms_loop

after_read_elms_loop:
    ;
    ; normal finishing
    ;

    ;
    ; возвращаем адрес массива
    ;

    mov esi, [ebp + 8]
    mov [esi], edi

    ;
    ; возвращаем размер массива
    ;

    mov esi, [ebp + 12]
    mov [esi], ebx

    pop edi
    pop esi
    pop ebx

    mov eax, 0

    mov esp, ebp

    pop ebp

    ret 4 + 4

process_overflow:

    dispose edi ; чистим выделенную память

    pop edi
    pop esi
    pop ebx

    mov eax, 1
    mov esp, ebp
    pop ebp

    ret 4 + 4

process_out_of_mem:

    dispose edi ; чистим выделенную память
    pop edi
    pop esi
    pop ebx

    mov eax, 2

    mov esp, ebp
    pop ebp
    ret 4 + 4

read_array endp


print_array proc

    push ebp
    mov ebp, esp
    push edi


    mov edi, [ebp + 8]
    mov ecx, 0

loop_print_arr:


    cmp ecx, [ebp + 12]
    jae after_loop_print_arr

    outchar byte ptr [edi + 1 * ecx]

    inc ecx

    jmp loop_print_arr

after_loop_print_arr:

    pop edi
    pop ebp

    ret 4 + 4

    print_array endp


main_part proc

    push ebp
    mov ebp, esp

    ; выделим некоторое число байт, будем к ним обращаться, как:
    ; [ebp - 4] - выделенная память для массива
    ; [ebp - 8] - начало предложения
    ; [ebp - 12] - количество знаков препинания в предложении
    ; [ebp - 16] - конец предложения
    ; [ebp - 20] - указатель на массив пар или троек

    sub esp, 24

    push ebx
    push esi
    push edi

    ;
    ; В регистре ebx будем сохранять текущий размер полученного  массива
    ; в esi
    ; в edi будем хранить текущий адрес массива
    ;

    mov ebx, 0

    mov dword ptr [ebp - 4], 0 ; размер выделенной памяти
    mov dword ptr [ebp - 8], 0 ; адрес начала предложения
    mov dword ptr [ebp - 12], 0 ; количество знаков препинания
    mov dword ptr [ebp - 16], 0 ; адрес конца предложения
    mov dword ptr [ebp - 20], 0 ; адрес нового массива пар или троек
    mov dword ptr [ebp - 24], 0 ; для указателя

    mov esi, 0

    mov ecx, 0

    mov edi, [ebp + 16] ; поместили адрес начала текста
;
;     outintln [ebp + 8]
;     outintln [ebp + 12]
;     outintln [ebp + 16]
;     outintln [ebp + 20]
;
;     outstrln "Goyda!!"


; tag_before_start:
;     ;помещаем в [ebp - 8] адрес начала предложения
;     mov dword ptr [ebp - 8], ecx

find_punkt_marks:
    mov edi, [ebp + 16]

    cmp ecx, [ebp + 20]
    jae after_read_elems_of_text_loop

;     outstrln "we print some shit"
;     outcharln byte ptr [edi + 1 * ecx]
;     outintln byte ptr [edi + 1 * ecx]

    cmp byte ptr [edi + 1 * ecx], ','
    je we_got_punkt_mark

    cmp byte ptr [edi + 1 * ecx], '-'
    je we_got_punkt_mark

    cmp byte ptr [edi + 1 * ecx], ':'
    je we_got_punkt_mark

    cmp byte ptr [edi + 1 * ecx], '('
    je we_got_punkt_mark

    cmp byte ptr [edi + 1 * ecx], ')'
    je we_got_punkt_mark

    cmp byte ptr [edi + 1 * ecx], '!'
    je we_got_punkt_mark

    cmp byte ptr [edi + 1 * ecx], '?'
    je we_got_punkt_mark

    cmp byte ptr [edi + 1 * ecx], ';'
    je we_got_punkt_mark

    cmp byte ptr [edi + 1 * ecx], '.'
    je dot

    inc ecx

    jmp find_punkt_marks

    ;если наткнулись на пунктуационный знак, то прибавляем один
    we_got_punkt_mark:
        inc dword ptr [ebp - 12]
        inc ecx
;         outstrln "Its ecx in we_got_punkt_mark"
;         outintln ecx
        jmp find_punkt_marks

    dot:
        outstrln "Sentence has ended"
        outstr "Print ECX - adress of the sentence "
        outintln ecx
        outintln dword ptr [ebp - 12]

        mov edi, [ebp - 20] ; указатель на начало массива троек

        inc ecx
        mov dword ptr [ebp - 16], ecx ; [ebp - 16] - адрес конца предложения (относительно начала текста)


        cmp ebx, [ebp - 4]
        jb enough_memory
        outstrln "Allocation mem in main part"

        mov eax, 12
        mul ebx
        add eax, ALLONG_SIZE * 12

        jc process_main_part_overflow

        add dword ptr [ebp - 4], ALLONG_SIZE

        push ebx

        outstr "New memory allocation size: "
        outintln eax

        new eax
        cmp eax, 0
        je process_main_part_out_of_mem

        outstr "New pointer to array: "
        outintln eax

        outstr "Old pointer to array: "
        outintln edi

        pop ebx

        mov ecx, 0

    copy_array_pair_loop:
        cmp ecx, ebx
        jae after_copying_array
        push esi
        push eax

        mov eax, 12
        mul ecx
        mov esi, eax
        pop eax

        mov edx, [edi + esi]
        mov [eax + esi], edx

        mov edx, [edi + esi + 4]
        mov [eax + esi + 4], edx

        mov edx, [edi + esi + 8]
        mov [eax + esi + 8], edx

        pop esi

        inc ecx

        jmp copy_array_pair_loop

    after_copying_array:
;         outstrln "we print new adreess"
;         outintln eax

        xchg eax, edi

;         outstrln "we print new adreess"
;         outintln edi

        cmp eax, 0
        je enough_memory

        push ebx
        push ecx
        push edi
        dispose eax
        pop edi
        pop ecx
        pop ebx

    enough_memory:
;         outstrln "we have enough mem"
        mov ecx, dword ptr [ebp - 16]
        mov eax, 12
        mul ebx
        push esi

        mov esi, [ebp - 12] ; в esi поместили число знаков препинания
        mov [edi + eax], esi

        mov [ebp - 12], dword ptr 0 ; обнуляем число знаков препинания
;         outstrln "We print the number of punkt"
;         outintln esi

        mov esi, [ebp - 8] ; в esi поместили адрес начала предложения
        mov [edi + eax + 4], esi
;         outstrln "We print the adress begin"
;         outintln esi

        mov esi, [ebp - 16] ;в esi поместили конец предложения
        mov [edi + eax + 8], esi
;         outstrln "We print the adress end"
;         outintln esi

        pop esi
        inc ebx

        mov dword ptr [ebp - 20], edi

        mov dword ptr [ebp - 8], ecx

        mov dword ptr [ebp - 24], edi

        jmp find_punkt_marks

    after_read_elems_of_text_loop:

        newline
        outstrln "Finish of creating array of triples"

        mov edi, dword ptr [ebp - 24]
    ;
    ; normal finishing
    ;

    ;
    ; возвращаем адрес массива
    ;
        mov edx, [ebp + 8]
        mov [edx], edi

    ;
    ; возвращаем размер массива
    ;
        mov edx, [ebp + 12]
        mov [edx], ebx

        outstr "size of arr: "
        outintln ebx

        pop edi
        pop esi
        pop ebx

        mov eax, 0

        mov esp, ebp
        pop ebp
        ret 4 + 4 + 4 + 4


    process_main_part_overflow:

        outstrln "We have overflow!"

        dispose edi ; чистим выделенную память
        pop edi
        pop esi
        pop ebx

        mov eax, 1

        mov [ebp - 12], dword ptr 0

        mov esp, ebp
        pop ebp
        ret 4 + 4 + 4 + 4

    process_main_part_out_of_mem:
        dispose edi ; чистим выделенную память
        pop edi
        pop esi
        pop ebx

        mov eax, 2

        mov [ebp - 12], dword ptr 0

        mov esp, ebp
        pop ebp
        ret 4 + 4 + 4 + 4

main_part endp

print_sentence_array proc

    push ebp
    mov ebp, esp
    push edi

    mov edi, [ebp + 8]  ; arr_pointer_pair
    mov ebx, [ebp + 16] ; arr_pointer

    mov ecx, 0
    mov eax, 0

    outstrln "Process of printing array of pairs:"
    newline

loop_print_mas:

    cmp ecx, [ebp + 12]
    jae after_loop_print_mas

    mov eax, 12
    mul ecx

    outstr "Size: "
    outintln dword ptr [edi + eax]
    mov edx, dword ptr [edi + eax + 4]

print_mas:

    cmp edx, [edi + eax + 8]
;     outintln dword ptr [edi + eax + 4]
;     outintln dword ptr [edi + eax + 4]
    jae next_print
    outchar byte ptr [ebx + edx]
    inc edx
    jmp print_mas

next_print:

    inc ecx
    newline
    newline
    jmp loop_print_mas

after_loop_print_mas:

    pop edi
    pop ebp
    ret 4 + 4 + 4
print_sentence_array endp

; def InsertionSort(A):
;     for i in range(1, len(A)):
;         # В new_elem сохранили значение A[i]
;         new_elem = A[i]
;         # Начиная с элемента A[i - 1]
;         j = i - 1
;         # все элементы, которые больше new_elem
;         while j >= 0 and A[j] > new_elem:
;             # сдвигаем вправо на 1
;             A[j + 1] = A[j]
;             j -= 1
;         # На свободное место записываем new_elem
;         A[j + 1] = new_elem

insertionSort proc

    push ebp
    mov  ebp, esp

    sub esp, 8

    push ebx
    push esi
    push edi
    push edx

    ;ebp + 8    указатель на массив
    ;ebp + 12   число элементов в массиве

    ; установили есх на число элементов

    ; установили есх на последний элемент массива
    mov eax, dword ptr [ebp + 12] ; количество элементов массива пар
    mov ecx, 12 ; 12 * [ebp + 12]
    mul ecx
    mov ecx, eax

    mov eax, 0          ; eax = 'i'
    xor ebx, ebx        ; ebx = 'j'
    mov esi, dword ptr [ebp + 8]    ; esi - адрес массива

    mov dword ptr [esp - 4], 0 ; адрес начала
    mov dword ptr [esp - 8], 0 ; адрес конца

    forloop:
        ;If 'i' >= the number of items, exit the loop
        cmp eax, ecx
        jge endloop

        ; сохраняем наше значение количества элементов
        push ecx

        ;сохраним в есх числовое значение key
        mov ecx, dword ptr [esi + eax]

        mov edx, dword ptr [esi + eax + 4]
        mov dword ptr [esp - 4], edx

        mov edx, dword ptr [esi + eax + 8]
        mov dword ptr [esp - 8], edx

        ;j = i-1
        mov ebx, eax
        sub ebx, 12

        whileloop:
            ;если j < 0, покидаем цикл
            cmp ebx, 0
            jl endwhile

            ;если array[j] <= key, покидаем цикл
            cmp dword ptr [esi + ebx], ecx
            jle endwhile

            mov edx, dword ptr [esi + ebx]
            mov dword ptr [esi + ebx + 12], edx

            mov edx, dword ptr [esi + ebx + 4]
            mov dword ptr [esi + ebx + 4 + 12], edx

            mov edx, dword ptr [esi + ebx + 8]
            mov dword ptr [esi + ebx + 8 + 12], edx

            ;j--
            sub ebx, 12

            ;Go back to the top of this loop
            jmp whileloop

        endwhile:

        ;array[j+1] = key
        mov dword ptr [esi + ebx + 12], ecx

        mov edx, [esp - 4]
        mov dword ptr [esi + ebx + 12 + 4], edx

        mov edx, [esp - 8]
        mov dword ptr [esi + ebx + 12 + 8], edx
        ;i++
        add eax, 12

        ;restore our "number of items" value
        pop ecx

        jmp forloop

    endloop:

    pop edx
    pop edi
    pop esi
    pop ebx

    mov esp, ebp
    pop ebp

    ret 4 + 4
insertionSort endp




start:

   push offset array_size
   push offset array_pointer
   call read_array

   outstr "array read, size: "
   outintln array_size

   push array_size
   push array_pointer
   call print_array

   newline

   push array_size
   push array_pointer
   push offset array_size_for_pair
   push offset array_pointer_for_pair
   call main_part

   newline

   push array_pointer
   push array_size_for_pair
   push array_pointer_for_pair
   call print_sentence_array

   push array_size_for_pair
   push array_pointer_for_pair
   call insertionSort
;
   push array_pointer
   push array_size_for_pair
   push array_pointer_for_pair
   call print_sentence_array

   exit 0
end start