piko.asm

	BITS 16

;***********
;BOOTLOADER
;***********

;constants instead of magic numbers
OS_SECTORS equ 0x20b ;size of OS in sectors, 2 is for int 13h (read)

RANDOM_BUFFER equ 0x1160
SEARCH_BUFFER equ 0x1161
REPLACE_BUFFER equ 0x1168
COPY_BUFFER equ 0x1170

jmp bootloader

    ;"help file" list of commands
    db "Pikobrain v1.6", 0xd, 0xa
    db "new, enter, back", 0xd, 0xa
    db "time", 0xd, 0xa
    db "memory [fi]", 0xd, 0xa
    db "visible [fi][2h]", 0xd, 0xa
    db "place [fi][4h][2h][]", 0xd, 0xa
    db "write [fi]", 0xd, 0xa
    db "edit [fi][2h]", 0xd, 0xa
    db "delete [fi][2h]", 0xd, 0xa
    db "link [fi][fi][2h]", 0xd, 0xa
    db "copy [fi][2h]w[fo][fi]", 0xd, 0xa
    db "jump [1h][fi][2h]w[fo][fi]", 0xd, 0xa
    db "kalc [4h][4h][1h]", 0xd, 0xa
    db "Kagain [4h][1h]", 0xd, 0xa
    db "hex [4h]", 0xd, 0xa
    db "xdex [5d]", 0xd, 0xa
    db ".float [4h]", 0xd, 0xa
    db "folder [fo]", 0xd, 0xa
    db "search [str]", 0xd, 0xa
    db "info", 0xd, 0xa
    db "os", 0xd, 0xa
    db "assembly [fi][2h]a[fi]", 0xd, 0xa
    db "run [fi][2h]"

bootloader:
    ;set up registers
    mov ax, 0x7c0
    mov ds, ax ;data segment
    mov ax, 0xa00
    mov ss, ax ;stack segment
    mov sp, 0x1000 ;stack pointer

    ;redirect ctrl+break handler
    xor ax, ax
    mov es, ax
    mov bx, 0x6c ;location in Interrup Vector Table
    mov word [es:bx], CTRL_BREAK ;location of handler in code
    add bx, 2h
    mov word [es:bx], 0x1000
    
    ;read OS files into RAM
    mov ax, 0x1000
    mov es, ax
    xor bx, bx
    mov ax, OS_SECTORS ;files to read
    mov cx, 1h
    mov dh, 0h ;dl set at boot
    int 13h
    cmp ah, 0h ;if error stop
    jne $

    ;check if install has been made
    mov bx, 0x1fd           ;location of variable
    cmp byte [es:bx], 0h    ;if installed: jump to OS
    jne jmppb
    mov byte [es:bx], 1h    ;else: mark as installed, and install
    
    ;set destination drive for install
    shr dl, 7h
    or dl, 0x80 ;0->80, 80->81 bitwise math

    ;write files to hard drive
    xor bx, bx
    mov ah, 3h ;use same values as previous int 13h
    int 13h
    cmp ah, 0h ;if error stop
    jne $

jmppb:
    jmp 0x1000:0x0200 ;jump to Pikobrain main

    ;fill up space
    times 506-($-$$) db 0h

    ;folder number
    db 0h ;upper 2 bits cl -- track
    dw 0h ;0x1000:last_byte

    db 0h ;0=installation=false, 1=installation=true
    dw 0xaa55


;**********
;PIKOBRAIN
;**********

    ;setup copy buffer
    mov ax, COPY_BUFFER
    mov es, ax
    xor bx, bx
    mov byte [es:bx], 0h

callnew:
    call new  ;call function, jump to main loop
    jmp input ;-->
new:
    ;clear screen
    pusha
    ;set graphics mode
    mov ax, 3h ;80x25 16 color text
    int 10h
    ;popa ;UNCOMMENT
    ;ret  ;FOR QEMU
    ;set color and clear screen
    mov ax, 0x600
    mov bh, 0x3e ;cyan-yellow <-- change this value to change colors in Pikobrain
    xor cx, cx
    mov dx, 0x184f ;size of screen 25x80
    int 10h
    popa
    ret


;**********
;FUNCTIONS
;**********
;common functions
;some used as macros in pikoasm

callenter:
    call enter
    jmp input
enter:
    ;print enter char
    mov ax, 0xe0d
    int 10h
    mov al, 0xa
    int 10h
    ret

readfile:
    ;reads one file
    mov ax, 0x1200
    mov es, ax
    xor bx, bx
    call filenum ;number of file
    call setfolder
    mov ax, 0x201 ;read one file
    int 13h
    ret

readfiles:
    ;read multiple files
    mov ax, 0x1200
    mov es, ax
    xor bx, bx
readfiles2: ;used by link
    push bx
    call filenum ;first file
    push cx ;store number
    call filenum ;number of files
    mov bl, cl ;store for al
    pop cx
    call setfolder
    mov al, bl
    mov ah, 2h
    pop bx
    int 13h ;read
    ret

xtox:
    ;output ch as 2 digit hex number
    mov al, ch
    and al, 0xf ;clear upper nibble, to get second digit only
    call xtoasc
    mov ah, al ;store
    mov al, ch
    shr al, 4h ;get upper nibble, to get first digit only
    call xtoasc
    mov ch, ah ;store
    ;output two numbers
    mov ah, 0xe
    int 10h
    mov al, ch
    int 10h
    ret

;the next two convert between ascii-chars and numerical values
;such as F=46h <-> 0xf
atohex:
    ;ascii-hex to hex
    sub al, 30h
    cmp al, 9h
    jle athback
    sub al, 7h ;if letter
athback:
    ret

xtoasc:
    ;hex to ascii-hex
    add al, 30h
    cmp al, 39h
    jle xtaback
    add al, 7h ;if letter
xtaback:
    ret

filenum:
    ;get 2 digit hex num input
    ;converts and into cl
    mov ah, 0h
    int 16h
    cmp al, 0x8 ;backspace = cancel
    je filenquit
    mov ah, 0xe ;output
    int 10h
    call atohex
    mov cl, al
    shl cl, 4h ;*16, store in upper nibble
    mov ah, 0h
    int 16h
    cmp al, 0x8 ;backspace = cancel
    je filenquit
    mov ah, 0xe
    int 10h
    call atohex
    add cl, al ;lower nibble
    ret
filenquit:
    ;exit writing, clear stack, go to input
    mov sp, 0x1000
    jmp input ;if a pikoasm program gets here it will terminate

setfolder:
    ;set folder to current folder number, for int 13h
    ;folder number stored in the end of the bootloader code
    and cl, 0x3f ;clear upper bits, cl is file number
    mov ax, 0x1000
    mov fs, ax
    mov si, 0x1fa ;folder number location
    mov al, [fs:si]
    shl al, 6h ;into right position
    add cl, al
    inc si
    mov dh, [fs:si] ;set values
    inc si
    mov ch, [fs:si]
    mov dl, 0x80
    ret

callfolder:
    call folder
    jmp input
folder:
    ;change (head and track i.e.) folder number
    ;dh and ch (cl) for int 13h
    mov ax, 0x1000
    mov fs, ax
    mov si, 0x1fc ;last number in folder number
    call filenum
    cmp cl, 0x69 ;double press tab to select current folder
    je fsame
    cmp cl, 0x44 ;double semi-colon to only enter last two digits
    je flast
    cmp cl, 0x41 ;double press h to select home folder (000000)
    je fhome
    and cl, 3h ;clear bits
    push cx
    call filenum
    push cx
    call filenum ;i.e. 6 digits total
    ;write values, to change folder number
    mov [fs:si], cl
    dec si
    pop cx
    mov [fs:si], cl
    dec si
    pop cx
    mov [fs:si], cl 
    ret
fhome:
    ;set folder number to 000000
    dec si
    mov word [fs:si], 0h
    dec si
    mov byte [fs:si], 0h
    ret
flast:
    ;only change last two digits of folder number
    call filenum
    mov [fs:si], cl
fsame: ;use current folder number
    ret

random:
    ;random number generator
    push cx ;store for assembly macros
    push dx
    mov ah, 0h ;get tick
    int 1ah
    mov ax, RANDOM_BUFFER
    mov fs, ax
    xor si, si
    mov ax, [fs:si]
    sub ah, dl ;update number = generate
    sub al, ah ;al is random number returned
    rol ax, 1h
    mov [fs:si], ax ;store
    pop dx
    pop cx
    ret

sget:
    ;get string input
    mov ax, SEARCH_BUFFER
    mov gs, ax
    xor di, di ;gs:di search word
sword:
    ;get char
    mov ah, 0h
    int 16h
    cmp ah, 0x3b ;f1, quit writing, for use of old string input
    je ssend 
    cmp al, 8h ;backspace
    jne swordcon
    dec di
    mov ah, 0xe ;print backspace
    int 10h
    mov ax, 0xa20 ;space
    int 10h
    jmp sword
