Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- ; Читаем массив 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
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement