315 lines
5.9 KiB
NASM
315 lines
5.9 KiB
NASM
|
|
section .text
|
|
|
|
|
|
|
|
initialize_video_mode:
|
|
|
|
.prolog:
|
|
push ax
|
|
|
|
; set the video mode correctly
|
|
xor ah, ah ; bios-function (set video mode)
|
|
mov al, 3 ; video mode with 80x25 characters
|
|
int 0x10
|
|
|
|
.epilog:
|
|
pop ax
|
|
ret
|
|
|
|
; cx: len_buffer
|
|
; si: buffer
|
|
; dl: start_x NOTE: Will contain the end of the text on-screen
|
|
; dh: start_y NOTE: Will contain the end of the text on-screen
|
|
print_string:
|
|
|
|
.prolog:
|
|
push di
|
|
push cx
|
|
push bx
|
|
push ax
|
|
|
|
xor di, di ; character index
|
|
|
|
.printing_loop:
|
|
|
|
.set_cursor_position:
|
|
|
|
mov ah, 0x02
|
|
mov bh, 0
|
|
int 0x10
|
|
|
|
.write_character:
|
|
|
|
push cx ; save len_buffer
|
|
|
|
; get the current character
|
|
mov bx, si
|
|
add bx, di
|
|
mov al, [bx]
|
|
; al now contains the current character
|
|
|
|
; set the other needed interrupt values
|
|
mov ah, 0x0a ; wanted function (write character at cursor position)
|
|
mov bh, 0 ; page number
|
|
mov cx, 1 ; repetitions of character
|
|
int 0x10 ; call bios basic draw functions
|
|
|
|
pop cx ; restore len_buffer
|
|
|
|
|
|
|
|
inc dl ; go to next column
|
|
|
|
; go to a new line if needed
|
|
cmp dl, 80
|
|
jb .no_new_line_needed
|
|
xor dl, dl
|
|
inc dh ; increase column
|
|
|
|
.no_new_line_needed:
|
|
|
|
inc di ; go to next character
|
|
|
|
; go further if the string-printing hasn't been finished
|
|
cmp di, cx
|
|
jb .printing_loop
|
|
|
|
.epilog:
|
|
pop ax
|
|
pop bx
|
|
pop cx
|
|
pop di
|
|
|
|
ret
|
|
|
|
|
|
|
|
; ds: source
|
|
; es: destination
|
|
; dx: len_to_copy
|
|
mem_copy:
|
|
push ax
|
|
push bx
|
|
push cx
|
|
push dx
|
|
xor cx, cx
|
|
mov di, dx
|
|
|
|
; ax: first region's value
|
|
; bx: address at index
|
|
; cx: byte_index
|
|
; dx: second region's value
|
|
.loop:
|
|
|
|
; retrieve the source byte at the current index
|
|
mov bx, cx
|
|
mov dx, [bx]
|
|
|
|
; swap the two segments
|
|
; here, ax and bx are used differently.
|
|
mov ax, es
|
|
mov bx, ds
|
|
mov ds, ax
|
|
mov es, bx
|
|
|
|
mov [bx], cx
|
|
|
|
; swap the two segments back
|
|
mov ax, es
|
|
mov bx, ds
|
|
mov ds, ax
|
|
mov es, bx
|
|
|
|
inc cx
|
|
|
|
; if the end has NOT been reached
|
|
cmp cx, di
|
|
jb .loop ; => continue
|
|
|
|
ret
|
|
|
|
|
|
|
|
; ds: region_1
|
|
; es: region_2
|
|
; dx: len_regions
|
|
; ax: result
|
|
mem_equals:
|
|
|
|
push bx
|
|
push cx
|
|
push dx
|
|
push di
|
|
xor cx, cx
|
|
mov di, dx
|
|
|
|
; ax: first region's value
|
|
; bx: address at index
|
|
; cx: byte_index
|
|
; dx: second region's value
|
|
.loop:
|
|
mov bx, cx
|
|
mov dx, [bx]
|
|
|
|
; swap the two segments
|
|
; here, ax and bx are used differently.
|
|
mov ax, es
|
|
mov bx, ds
|
|
mov ds, ax
|
|
mov es, bx
|
|
|
|
mov bx, cx
|
|
mov ax, [bx]
|
|
|
|
cmp ax, dx
|
|
|
|
; swap the two segments back
|
|
mov ax, es
|
|
mov bx, ds
|
|
mov ds, ax
|
|
mov es, bx
|
|
|
|
; jump accordingly to the comparison above
|
|
jne .not_equal
|
|
inc cx
|
|
|
|
cmp cx, di ; if the loop needs to continue
|
|
jb .loop ; (if the end is NOT reached yet)
|
|
|
|
; it goes here if the two regions are completely equal
|
|
pop di
|
|
pop dx
|
|
pop cx
|
|
pop bx
|
|
|
|
mov ax, 1
|
|
ret
|
|
|
|
.not_equal:
|
|
|
|
pop di
|
|
pop dx
|
|
pop cx
|
|
pop bx
|
|
|
|
mov ax, 0
|
|
ret
|
|
|
|
|
|
|
|
; ax: start_sector (lower)
|
|
; bl: start_sector (upper)
|
|
; cx: sector_count
|
|
; dh: drive
|
|
; es: buffer_address (upper)
|
|
; di: buffer_address (lower)
|
|
load_sectors:
|
|
|
|
.prolog:
|
|
push ax
|
|
push bx
|
|
push cx
|
|
push dx
|
|
push si
|
|
xor si, si ; current sector index
|
|
|
|
|
|
|
|
; calculate the distance (in sectors) to the next cylinder boundary
|
|
|
|
; get the index of the current cylinder
|
|
and ax, 0b00111111 ; extract only the sector index
|
|
mov bx, 64 ; get the maximum number of sectors + 1
|
|
sub bx, ax ; invert the result; 1 becomes 63; 63 becomes 1
|
|
cmp ax, 63
|
|
jne .is_not_on_full_cylinder_boundary
|
|
|
|
; if it's indeed on a full cylinder boundary, the first_read-part is unimportant
|
|
mov ax, 0
|
|
set_load_args
|
|
|
|
.is_not_on_full_cylinder_boundary:
|
|
|
|
|
|
|
|
; cx still contains the entry-point's wanted sector_count
|
|
; ax now contains the distance to the next cylinder boundary
|
|
|
|
cmp cx, ax
|
|
jbe .load_data
|
|
|
|
; it gets here if there are more sectors needed after the
|
|
; next cylinder boundary
|
|
; if the number of sectors
|
|
; which are wanted (sector_count) is above the
|
|
; distance to the next cylinder boundary
|
|
|
|
; if not that many sectors are needed, just read as
|
|
; many sectors as are needed in total
|
|
mov cx, bx
|
|
|
|
jmp .load_data
|
|
|
|
|
|
|
|
; sets the arguments for a run of '.load_data' after the
|
|
; first one; aligned on a CHS - cylinder boundary
|
|
.set_load_args:
|
|
|
|
mov bx, sp
|
|
add bx, 4
|
|
mov cx, [bx]
|
|
sub cx, si ; cx = num_missing_sectors
|
|
|
|
cmp cx, 63
|
|
jbe .add_num_missing_sectors_to_sector_index
|
|
|
|
; if this goes here, there are more than 63 sectors
|
|
; still missing to be loaded
|
|
; -> clamp them to 63 so they can be loaded.
|
|
mov cl, 63
|
|
jmp .load_data
|
|
|
|
.add_num_missing_sectors_to_sector_index:
|
|
|
|
add si, cx
|
|
|
|
; loads at most 64 sectors from the disk into the main memory
|
|
; ax: scratchpad
|
|
; bx: start_sector (high part)
|
|
; ch: start_sector (low part)
|
|
; cl: num_sectors
|
|
.load_data:
|
|
|
|
mov ah, 0x02
|
|
mov al, cl
|
|
mov dl, [bx] ; drive
|
|
mov dh, bh ; head
|
|
mov cl, ch ; sector
|
|
mov ch, bl ; cylinder
|
|
mov bx, di ; buffer address (lower)
|
|
int 0x13
|
|
|
|
.continue_if_needed:
|
|
|
|
; check if there still are sectors missing to load
|
|
mov bx, sp
|
|
add bx, 4
|
|
mov cx, [bx] ; sector_count
|
|
|
|
cmp si, cx
|
|
jb .set_load_args
|
|
|
|
|
|
|
|
.epilog:
|
|
|
|
pop si
|
|
pop dx
|
|
pop cx
|
|
pop bx
|
|
pop ax
|
|
|
|
ret
|