swordcon:
    mov [gs:di], al ;store char in buffer
    ;if enter: end
    cmp al, 0xd ;if enter, end writing
    je ssend
    ;output
    mov ah, 0xe ;output char
    int 10h  
    inc di
    jmp sword
ssend:
    xor di, di
    ret


;******
;INPUT
;******
;main loop

input:
    ;get commands
    mov ah, 0h
    int 16h
    mov bh, 0h ;graphics reason

    cmp al, 0x6e ;n
    je callnew
    cmp al, 0xd  ;enter
    je callenter  
    cmp al, 0x62 ;b
    je callback
    cmp al, 0x74 ;t
    je time
    cmp al, 0x6d ;m
    je memory
    cmp al, 0x76 ;v
    je visible
    cmp al, 0x70 ;p
    je place
    cmp al, 0x77 ;w
    je write
    cmp al, 0x65 ;e
    je edit
    cmp al, 0x64 ;d
    je delete
    cmp al, 0x6c ;l
    je link
    cmp al, 0x63 ;c
    je copystart
    cmp al, 0x6a ;j
    je jump
    cmp al, 0x6b ;k
    je kalc
    cmp al, 0x4b ;K
    je kagain
    cmp al, 0x68 ;h
    je hex
    cmp al, 0x78 ;x
    je xdec
    cmp al, 0x2e ;.
    je real
    cmp al, 0x66 ;f
    je callfolder
    cmp al, 0x69 ;i
    je info
    cmp al, 0x73 ;s
    je search
    cmp al, 0x6f ;o
    je os
    cmp al, 0x61 ;a
    je assembly
    cmp al, 0x72 ;r
    je run

    ;else check arrows
arrow:
    mov al, ah
    ;get cursor location
    mov ah, 3h
    int 10h
    cmp al, 0x48 ;up
    je arrowup
    cmp al, 0x50 ;down
    je arrowdown
    cmp al, 0x4b ;left
    je arrowleft
    cmp al, 0x4d ;right
    je arrowright
    jmp input
arrowup:
    dec dh
    jmp arrowend
arrowdown:
    inc dh
    jmp arrowend
arrowleft:
    dec dl
    jmp arrowend
arrowright:
    inc dl
arrowend:
    mov ah, 2h ;update cursor
    int 10h
    jmp input

callback:
    call back
    jmp input
back:
    ;move cursor to top left
    mov ah, 2h
    xor dx, dx
    int 10h
    ret

 
;*********
;COMMANDS
;*********
;'programs'

time:
    ;get date
    ;convert to decimal
    mov ah, 4h
    int 1ah
    call xtox
    mov ch, cl
    call xtox
    mov al, 0x2f ;/
    int 10h
    mov ch, dh
    call xtox
    mov al, 0x2f ;/
    int 10h
    mov ch, dl
    call xtox
    mov al, 0x20 ;space
    int 10h
    ;get time
    ;convert to decimal
    mov ah, 2h
    int 1ah
    call xtox
    mov al, 0x3a ;:
    int 10h
    mov ch, cl
    call xtox
    mov al, 0x3a ;:
    int 10h
    mov ch, dh
    call xtox
    jmp input

memory:
    ;read file in hex and ascii
    call readfile
    mov dl, 0h ;due to visible, show that m command running, not v
menter:
    mov dh, 0h ;column counter
    call enter
    mov ch, bl ;print row index
    call xtox
    mov al, 0x3a ;:
    int 10h
mbyte:
    mov ch, [es:bx] ;get content of byte
    cmp ch, dl ;if value == <visible command value> or 0h when m command
    je mvisible
    call xtox ;else output as hex
mcon:
    mov al, 0x20 ;space
    int 10h
    inc bx
    inc dh
    cmp dh, 0x10 ;width of content
    jne mbyte
    ;output row as ascii
    mov si, bx
    sub bx, 0x10
mascii:
    mov al, [es:bx]
    ;check if special char
    cmp al, 0x1f
    ja macon
    mov al, 0x2a ;*
macon:
    int 10h ;write char
    inc bx
    cmp bx, si ;end of row
    jne mascii
    cmp bx, 0x100 ;press key after half is shown; screen too small
    je mhalf
    cmp bx, 0x200 ;reading 512 bytes
    je input
    jmp menter
mhalf:
    mov ah, 0h
    int 16h
    jmp menter
mvisible:
    mov al, 0x2e ;.. to mark v command value
    int 10h
    int 10h
    jmp mcon
    
visible:
    ;highlight opcode in memory
    call readfile
    call filenum ;get opcode
    mov dl, cl ;store opcode
    call menter

place:
    ;write byte to certain location(s)
    call readfile
    push cx ;save file number
    ;get two bytes for location
    call filenum
    mov bh, cl
    call filenum
    mov bl, cl ;store in bx
ploop:
    call enter
    mov ch, [es:bx] ;output current value
    call xtox
    call filenum ;get value to place
    mov [es:bx], cl ;place
    inc bx
    mov ah, 0h
    int 16h
    cmp al, 0xd ;if enter: write more
    je ploop
    ;else save updated file
    xor bx, bx
    pop cx
    call setfolder
    mov ax, 0x301
    int 13h
    jmp input

read:
;OK the text editor is a mess so I'll list what registers are used for
;ax = general purpose
;bx = general purpose if necessary; bh=0h (1st screen) whenever video interrupts are used
;cx = general purpose ;is pushed as it stores the file number
;dx = stores cursor location
;si = index of the character in top left, needed for scrolling
;di = index of current character the cursor is located on
;es:di holds the actual text
;fs:   holds copy buffer
;gs:   holds search buffer

;first the file is read and written to the screen
;when a char is typed:
    ;the screen is rewritten from the cursor forward
;when a special function is used:
    ;various levels of (if any) rewriting of the screen takes place

    ;read file as ASCII chars
    ;de facto part of text editor
    call readfiles
rlink: ;used by wlink
    mov bl, al ;al=number of files
    shl bx, 9h ;*200h-> buffer size in bytes
    mov byte [es:bx], 0h ;mark end of buffer, due to full files
rstart: ;used by wdel, wgoto
    mov ax, RANDOM_BUFFER
    mov gs, ax ;gs:di used as cmp buffer for wfind
    mov di, 2h ;placing it somewhere else for now
    mov byte [gs:di], 0h
readstart: ;used by wfind
    xor bx, bx
    xor si, si ;si always stores the index of the first char on the screen i.e. top left
    call new ;due to text editor
readstart2: ;used by wfnext, doesn't clear screen
    push cx ;store file number
nextread:
    mov al, [es:bx] ;get char
    cmp al, 0xd ;newline
    je readsi
readcon:
    cmp al, 0h ;end of file
    je readend
    mov ah, 0xe ;print char
    int 10h
    inc bx
    cmp byte [gs:di], 0x2a ;* for text editor find any char (joker)
    je readeq
    cmp al, [gs:di] ;equal chars
    je readeq
    xor di, di
    jmp nextread
readeq:
    ;for wfind
    ;chars are equal
    inc di
    cmp byte [gs:di], 0xd ;if string found
    jne nextread
readend:
    pop cx ;file number
    ret
;si stuff for editor
readsi: ;si stores location of first char on screen (in text editor)
    ;si to next line
    push ax
    push bx
    mov bh, 0h
    mov ah, 3h ;get cusor position
    int 10h
    pop bx
    pop ax
    cmp dh, 0x18 ;bottom row
    jne rsiend
    call rsiloop
rsiend:
    jmp readcon
rsiloop:
    ;move si to next line
    inc si
    cmp byte [es:si], 0xa ;newline
    jne rsiloop
    inc si
    ret
rbacksi:
    ;si to previous line
    sub si, 2h ;skip newline
rbsiloop:
    dec si
    cmp si, 1h
    jle rbsiend
    cmp byte [es:si], 0xa ;newline
    jne rbsiloop
    inc si
    ret
rbsiend:
    xor si, si
    ret

;TEXT EDITOR
write:
    mov ax, 0x1200
    mov es, ax
    call filenum ;get file number
    push cx ;store for save
    call new
    xor si, si ;for scrolling
    xor bx, bx ;pointer
wedit: ;for edit
    mov byte [es:bx], 0h ;mark last char
    mov di, bx ;index of cursor char
    mov ax, COPY_BUFFER
    mov fs, ax
typechar: ;main editor loop
    call wtype
    jmp wgetchar
wtype:
    ;update screen from location of cursor
    push di
    mov bh, 0h ;i hate that bh must be 0, else bugs
    mov ah, 3h ;get cursor
    int 10h
    push dx
typeloop:
    ;write char or fill line if newline
    mov ah, 0xe
    mov al, [es:di]
    cmp al, 0h ;end of file
    je typend
    cmp al, 0xd ;enter
    je typelinestart
    cmp al, 0xa ;don't output
    je typecont
    int 10h ;output char
typecont:
    inc di
    jmp typeloop
typend:
    call typeline ;clear two lines
    call typeline ;..due to backspace on newline
typend2: ;used by typelinestart
    pop dx
    mov ah, 2h ;reset cursor
    int 10h
    pop di
    ret
typelinestart:
    call typeline
    cmp dh, 0x18
    je typend2
    jmp typecont
typeline:
    ;fill rest of line with spaces
    mov ah, 3h
    int 10h
    mov cx, 0x50 ;width of screen (ch=0)
    sub cl, dl ;number of spaces to fill line with
    je typeret ;if cl=0 don't write
    mov ax, 0xa20
    int 10h
    cmp dh, 0x18 ;if last line
    je typeret
    call enter
typeret:
    ret
wgetchar:
    mov bh, 0h
    ;get cursor location for dx, used by some special keys
    mov ah, 3h
    int 10h
    ;get char to write
    mov ah, 0h
    int 16h
    ;special keys
    cmp al, 0x8 ;backspace
    je backspace
    cmp ah, 0x4b ;left arrow
    je wleft
    cmp ah, 0x4d ;right arrow
    je wright
    cmp ah, 0x50 ;down arrow
    je wdown
    cmp ah, 0x48 ;up arrow
    je wup
    cmp al, 0x9 ;tab (circle)
    je wcallcopy
    cmp ah, 0xf ;shifted tab (cut)
    je wcallcopy
    cmp al, 0x7c ;| paste
    je wpaste
    cmp ah, 0x49 ;page up
    je wpgup
    cmp ah, 0x51 ;page down
    je wpgdown
    cmp ah, 0x52 ;ins
    je wins
    cmp ah, 0x53 ;del
    je wdel
    cmp ah, 0x47 ;home
    je whome
    cmp ah, 0x4f ;end
    je wend
    cmp al, 0xd ;enter
    je wenter
    cmp ah, 0x3b ;f1
    je wfind
    cmp ah, 0x3c ;f2
    je wfnext
    cmp ah, 0x3d ;f3
    je wreplace
    cmp ah, 0x3e ;f4
    je save
    cmp ah, 0x3f ;f5
    je wspace
    cmp ah, 0x40 ;f6
    je wgoto
    cmp ah, 0x41 ;f7
    je wlink
    ;output character typed
    mov ah, 0xe
    int 10h
    cmp al, 0x60 ;` save
    je save
    cmp al, 0x1b ;esc cancel
    je savend
    cmp al, 0x5c ;\ special char
    je wspecial
    cmp al, 0x7e ;~ char count
    je wchar
    call wloopstart ;add char to buffer
    jmp typechar
wloopstart:
    mov bx, di ;pointer
wloop:
    ;add char to buffer
    mov ah, [es:bx]  ;get current char
    mov [es:bx], al  ;place new char (the typed one)
    mov al, ah       ;store the old char as the "new char"
    inc bx
    cmp al, 0h       ;check if file end
    jne wloop
wloopend:
    inc di           ;update di
    mov byte [es:bx], 0h ;show end of file
    ret
wleft:
    ;move cursor one step left
    cmp dx, 0h ;if top left of screen do nothing
    je wgetchar
    dec di
    cmp dl, 0h ;beginning of line
    je wleftnl
    mov ax, 0xe08 ;backspace
    int 10h
    jmp wgetchar
wleftnl:
    ;move cursor to previous line due to newline
    mov ah, 2h
    dec dh
    mov dl, 0x4f ;end of line
    int 10h
    cmp byte [es:di], 0xa ;newline
    jne wgetchar
    dec di
    jmp wbnloop
wright:
    ;move cursor one step right
    cmp byte [es:di], 0h ;end of file
    je wgetchar
    call wright2
    jmp wgetchar
wright2:
    ;get cursor location
    mov ah, 3h ;due to wend
    int 10h
    cmp byte [es:di], 0xd ;if newline
    je wrightnl
    inc di
    ;else simply move cursor right
    mov ah, 2h
    inc dl
    int 10h
    ret
wrightnl:
    cmp dh, 0x18 ;if last line do nothing; we don't want to scroll
    je wrightend
    add di, 2h ;go past 0xa
    ;move cursor to start of next line
    mov ah, 2h
    inc dh
    mov dl, 0h
    int 10h
wrightend:
    ret
backspace:
    cmp di, 0h ;if start of file: do nothing
    je wgetchar
    cmp dx, 0h ;if top left of screen: do nothing
    je wgetchar
    mov ax, 0xe08 ;backspace
    int 10h
    dec di
    mov ch, [es:di] ;must store for cmp later
    call wbloopstart ;remove char from buffer
    cmp dl, 0h ;are we removing a newline?
    je wbnl
wbauto:
    ;else just erase char
    mov bh, 0h
    mov cx, 1h ;only one char
    mov ax, 0xa20 ;for backspace newline
    int 10h
    jmp typechar
wbnl:
    ;move cursor to previous line
    mov bh, 0h
    mov ah, 2h
    dec dh
    mov dl, 0x4f ;79 end of row
    int 10h
    cmp ch, 0xa ;was stored, check if newline
    jne wbauto  ;this causes a bug if removed
    ;remove newline
    dec di
    call wbloopstart
wbnloop:
    ;move left until we find text; due to this a line can not end with a space
    ;get cursor char
    mov bh, 0h
    mov ah, 8h
    int 10h
    cmp al, 0x20 ;space apparently
    jne wbnlend
    ;get cursor position
    mov ah, 3h
    int 10h
    cmp dl, 0h ;beginning of line
    je typechar
    ;mov cursor left
    dec ah ;2h
    dec dl
    int 10h
    jmp wbnloop
wbnlend:
    ;cursor right
    mov ah, 2h
    inc dl
    int 10h
    jmp typechar
wbloopstart:
    mov bx, di
wbloop:
    ;erase character from buffer
    inc bx
    mov al, [es:bx] ;get next character
    dec bx
    mov [es:bx], al ;move it to current byte
    cmp al, 0h      ;check if file end
    je wbloopend
    inc bx          ;go to next byte
    jmp wbloop
wbloopend:
    ret
wup:
    ;arrow up, move to end of previous line
    mov bl, dl ;bh = 0
    sub di, bx ;move di to start of line  
    mov ah, 2h
    mov dl, 0h ;move cursor to start of line
    int 10h
    jmp wleft
wdown:
    ;arrow down, move to end of next line
    mov al, [es:di]
    cmp al, 0xd ;search for newline
    je wdown2
    cmp al, 0h ;end of file
    je wgetchar
    call wright2
    jmp wdown
wdown2:
    ;when newline found, go to end of that line
    call wright2
    mov al, [es:di]
    cmp al, 0xd ;newline
    je wgetchar
    cmp al, 0h ;end of file
    je wgetchar
    jmp wdown2
wenter:
    ;handles the writing of enter
    call wloopstart ;insert al=0xd into buffer
    ;di already increased
    mov bh, 0h
    call typeline
    mov al, 0xa
    call wloopstart
    cmp dh, 0x18 ;bottom row
    jne typechar
    mov ax, 0xe0d ;print enter, else bug on last row
    int 10h
    mov al, 0xa
    int 10h
    call rsiloop ;si to next line
    jmp typechar
wpgup:
    ;scroll page up
    cmp si, 0h ;if already at top: do nothing
    je wgetchar
    call rbacksi ;si to previous line
    call wpg
    inc dh
    int 10h ;update cursor
    jmp wgetchar
wpgdown:
    ;scroll page down
    call rsiloop ;si to next line
    call wpg
    dec dh
    int 10h ;update cursor
    jmp wgetchar
wpg:
    ;rewrite screen
    push dx
    push di
    call back ;cursor top left
    mov di, si
    call wtype ;rewrite screen
    ;restore values and cursor
    pop di
    pop dx
    mov ah, 2h ;move cursor one line up
    ret
wins:
    ;scroll bulk to top
    call back
    xor si, si ;reset values
    xor di, di
    jmp typechar ;rewrite screen
wdel:
    ;scroll bulk to bottom by re-reading file
    call rstart
    mov di, bx ;last char
    jmp wgetchar
whome:
    call back ;move cursor to top left
    mov di, si ;set to first char on screen
    jmp wgetchar
wend:
    ;move cursor to end of file
    cmp byte [es:di], 0h ;end of the file
    je wgetchar
    call wright2 ;go to next line
    cmp dh, 0x18 ;if last line
    je wendnl
    jmp wend
wendnl:
    ;check if we are at the end=newline
    cmp byte [es:di], 0xd
    je wgetchar
    jmp wend
wspecial:
    ;type special ascii char
    call filenum ;char value
    mov ah, 2h ;reset cursor, dx stored in wgetchar
    int 10h
    mov al, cl
    mov ah, 0xe ;output char
    int 10h
    call wloopstart ;place char in buffer
    jmp typechar
wchar:
    ;ouput di = index of cursor char
    mov cx, di
    call xtox
    mov ch, cl
    call xtox
    ;char press
    mov ah, 0h
    int 16h
    mov ah, 2h ;reset cursor
    int 10h
    jmp typechar
wfind:
    ;find string in file
    call sget ;get string
    call readstart ;re-read
wfend:
    mov di, bx
    jmp typechar
wfnext:
    ;find next occurance of string
    mov bx, di
    mov ax, SEARCH_BUFFER
    mov gs, ax
    xor di, di ;gs:di search word
    call readstart2
    jmp wfend
wreplace:
    ;replace string created by f1 with specified string
    mov ax, REPLACE_BUFFER
    mov gs, ax
    xor di, di
    call sword ;get string that will replace
    xor bx, bx
wrloop:
    mov ax, SEARCH_BUFFER ;when comparing, find old string
    mov gs, ax
    xor di, di
wrcomp:
    ;compare chars between buffers  
    mov al, [gs:di]
    cmp al, 0xd ;enter marks the end of the input string
    je wrfound  ;->meaning we found a match
    cmp byte [es:bx], 0h ;end of file
    je wdel
    cmp al, [es:bx] ;if the strings are unequal
    jne wrnot
    ;equal chars, but not yet strings
    inc bx
    inc di
    jmp wrcomp
wrnot:
    ;strings unequal
    inc bx
    xor di, di
    jmp wrcomp
wrfound:
    ;string found: replace
    ;remove old string
    dec bx ;right char
    push bx
    call wbloop
    pop bx
    dec di   ;must be after call to be right number of times
    je wrcon ;erase chars until di=0
    jmp wrfound
wrcon:
    ;write new string
    mov ax, REPLACE_BUFFER
    mov gs, ax
wrwrite:
    mov al, [gs:di]
    cmp al, 0xd
    je wrloop
    push bx
    call wloop ;increases di
    pop bx
    inc bx
    jmp wrwrite
wspace:
    ;remove spaces before newlines
    ;add newlines where lines are completely full
    xor di, di
wsloop2: ;used by 'wsnl'
    xor dx, dx ;counts chars on lines
wsloop:
    mov al, [es:di]
    cmp al, 0h ;end of file
    je wsend
    cmp al, 0xd ;newline
    je wcspace
    cmp dx, 0x4f ;end of line
    je wsnl
    inc di
    inc dx
    jmp wsloop
wsnl:
    dec di
    cmp byte [es:di], 0x20 ;find space
    jne wsnl
    ;insert enter
    call wsspace2 ;check spaces
    inc di ;to be right
    mov al, 0xd
    call wloopstart ;insert enter
    mov al, 0xa
    call wloopstart ;insert complete enter
    jmp wsloop2
wcspace:
    call wsspace
    add di, 3h ;jump past newline
    jmp wsloop2
wsspace:
    dec di
wsspace2: ;used by 'wsnl'
    cmp byte [es:di], 0x20 ;if space delete
    je wsserase
    ret
wsserase:
    call wbloopstart ;erase
    jmp wsspace ;check if multiple spaces 
wsend:
    ;re-read file
    call rstart
    mov di, bx ;last char
    jmp wgetchar
wgoto:
    ;go to certain char in file
    call filenum ;get location into ax
    mov ch, cl
    call filenum ;4 digit hex
    mov bx, cx
wgoto2: ;used by wcallcopy
    mov al, [es:bx]
    push ax ;save current character
    mov byte [es:bx], 0h ;mark location
    call rstart ;read until null char
    pop ax
    mov [es:bx], al ;reset
    mov di, bx
    jmp typechar
wlink:
;read the current 'word' which serves as a 'link' to another file
;open that file. ex: 0000002002 would link to file 20-21 in home folder
;i.e. folder number, file number, number of files
;*2002 *is shortcut to use current folder
    ;go to start of 'word'
    dec di
    cmp byte [es:di], 0x20 ;find space
    jne wlink
    mov bx, di ;will use bx as index later
    inc di ;go to first char
    cmp byte [es:di], 0x2a ;* shortcut for current folder
    je wlfile
    ;read folder number
    mov ax, 0x1000
    mov fs, ax
    mov di, 0x1fa ;location of folder number
    mov cl, 3h ;3 numbers read
wlloop:
    call agetbyte   ;read 3 numbers
    mov [fs:di], al ;write into folder number
    inc di
    dec cl
    jne wlloop
    dec bx ;due to * shortcut
wlfile:
    inc bx
    ;get file number and bulk length
    call agetbyte
    push ax ;file number
    call agetbyte
    mov bl, al ;store for later
    pop cx ;file number
    call setfolder
    ;read file
    mov ax, 0x1200 ;buffer
    mov es, ax
    mov ah, 2h
    mov al, bl
    xor bx, bx
    int 13h ;read
    pop bx ;take down cx=file number
    call rlink ;write file to screen
    push cx ;file number, for save
    jmp wedit
wcallcopy:
    ;copy/cut
    push si
    push di
    call wcopy
    pop di
    pop si
    cmp cl, 0h ;0=cut
    jne wgetchar
    jmp wgoto2 ;read until limit (bx was set to di)
wcopy:
;the copy buffer looks like this:
;INDEX| CONTENT
;0    | copying? (byte)(1=true, 0=false)
;1-2  | index    (word)(index of first limit) [this is if copying=1]
;1-   | buffer   (string)(stores the text to copy) [is if copying=0]
;index 1 is i.e. used depending on the value of 'copying' boolean
;either:
;[1, <index>]
;[0, <buffer>..]
    mov cl, al ;00 if cut (09 if copy)
    xor si, si
    cmp byte [fs:si], 0h ;check if copy is active
    jne wccopy
    ;if not active mark copying as active 1h
    mov byte [fs:si], 1h ;start copying
    inc si
    mov [fs:si], di ;store char location
    ret
wccopy:
    ;copy content
    mov byte [fs:si], 0h ;mark end of copying
    inc si
    mov bx, [fs:si] ;get location of second limit/char
    mov ax, di ;current location into ax
    cmp bx, ax
    jle wcsave1
    xchg bx, ax ;bx should be lower than ax
wcsave1:
    mov di, bx ;bx is left limit
wcsave: ;loop to store chars in buffer
    mov ch, [es:bx]
    mov [fs:si], ch ;store char in copy buffer
    cmp bx, ax
    je wcsavend ;all characters copied
    inc bx
    inc si
    jmp wcsave
wcsavend:
    inc si
    mov byte [fs:si], 0h ;mark end of copy string
    cmp cl, 0h ;0=cut
    jne wcend
    ;remove cut text from buffer
    inc ax
    mov bx, ax ;first char after gap
    sub ax, di ;size of gap +1
wcutloop:
    mov ch, [es:bx]
    sub bx, ax
    mov [es:bx], ch ;move character
    add bx, ax
    inc bx
    cmp ch, 0h ;end of file
    jne wcutloop
wcend:
    mov bx, di ;left-limit, used when jumping to wgoto2
    ret
wpaste:
    push si
    mov si, 1h ;where copied string starts
wpasteloop:
    mov al, [fs:si] ;get char
    cmp al, 0h ;end of string
    je wpastend
    mov ah, 0xe ;move cursor according to char
    int 10h
    cmp al, 0xd ;newline
    je wpsi
wpcon:
    call wloopstart ;save char in buffer
    inc si
    jmp wpasteloop
wpsi:
    ;if newline
    mov bh, 0h
    mov ah, 3h ;get cursor
    int 10h
    cmp dh, 0x18 ;check if last line
    jne wpcon
    mov dx, si
    pop si
    call rsiloop ;move si
    push si
    mov si, dx
    jmp wpcon
wpastend:
    pop si
    mov bh, 0h
    mov ah, 3h ;get cursor
    int 10h
    push dx
    call back ;cursor top left
    push di
    mov di, si
    call wtype ;update screen
    pop di    
    pop dx
    mov ah, 2h ;reset cursor
    int 10h 
    jmp wgetchar
save:
    ;prepare saving
    pop cx ;file number
    push cx ;if quick save, remain on stack
    push ax ;quick save or not, int 16h
    mov bx, 0xffff ;becomes 0
    call lloop ;go to last byte
    push bx
    and bx, 0x1ff
    cmp bx, 0x1ff ;if true the file is full
    je savecon
    pop bx
    push bx
    or bx, 0x1ff
    mov byte [es:bx], 0h ;place a null at end, to mark it is not a bulk
savecon:
    pop bx
    shr bx, 9h ;/200h
    inc bl
    ;save file
    push si
    call setfolder ;due to quicksave si pushed
    pop si
    mov al, bl
    mov ah, 3h
    xor bx, bx 
    int 13h
    ;check if quick save
    pop ax
    cmp al, 0x60 ;` pure save
    jne wgetchar
savend:
    mov sp, 0x1000 ;reset stack pointer, due to cx f4
    xor bx, bx
    mov byte [fs:bx], 0h ;reset copy buffer
    jmp input

edit:
    ;edit file
    call read
    push cx ;file number, for save
    jmp wedit

delete:
    ;erases files
    call readfiles
    shl al, 1h ;*2 = "number of files" to delete for bx
dloop:
    mov byte [es:bx], 0h ;set as 0h, since if the first byte is a 0h the file is "empty"
    add bh, 2h ;next file
    cmp bh, al ;all files erased
    jne dloop
    ;write files back
    shr al, 1h ;return to old value
    mov ah, 3h
    xor bx, bx
    int 13h
    jmp input

lloop:
    ;read [es:bx] until 0h char
    inc bx
    cmp byte [es:bx], 0h ;end of file
    jne lloop
    ret
link:
    ;link files together (concatenate)
    call readfile ;get last file of first bulk
    push cx ;first file number
    call lloop
    call readfiles2 ;use bx value for destination
    call lloop
    ;write files
    pop cx ;file number
    mov ah, 3h
    or bx, 0x1ff ;go to last byte
    mov byte [es:bx], 0h ;mark end of file
    inc bh ;->200h
    mov al, bh
    shr al, 1h ;set al to right number of files to save
    xor bx, bx ;reset buffer
    int 13h
    jmp input

copystart:
    mov bx, 0x8080 ;source and destination disk (hard drive)
    jmp copy
jump:
    ;move file between usb and hard disk, only works when booting from usb
    ;get source 0=80h 1=81h
    ;destination will be opposite
    mov ah, 0h
    int 16h
    mov ah, 0xe ;output number
    int 10h
    mov bl, al ;store in bx
    mov bh, bl
    xor bx, 0xb1b0 ;convert from 30h to 80h, and flip the first bit of bh
copy:
    mov di, bx ;di is used to store source and destination disk
    mov ax, 0x1200
    mov es, ax
    call filenum ;file number
    push cx
    call filenum ;number of files
    mov al, cl
    mov ah, 2h ;for int 13h 
    pop cx
    push ax
    call setfolder
    pop ax ;set ax
    push ax
    mov dl, bl ;set dl (bx=di)
    shr di, 8h ;get next value for dl
    xor bx, bx
    int 13h
    mov ax, 0xe77 ;w = succesfull read
    int 10h
    ;write
    call folder ;get destination folder
    call filenum ;file number
    call setfolder
    pop ax ;same number
    inc ah
    mov bx, di
    mov dl, bl ;drive
    xor bx, bx
    int 13h
    jmp input   

;CALCULATOR
kalc:
    call kgetint
kagain: ;uses result from last operation, i.e. cx
    push cx ;store number
    call kgetint
    ;2 integers stored on stack
    ;0000-FFFF
    ;return integers
    pop dx ;first integer, 2nd already in cx
    ;get operator
    mov ah, 0h
    int 16h
    cmp al, 31h ;1=add
    je kadd
    cmp al, 32h ;2=subtract
    je ksub
    cmp al, 33h ;3=multiply
    je kmul
    cmp al, 34h ;4=divide
    je kdiv
    cmp al, 35h ;5=modulo
    je kmod
    cmp al, 36h ;6=and
    je kand
    cmp al, 37h ;7=or
    je kor
    cmp al, 38h ;8=xor
    je kxor
    cmp al, 39h ;9=not
    je knot
    cmp al, 30h ;0=float division
    je kfloat   
    jmp input ;if invalid
    ;answer stored in dx
kadd:
    add dx, cx
    jmp kanswer
ksub:
    sub dx, cx
    jmp kanswer
kmul:
    mov ax, dx
    mul cx
    mov dx, ax
    jmp kanswer
kdiv:
    mov ax, dx
    xor dx, dx
    div cx
    mov dx, ax
    jmp kanswer
kmod:
    mov ax, dx
    xor dx, dx
    div cx
    ;dx is remainder
    jmp kanswer
kand:
    and dx, cx
    jmp kanswer
kor:
    or dx, cx
    jmp kanswer
kxor:
    xor dx, cx
    jmp kanswer
knot:
    not dx
    jmp kanswer
kfloat:
    ;uses the normal "long division" style of division for hexadecimal
    ;this means that instead of multiplying the remainder by 10, we do it by 16.
    ;4 digit result
    ;divide and save the remainder
    mov ax, 0xe2e ;.
    int 10h
    mov bl, 4h ;counter
    mov ax, dx
    xor dx, dx
    div cx
    ;dx is remainder
    ;divide dx by cx to get float
kfloop:
    shl dx, 4h ;*16 (multiply the remainder)
    push dx ;save
    mov ax, dx
    xor dx, dx
    div cx
    push ax ;output al
    mov ah, 0xe
    call xtoasc ;convert into ascii
    int 10h
    pop ax
    mul cx ;multiply quotient by divisor
    mov dx, ax
    pop ax
    sub ax, dx ;"long division" subtraction
    mov dx, ax
    dec bl
    jne kfloop
    jmp input
kanswer:
    ;answer in dx, output as hex
    mov ch, dh
    call xtox
    mov ch, dl
    call xtox
    mov cx, dx ;due to , command
    jmp input
kgetint:
    ;get 4-digit hex number
    call filenum
    mov ch, cl
    call filenum
    call enter
    ret

hex:
    ;convert hex to dec
    mov al, 0x30 ;end of result, ah = 0
    push ax
    ;get 4-digit hex
    call filenum
    mov ch, cl ;store value
    call filenum
    call enter
    mov ax, cx
    mov bx, 0xa ;divisor
hloop:
    xor dx, dx ;dx ax / bx, else too large result
    ;convert
    div bx
    push dx ;store remainder
    cmp ax, 0h ;division ended
    jne hloop
hend:
    ;write result
    pop ax
    cmp al, 0x30 ;end of result
    je input
    ;output
    add ax, 0xe30 ;printable
    int 10h
    jmp hend

xdec:
    ;convert dec to hex
    mov al, 0x30 ;mark end of result
    push ax
    mov dx, 0x2710 ;mul 10000
    xor bx, bx ;answer
    mov si, 0xa ;dx ax / si
    mov cl, 5h ;counter
xget:
    ;get number
    mov ah, 0h
    int 16h
    mov ah, 0xe ;output
    int 10h
    and ax, 0xf ;~sub 30h
    push dx ;save while mul
    mul dx
    add bx, ax ;store answer in bx
    ;div dx 10
    pop dx
    mov ax, dx
    xor dx, dx ;divide dx by 10, since in the next digit x will be one less in 10^x.
    div si
    mov dx, ax
    dec cl
    jne xget ;if not 0
    mov si, 0x10 ;div
    mov ax, bx ;answer in bx
xconv:
    xor dx, dx
    div si
    push dx ;remainder
    cmp ax, 0h
    jne xconv
    call enter
xout:
    pop ax
    cmp al, 0x30 ;end
    je input
    call xtoasc
    mov ah, 0xe
    int 10h
    jmp xout

real:
    ;convert hex float to dec float
    call filenum
    mov bh, cl
    call filenum ;get number and push
    mov bl, cl
    push bx
    mov cl, 6h ;counter=number of digits in output
    mov bx, 0xa ;10 is multiplier
    call enter
    mov al, 0x2e ;.
    int 10h
    pop ax ;number to convert
realoop:
    mul bx      ;by solving for x in the ratio equation (x/10=y/16)..
    push ax     ;where y is the upper most nibble in ax (the inputted float value)..
    mov al, dl  ;you can convert a hexadecimal float to decimal float -> x=(y*10)/16..
    add al, 30h ;you don't have to divide by 16, since the quotient will still be the same as in dl
    mov ah, 0xe
    int 10h ;print value
    pop ax
    dec cl
    jne realoop ;6 decimal points precision
    jmp input

info: 
    ;Pikobrain dir/ls command 
    mov ax, 0x1000
    mov fs, ax
    mov si, 0x1fa ;folder number location
    ;ouput folder number in hex
    mov ch, [fs:si]
    call xtox
    inc si
    mov ch, [fs:si]
    call xtox
    inc si
    mov ch, [fs:si]
    call xtox
    call enter
    ;output files 
    ;get file info in folder
    mov ax, 0x1200
    mov es, ax
    xor bx, bx
    mov cl, 1h ;changes later
    call setfolder
    mov ax, 0x23f ;read all files
    int 13h
    mov cl, 1h
iloop:
    ;read file
    cmp byte [es:bx], 0h ;is empty?
    je ilend
    ;output filenum
    mov ch, cl
    call xtox
    mov ax, 0xe2e ;.
    or bx, 0x1ff ;end of file
    cmp byte [es:bx], 0h ;check if file is full
    je iskip
    mov al, 0x3a ;: used if file is full
iskip:
    int 10h ;output . or :
    and bx, 0xfe00 ;start of file
    mov ch, 0xa ;char counter
iwloop:
    ;write 10 chars
    mov al, [es:bx]
    cmp al, 0x20 ;space, to not print weird chars
    jge iw
    mov al, 0x2a ;* to mark special char
iw:
    int 10h
    inc bl ;next char
    dec ch
    jne iwloop ;10 characters
    mov ax, 0xe20 ;space
    int 10h
    int 10h
    int 10h ;3 times, will cause a newline
ilend:
    mov bl, cl
    shl bx, 9h ;move bx to next file
    inc cl
    cmp cl, 0x40 ;last file
    je input
    jmp iloop ;read next file

search:
    ;search for string in folder (find)
    call sget ;input string
    call enter
    ;read all files
    mov ax, 0x1200
    mov es, ax
    xor bx, bx
    mov cl, 1h ;will change
    call setfolder
    mov ax, 0x23f ;all files
    int 13h
sloop:
    xor di, di ;reset, [gs:di] stores string
scomp:
    mov dl, [gs:di] ;compare with search word
    cmp dl, 0xd ;end of search word
    je sfind
    cmp dl, 0x2a ;* any character
    je scont
    mov al, [es:bx] ;get char from file
    cmp al, 0h ;end of file
    je seof
    cmp al, dl
    jne snot ;not equal words
scont:
    inc bx
    inc di
    jmp scomp
sfind:
    ;print file number
    push bx
    push bx
    shr bx, 9h ;"convert" into file number
    inc bl
    mov ch, bl
    call xtox
    mov ax, 0xe2e ;.
    int 10h
    pop bx
    and bx, 0x1ff ;clear upper bits
    ;output index of string found location
    mov ch, bh
    call xtox
    mov ch, bl
    call xtox
    mov al, 0x20 ;space
    int 10h
    pop bx
seof:
    ;end of file
    or bx, 0x1ff
snot:
    inc bx ;next char
    cmp bh, 0x7e ;check if last file
    jge input
    jmp sloop

os:
    ;display largest folder
    mov ah, 8h ;get drive info
    mov dl, 0x80
    int 13h
    push cx
    shr cl, 6h ;upper bits of track
    mov ch, cl
    call xtox
    mov ch, dh ;sides
    call xtox
    pop cx ;cylinders
    call xtox
    call enter
    and cl, 0x3f ;clear upper bits
    mov ch, cl ;sectors
    call xtox
    jmp input

;ASSEMBLER
assembly:
    mov ax, 0x1a00
    mov gs, ax ;gs:di writes machine opcodes
    xor di, di
    mov byte [gs:di], 0x5c ;\ to mark executable for r command
    inc di
    call readfiles
    mov sp, 0x1000 ;reset stack pointer
    xor si, si ;fs:si stores labels and jmp
    push si ;store for labels
aconv:
    mov al, [es:bx] ;get char
    cmp al, 0x4d ;Mov
    je aM
    cmp al, 0x41 ;Add
    je aA
    cmp al, 0x53 ;Sub
    je aS
    cmp al, 0x54 ;Mul times
    je aaT
    cmp al, 0x44 ;Div
    je aD
    cmp al, 0x48 ;Inc high
    je aaH
    cmp al, 0x4c ;Dec less
    je aaL
    cmp al, 0x5a ;shift z
    je aZ
    cmp al, 0x51 ;rotate q
    je aQ
    cmp al, 0x42 ;And both
    je aB
    cmp al, 0x4f ;Or
    je aO
    cmp al, 0x58 ;Xor
    je aaX
    cmp al, 0x4e ;Not
    je aN
    cmp al, 0x55 ;pUsh u
    je aU
    cmp al, 0x50 ;Pop
    je aP
    cmp al, 0x49 ;Int
    je aI
    cmp al, 0x43 ;Cmp
    je aC
    cmp al, 0x47 ;in/out g
    je aG
    cmp al, 0x4a ;Jmp
    je aJ
    cmp al, 0x46 ;Call function
    je aF
    cmp al, 0x52 ;Ret
    je aR
    cmp al, 0x57 ;macro w
    je aW
    cmp al, 0x2e ;. label
    je aLabel
    cmp al, 0x4b ;db kreate
    je a1bk
    cmp al, 0x45 ;End
    je aE
    cmp al, 0h ;end of file
    je asave
    cmp al, 0x3b ;; comment
    je aComment
    cmp al, 0x22 ;" print
    je aPrint
    inc bx
    jmp aconv
acend:
    inc bx
    inc di
    jmp aconv
aM:
    ;MOV
    call aloop
    ;compare dl
    cmp dl, 0x52 ;Register
    je aMR
    cmp dl, 0x4e ;Number
    jne aMS      ;Segment
    ;MOV NUMBER
    mov dl, 0xb0 ;opcode for MN
    jmp amregstart
aMR:
    ;MOV REGISTER
    mov dh, 0x88 ;opcode for MR (or 89)
    jmp acombstart
aMS:
    cmp dl, 0x49 ;I= mov Xs, ax
    je aMI
    cmp dl, 0x4f ;O= mov ax, Xs
    je aMO
    cmp dl, 0x45 ;ME
    jb aMAstart
    cmp dl, 0x47 ;MG
    ja aMAstart  ;if not E,F,G -> mov xx, [xx:xx]
    ;mov [xx:xx], xx OR MIx
    mov al, ah
    mov ah, dl ;seg:off chars into ax
    push ax
    dec bx
    call aloop2 ;get register chars into ax
    mov cx, ax ;placed into cx
    pop ax
    mov dx, 0x8826 ;mov [xx:xx], al
    cmp cl, 0x58 ;X
    jne aMA
    inc dh
    jmp aMA
aMI:
    ;mov seg.reg, reg ;; MI rg sr
    mov dh, 0x8e
    jmp acomb
aMO:
    ;mov reg, seg.reg ;; MO rg sr
    mov dh, 0x8c
    jmp acomb
aMAstart:
    ;mov xx, [xx:xx]
    mov cl, ah
    mov ch, dl ;register chars into cx
    dec bx
    call aloop2 ;seg:off chars into ax
    mov dx, 0x8a26
    cmp cl, 0x58 ;X
    jne aMA
    inc dh ;16-bit
aMA:    
    cmp ah, 0x45 ;E:
    je aMA0
    cmp ah, 0x46 ;F:
    je aMA1
    cmp ah, 0x47 ;G:
    je aMA2
    jmp aerror
    ;inc dl from 0x26
aMA2:
    inc dl
aMA1:
    add dl, 0x3e
aMA0:
    mov [gs:di], dx ;save
    add di, 2h
    mov dl, 0x4 ;last byte for register
    cmp al, 0x42 ;B
    je aM2
    cmp al, 0x53 ;S
    je aM0
    cmp al, 0x54 ;T
    je aM1
    jmp aerror
    ;inc dl
aM2:
    add dl, 2h
aM1:
    inc dl
aM0:
    mov ax, cx ;prepare acomb
    mov ch, 8h ;number to add
    jmp acomb2
aA:
    ;ADD
    call aloop
    cmp dl, 0x4e
    je aAN
    cmp dl, 0x52
    je aAR
    jmp aerror
aAN:
    ;ADD NUMBER
    mov dx, 0x80c0
    mov ch, 1h
    jmp aregstart
aAR:
    ;ADD REGISTER
    mov dh, 0h
    jmp acombstart
aS:
    ;SUB
    call aloop
    cmp dl, 0x4e
    je aSN
    cmp dl, 0x52
    je aSR
    jmp aerror
aSN:
    mov dx, 0x80e8
    mov ch, 1h
    jmp aregstart
aSR:
    mov dh, 0x28
    jmp acombstart
aaT:
    ;MUL
    call aloop
    mov dx, 0xf6e0
    mov ch, 3h ;no argument
    jmp aregstart
aD:
    ;DIV
    call aloop
    mov dx, 0xf6f0
    mov ch, 3h ;no argument
    jmp aregstart
aaH:
    ;INC
    call aloop
    mov dx, 0xfec0
    mov ch, 3h
    jmp aregstart
aaL:
    ;DEC
    call aloop
    mov dx, 0xfec8
    mov ch, 3h
    jmp aregstart
aZ:
    ;SH R/L
    call aloop
    cmp dl, 0x52 ;R
    je aZR
    cmp dl, 0x4c ;L
    je aZL
    jmp aerror
aZR:
    mov dx, 0xc0e8
    mov ch, 1h
    cmp al, 0x58 ;X
    je aZQX
    jmp aregstart
aZL:
    mov dx, 0xc0e0
    mov ch, 1h
    cmp al, 0x58 ;X
    je aZQX
    jmp aregstart
aQ:
    call aloop
    cmp dl, 0x52 ;R
    je aQR
    cmp dl, 0x4c ;L
    je aQL
    jmp aerror
aQR:
    mov dx, 0xc0c8
    mov ch, 1h
    cmp al, 0x58 ;X
    je aZQX
    jmp aregstart
aQL:
    mov dx, 0xc0c0
    mov ch, 1h
    cmp al, 0x58 ;X
    je aZQX
    jmp aregstart
aZQX:
    ;Z and Q will take 8 bit argument even if 16 bit register
    dec ch ;will end up as 1h = 1 byte
    jmp aregstart
aB:
    ;AND
    call aloop
    cmp dl, 0x4e
    je aBN
    cmp dl, 0x52
    je aBR
    jmp aerror
aBN:
    mov dx, 0x80e0 ;special case
    mov ch, 1h
    jmp aregstart
aBR:
    mov dh, 0x20
    jmp acombstart
aO:
    ;OR
    call aloop
    cmp dl, 0x4e
    je aON
    cmp dl, 0x52
    je aOR
    jmp aerror
aON:
    mov dx, 0x80c8 ;special case
    mov ch, 1h
    jmp aregstart
aOR:
    mov dh, 0x8
    jmp acombstart
aaX:
    ;XOR
    call aloop
    cmp dl, 0x4e
    je aXN
    cmp dl, 0x52
    je aXR
    jmp aerror
aXN:
    mov dx, 0x80f3 ;special case
    mov ch, 1h
    jmp aregstart
aXR:
    mov dh, 0x30
    jmp acombstart
aN:
    ;NOT
    call aloop
    mov dx, 0xf6d0
    mov ch, 3h
    jmp aregstart
aC:
    ;CMP
    call aloop
    cmp dl, 0x4e
    je aCN
    cmp dl, 0x52
    je aCR
    jmp aerror
aCN:
    mov dx, 0x80f8 ;special case
    mov ch, 1h
    jmp aregstart
aCR:
    mov dh, 0x38
    jmp acombstart
aregstart:
    ;aregstart is for [mne] [reg], [imm8/16]
    ;dx contain opcode, and ch number of bytes in source
    ;byte or word move?
    cmp al, 0x58 ;X
    jne areg
    inc dh ;for r16
    inc ch ;2bytes
areg:
    mov [gs:di], dh
    ;get destination
    cmp ax, 0x4158 ;AX
    je ar0
    cmp ax, 0x4148 ;AH
    je ar4
    cmp ax, 0x414c ;AL
    je ar0
    cmp ax, 0x4258 ;BX
    je ar3
    cmp ax, 0x4248 ;BH
    je ar7
    cmp ax, 0x424c ;BL
    je ar3
    cmp ax, 0x4358 ;CX
    je ar1
    cmp ax, 0x4348 ;CH
    je ar5
    cmp ax, 0x434c ;CL
    je ar1
    cmp ax, 0x4458 ;DX
    je ar2
    cmp ax, 0x4448 ;DH
    je ar6
    cmp ax, 0x444c ;DL
    je ar2
    cmp ax, 0x5358 ;SX
    je ar6
    cmp ax, 0x5458 ;TX
    je ar7
    jmp aerror
    ;set dl = register
ar7:
    inc dl
ar6:
    inc dl
ar5:
    inc dl
ar4:
    inc dl
ar3:
    inc dl
ar2:
    inc dl
ar1:
    inc dl
ar0:
    inc di
    mov [gs:di], dl ;save register
    cmp ch, 1h
    je a1b
    cmp ch, 2h
    je a2b
    jmp acend ;else back
amregstart:
    ;amregstart is for mov [reg], [imm8/16]    
    mov ch, 0h ;adds to dl depending on combination
    mov dh, 1h ;number of bytes in source
    ;byte or word move?
    cmp al, 0x58 ;X
    jne amreg
    inc dh ;2h for r16
amreg:
    ;get register
    cmp ax, 0x4158 ;AX
    je amr8
    cmp ax, 0x4148 ;AH
    je amr4
    cmp ax, 0x414c ;AL
    je amr0
    cmp ax, 0x4258 ;BX
    je amr11
    cmp ax, 0x4248 ;BH
    je amr7
    cmp ax, 0x424c ;BL
    je amr3
    cmp ax, 0x4358 ;CX
    je amr9
    cmp ax, 0x4348 ;CH
    je amr5
    cmp ax, 0x434c ;CL
    je amr1
    cmp ax, 0x4458 ;DX
    je amr10
    cmp ax, 0x4448 ;DH
    je amr6
    cmp ax, 0x444c ;DL
    je amr2
    cmp ax, 0x5358 ;SX
    je amr14
    cmp ax, 0x5458 ;TX
    je amr15
    jmp aerror ;if not found
amr15:
    inc ch
amr14:
    add ch, 3h
amr11:
    inc ch
amr10:
    inc ch
amr9:
    inc ch
amr8:
    inc ch
amr7:
    inc ch
amr6:
    inc ch
amr5:
    inc ch
amr4:
    inc ch
amr3:
    inc ch
amr2:
    inc ch
amr1:
    inc ch
amr0:
    add dl, ch ;set dl as opcode
    mov [gs:di], dl
    ;jump depending on dh (byte or word)
    cmp dh, 1h
    je a1b
    jmp a2b ;else 2 bytes
acombstart:
    ;acombstart is for [mne] [reg], [reg]
    ;byte or word move?
    cmp al, 0x58 ;X
    jne acomb
    inc dh ;for r16
acomb: ;used by MI and MO
    mov [gs:di], dh ;opcode for operation
    mov dl, 0xc0 ;argument, for the various combinations
    mov ch, 1h ;adds to dl depending on combination
    inc di ;do it here due to segment moves MEBAL etc.
acomb2: ;for second round
    ;get combinations of registers
    cmp ax, 0x4158 ;AX
    je ac0
    cmp ax, 0x4148 ;AH
    je ac4
    cmp ax, 0x414c ;AL
    je ac0
    cmp ax, 0x4258 ;BX
    je ac3
    cmp ax, 0x4248 ;BH
    je ac7
    cmp ax, 0x424c ;BL
    je ac3
    cmp ax, 0x4358 ;CX
    je ac1
    cmp ax, 0x4348 ;CH
    je ac5
    cmp ax, 0x434c ;CL
    je ac1
    cmp ax, 0x4458 ;DX
    je ac2
    cmp ax, 0x4448 ;DH
    je ac6
    cmp ax, 0x444c ;DL
    je ac2
    cmp ax, 0x5358 ;SX
    je ac6
    cmp ax, 0x5458 ;TX
    je ac7
    cmp ax, 0x4553 ;ES
    je ac0
    cmp ax, 0x4653 ;FS
    je ac4
    cmp ax, 0x4753 ;GS
    je ac5
    jmp aerror ;if not found
    ;update dl = argument
ac7:
    add dl, ch
ac6:
    add dl, ch
ac5:
    add dl, ch
ac4:
    add dl, ch
ac3:
    add dl, ch
ac2:
    add dl, ch
ac1:
    add dl, ch
ac0:
    ;check if second round through
    cmp ch, 1h
    jne acombend
    ;get source
    call aloop2
    mov ch, 8h ;new add number
    jmp acomb2
acombend:
    mov [gs:di], dl ;enter combination
    jmp acend
aU:
    ;PUSH
    mov dl, 0x50
    jmp aUP
aP:
    mov dl, 0x58
aUP:
    inc bx
    mov al, [es:bx]
    cmp al, 0x41 ;AX
    je aU0
    cmp al, 0x42 ;BX
    je aU3
    cmp al, 0x43 ;CX
    je aU1
    cmp al, 0x44 ;DX
    je aU2
    cmp al, 0x53 ;SX (SI)
    je aU6
    cmp al, 0x54 ;TX (DI)
    jne aerror
aU7:
    inc dl
aU6:
    add dl, 3h   
aU3:
    inc dl
aU2:
    inc dl
aU1:
    inc dl
aU0: 
    mov [gs:di], dl
    jmp acend   
aI:
    ;INT
    mov byte [gs:di], 0xcd ;int
    jmp a1b
aG:
    ;IN/OUT
    inc bx
    mov dl, [es:bx]
    cmp dl, 0x49 ;I
    je aGI
    cmp dl, 0x4f ;O
    je aGO
    jmp aerror
aGI:
    ;IN
    mov byte [gs:di], 0xe4
    jmp a1b
aGO:
    ;OUT
    mov byte [gs:di], 0xe6
    jmp a1b
aF:
    mov byte [gs:di], 0xe8 ;call
    jmp aJMP
aR: 
    mov byte [gs:di], 0xc3 ;ret
    jmp acend
aW:
    ;macros, using Pikobrain functions
    mov byte [gs:di], 0xe8 ;call
    inc bx
    inc di
    mov cx, 0xe000 ;difference betwwen segment 0x1000: and 0x1200:, stores jump lenght
    mov al, [es:bx] ;next char
    cmp al, 0x41 ;atohex
    je aWA
    cmp al, 0x45 ;enter
    je aWE
    cmp al, 0x46 ;folder
    je aWF
    cmp al, 0x47 ;sGet
    je aWG
    cmp al, 0x48 ;xtoasc Hex
    je aWH
    cmp al, 0x4e ;fileNum
    je aWN
    cmp al, 0x4f ;readfiles2 Open
    je aWO
    cmp al, 0x52 ;random
    je aWR
    cmp al, 0x53 ;setfolder
    je aWS
    cmp al, 0x57 ;neW
    je aWW
    cmp al, 0x58 ;xtox
    je aWX
    jmp aerror
aWA:
    add cx, atohex ;adding location of function to cx
    jmp aWend
aWE:
    add cx, enter
    jmp aWend
aWF:
    add cx, folder
    jmp aWend
aWG:
    add cx, sget
    jmp aWend
aWH:
    add cx, xtoasc
    jmp aWend
aWN:
    add cx, filenum
    jmp aWend
aWO:
    add cx, readfiles2
    jmp aWend
aWR:
    add cx, random
    jmp aWend
aWS:
    add cx, setfolder
    jmp aWend
aWW:
    add cx, new
    jmp aWend
aWX:
    add cx, xtox
    jmp aWend
aWend:
    sub cx, di
    sub cx, 2h ;bacause of the size of this call
    mov word [gs:di], cx
    inc di
    jmp acend
aJ:
    inc bx
    mov al, [es:bx]
    cmp al, 0x4d ;M
    je aJM
    mov byte [gs:di], 0xf ;conditional far jump
    inc di
    cmp al, 0x45 ;Equal
    je aJE
    cmp al, 0x4e ;Not equal
    je aJNE
    cmp al, 0x47 ;Greater
    je aJG
    cmp al, 0x41 ;Above
    je aJA
    cmp al, 0x4c ;Less
    je aJL
    cmp al, 0x42 ;Below
    je aJB
    jmp aerror
aJE:
    mov byte [gs:di], 0x84
    jmp aJMP
aJNE:
    mov byte [gs:di], 0x85
    jmp aJMP
aJG:
    mov byte [gs:di], 0x8f
    jmp aJMP
aJA:
    mov byte [gs:di], 0x87
    jmp aJMP
aJL:
    mov byte [gs:di], 0x8c
    jmp aJMP
aJB:
    mov byte [gs:di], 0x82
    jmp aJMP
aJM:
    mov byte [gs:di], 0xe9 ;jmp
aJMP:
    call askip
    mov ax, 0x2000 ;fs:si stores jmp statements
    mov fs, ax
    inc di ;where machine code will be written
    mov cx, di ;store location of machine code pointer
    inc di ;to be correct later
    call aJMl
    inc si
    mov [fs:si], cx ;store di
    add si, 2h
    jmp acend
aJMl:
    ;store label name in fs:si
    mov al, [es:bx]
    mov [fs:si], al
    cmp al, 0x2e ;. end of label name
    je aJMlend
    inc si
    inc bx
    jmp aJMl
aJMlend:
    ret
aLabel:
    mov ax, 0x2800 ;fs:si stores labels
    mov fs, ax
    mov dx, si ;store for later
    pop si ;the si for 0x2800 is stored on stack
    mov cx, di ;store for later (dx=si, cx=di)
    inc bx ;get passed the 1st "." in label name
    call aJMl ;store label in buffer
    ;store memory location of label
    inc si
    mov [fs:si], cx ;store di
    add si, 2h
    push si
    mov si, dx ;return to normal
    inc bx
    jmp aconv
aComment:
    ;commenting
    inc bx
    mov al, [es:bx]
    cmp al, 0h ;end of file
    je aconv
    cmp al, 0xd ;newline = end of comment
    jne aComment
    jmp aconv
aE:
    ;end program by a far return
    mov byte [gs:di], 0xcb ;far return
    jmp acend
aPrint:
    ;print string
    mov word [gs:di], 0x0eb4 ;mov ah, 0xe
    inc di
aPloop: 
    inc bx
    mov ah, [es:bx]
    cmp ah, 0x22 ;" end of string
    je acend
    mov al, 0xb0 ;mov al
    inc di
    mov [gs:di], ax ;mov al, <>
    add di, 2h
    mov word [gs:di], 0x10cd ;int 10h
    inc di
    jmp aPloop
askip:
    ;skip whitespace
    inc bx
    mov al, [es:bx]
    cmp al, 0xd
    je askip
    cmp al, 0xa
    je askip
    cmp al, 0x20
    je askip
    ret
aloop:
    ;get args
    inc bx
    mov dl, [es:bx] ;store for cmp
aloop2:
    call askip
    ;get two chars, register
    mov ah, [es:bx]
    inc bx
    mov al, [es:bx] ;store ax
    ret
agetbyte:
    ;get 1 byte
    call askip
    mov al, [es:bx]
    call atohex
    mov ah, al
    shl ah, 4h ;move to upper nibble
    inc bx
    mov al, [es:bx]
    call atohex
    add al, ah ;put ah nibble into al
    ret
a2b:
    call agetbyte
    push ax
a1b:
    inc di
a1bk:
    call agetbyte
    push ax
abloop:
    pop ax
    mov [gs:di], al
    cmp sp, 0xffe ;since si pushed
    je acend
    inc di
    jmp abloop
aerror:
    ;output the location in source code
    mov ch, bh
    call xtox
    mov ch, bl
    call xtox
    mov ax, 0xe65 ;e
    int 10h
    ;will still save
asave:
    ;add jumps to machine code (second round)
    mov ax, 0x2000
    mov fs, ax
    mov byte [fs:si], 0h ;mark end of jmp list
    mov ax, 0x2800
    mov es, ax
    pop si
    mov byte [es:si], 0h ;mark end of label list
    xor si, si
aslstart:
    xor bx, bx
ascomp:
    push si
asaveloop:
    mov al, [fs:si] ;get jmp statement label
    cmp al, 0h
    je awrite ;end of jmps
    cmp al, [es:bx]
    jne ascompend ;not same name
    cmp al, 0x2e ;. end of label name
    je ascompeq ;label found
    inc si
    inc bx
    jmp asaveloop
ascompend:
    ;jump past label
    mov al, [es:bx]
    cmp al, 0x2e;. end of name
    je ascend
    cmp al, 0h ;label not found
    je alerror
    inc bx
    jmp ascompend
ascend:
    pop si ;reset
    add bx, 3h ;jump past label location
    jmp ascomp
ascompeq:
    ;label found
    inc si
    mov cx, [fs:si] ;jmp location   
    inc bx
    mov dx, [es:bx] ;label location
    sub dx, cx ;calculate jump lenght
    sub dx, 2h ;because of how jmps work
    mov bx, cx
    mov [gs:bx], dx ;store jump lenght
    ;update values for next round
    pop ax ;take down si
    add si, 2h ;go past jmp location
    jmp aslstart
alerror:
    pop si ;take down si
    mov ah, 0xe ;output label name
aleloop:
    ;label error
    mov al, [fs:si]
    int 10h
    inc si
    cmp al, 0x2e ;. end of name
    jne aleloop
awrite:
    mov ax, 0xe61 ;assembled
    int 10h
    ;buffer of machine code to be saved
    mov ax, 0x1a00
    mov es, ax
    xor bx, bx
    ;destination file
    call filenum
    call setfolder
    mov ax, di ;calculate number of files to save: di//0x200
    shr ax, 9h ;/200h
    inc al
    push cx
    push ax
    mov ch, al
    call xtox ;print size of machine code
    pop ax
    pop cx
    mov ah, 3h
    int 13h
    jmp input

run:
    ;run user program
    call readfiles
    cmp byte [es:bx], 0x5c ;\ marks executable (only these run)
    jne input
    call 0x1000:0x2001 ;location of program machine code
runcall: ;used in ctrl+break handler
    jmp input 


;***********
CTRL_BREAK: ;Location used in bootloader
;***********

    ;ctrl+break handler
    ;goes to input
    mov bx, sp ;store
    mov sp, 0xffe ;first stack item
breakloop:
    pop ax
    cmp ax, 0x1000 ;search for cs value 0x1000
    jne breakcon
    ;set new cs:ip values to 0x1000:0x200
    push ax ;0x1000
    sub sp, 2h
    pop ax
    cmp ax, runcall ;cs:ip will be at a different place while running
    je breakcon
    mov ax, input
    push ax
    mov sp, bx ;reset
    iret
breakcon:
    push ax
    sub sp, 2h ;next stack item
    jmp breakloop

    times 5632-($-$$) db 0h ;fill space

;commands to assemble and make into flp file linux + NASM
;nasm -f bin -o myfirst.bin myfirst.asm
;dd status=noxfer conv=notrunc if=myfirst.bin of=myfirst.flp

;to place onto USB:
;sudo dd if=piko.bin of=/dev/sdb

;to read file 0B of the USB on Linux (after using the j command)
;sudo head -c 5632 /dev/sdb | tail -c 512 > test.txt