X-Git-Url: https://git.rrq.au/?a=blobdiff_plain;f=main.asm;h=93e576fe684543b77547aa936a2b74a109e34116;hb=9b08decf6a8f5d454c90dbcbf12d42cb8954a022;hp=4e1a05fa1253d00f6a3b85b1a3ceeb46286bcdf6;hpb=c6ef34f80b3c194834b1522657166c2a36bf4a29;p=rrq%2Fjonasforth.git diff --git a/main.asm b/main.asm index 4e1a05f..93e576f 100644 --- a/main.asm +++ b/main.asm @@ -1,34 +1,31 @@ ;; vim: syntax=fasm -format ELF64 executable - -;; "Syscalls" {{{ - -;; [NOTE] Volatile registers Linux (syscalls) vs UEFI +;; At compile-time we load the module given by the environment variable +;; OS_INCLUDE. All of the following these procedures should preserve the value +;; of RSI and RSP. They may use other registers as they like. ;; -;; Linux syscalls: RAX, RCX, R11 -;; UEFI: RAX, RCX, R11, RDX, R8, R9, R10 - -;; We are in the process of replacing our dependency on Linux with a dependency -;; on UEFI. The following macros attempt to isolate what would be syscalls in -;; Linux; thus, we will be able to replace these with UEFI-based implementations, -;; and in theory we should expect the program to work. - -;; Print a string of a given length. +;; The module should provide the following: ;; -;; Input: -;; - RCX = Pointer to buffer -;; - RDX = Buffer length +;; os_code_section +;; Macro to start the text segment. ;; -;; Clobbers: RAX, RCX, R11, RDI, RSI -macro sys_print_string { - mov rax, 1 - mov rdi, 1 - mov rsi, rcx - syscall -} - -;; }}} +;; os_data_section +;; Macro to start the data segment. +;; +;; os_initialize +;; Called at initialization. +;; +;; os_print_string +;; Takes a string buffer in RCX and the length in RDX, and prints the string +;; to the console. +;; +;; os_read_char +;; Wait for the user to type a key, and then put the corresponding ASCII byte +;; into RAX. +;; +;; os_terminate +;; Shut down the system, returning the error code given in RAX. +include '%OS_INCLUDE%' ;; The code in this macro is placed at the end of each Forth word. When we are ;; executing a definition, this code is what causes execution to resume at the @@ -87,17 +84,17 @@ macro forth_asm label, name, immediate { .start: } -segment readable executable - -entry main - include "impl.asm" ; Misc. subroutines include "bootstrap.asm" ; Forth words encoded in Assembly +os_code_section + main: cld ; Clear direction flag so LODSQ does the right thing. mov rbp, return_stack_top ; Initialize return stack + call os_initialize + mov rax, MAIN jmp qword [rax] @@ -124,6 +121,17 @@ forth_asm LIT, 'LIT' push rax next +;; When LITSTRING is encountered while executing a word, it instead reads a +;; string from the definition of that word, and places that string on the stack +;; as (buffer, length). +forth_asm LITSTRING, 'LITSTRING' + lodsb + push rsi ; Buffer + movzx rax, al + push rax ; Length + add rsi, rax ; Skip over string before resuming execution + next + ;; Given a string (a pointer following by a size), return the location of the ;; dictionary entry for that word. If no such word exists, return 0. forth_asm FIND, 'FIND' @@ -188,45 +196,79 @@ forth_asm EMIT, 'EMIT' lea rcx, [rsp] mov rdx, 1 - sys_print_string + call os_print_string add rsp, 8 popr rax popr rsi next -;; Read a word and push it onto the stack as a pointer and a size. The pointer -;; is valid until the next call to READ_WORD. -forth_asm READ_WORD, 'READ-WORD' +;; Read a single character from the current input stream. Usually, this will wait +;; for the user to press a key, and then return the corresponding character. When +;; reading from a special buffer, it will instead return the next characater from +;; that buffer. +;; +;; The ASCII character code is placed on the stack. +forth_asm KEY, 'KEY' + call .impl + push rax + next + +;; Result in RAX +.impl: ;; Are we reading from user input or from the input buffer? cmp [input_buffer], 0 jne .from_buffer ;; Reading user input - mov [.rsi], rsi - - call read_word - push rdi ; Buffer - push rdx ; Length - - mov rsi, [.rsi] - next + call os_read_char + ret .from_buffer: ;; Reading from buffer - mov [.rsi], rsi + mov rax, [input_buffer] + movzx rax, byte [rax] + + inc [input_buffer] + dec [input_buffer_length] + ret + +;; Read a word and push it onto the stack as a pointer and a size. The pointer +;; is valid until the next call to READ_WORD. +forth_asm READ_WORD, 'READ-WORD' + push rsi +.skip_whitespace: + ;; Read characters until one of them is not whitespace. + call KEY.impl + ;; We consider newlines and spaces to be whitespace. + cmp al, ' ' + je .skip_whitespace + cmp al, $A + je .skip_whitespace + + ;; We got a character that wasn't whitespace. Now read the actual word. + mov [.length], 0 - mov rsi, [input_buffer] - mov rcx, [input_buffer_length] +.read_alpha: + movzx rbx, [.length] + mov rsi, .buffer + add rsi, rbx + mov [rsi], al + inc [.length] - call pop_word + call KEY.impl - mov [input_buffer], rsi ; Updated buffer - mov [input_buffer_length], rcx ; Length of updated buffer - push rdi ; Word buffer - push rdx ; Length of word buffer + cmp al, ' ' + je .end + cmp al, $A + jne .read_alpha + +.end: + pop rsi + push .buffer + movzx rax, [.length] + push rax - mov rsi, [.rsi] next ;; Takes a string on the stack and replaces it with the decimal number that the @@ -250,7 +292,7 @@ forth_asm TELL, 'TELL' pop rdx ; Length pop rcx ; Buffer - sys_print_string + call os_print_string popr rsi popr rax @@ -258,9 +300,8 @@ forth_asm TELL, 'TELL' ;; Exit the program cleanly. forth_asm TERMINATE, 'TERMINATE' - mov rax, $3C - mov rdi, 0 - syscall + mov rax, 0 + call os_terminate ;; Duplicate a pair of elements. forth_asm PAIRDUP, '2DUP' @@ -349,7 +390,7 @@ forth_asm DOTU, '.U' ;; Print the buffer mov rcx, .buffer mov rdx, [.printed_length] - sys_print_string + call os_print_string ;; Restore RSI and continue execution pop rsi @@ -422,13 +463,7 @@ forth_asm READ_STRING, 'S"' mov [.length], 0 .read_char: - mov rax, 0 - mov rdi, 0 - mov rsi, .char_buffer - mov rdx, 1 - syscall - - mov al, [.char_buffer] + call os_read_char cmp al, '"' je .done @@ -452,10 +487,6 @@ read_string_buffer: ;; We borrow READ_STRING's buffer. They won't mind. mov [READ_STRING.length], 0 - ;; Skip space ([TODO]: Shouldn't we do this while parsing instead?) - inc [input_buffer] - dec [input_buffer_length] - .read_char: mov rbx, [input_buffer] mov al, [rbx] @@ -584,7 +615,7 @@ forth INPUT_LENGTH, 'INPUT-LENGTH' dq LIT, input_buffer_length dq EXIT -segment readable writable +os_data_section ;; The LATEST variable holds a pointer to the word that was last added to the ;; dictionary. This pointer is updated as new words are added, and its value is @@ -616,6 +647,11 @@ DOTU.rbuffer rq 16 DOTU.length dq ? DOTU.printed_length dq ? +KEY.buffer dq ? + +READ_WORD.buffer rb $FF +READ_WORD.length db ? + ;; Reserve space for compiled words, accessed through HERE. here dq here_top here_top rq $4000 @@ -624,11 +660,11 @@ here_top rq $4000 rq $2000 return_stack_top: -segment readable - ;; We store some Forth code in sys.f that defined common words that the user ;; would expect to have available at startup. To execute these words, we just ;; include the file directly in the binary, and then interpret it at startup. -sysf file 'sys.f' +sysf: +file 'sys.f' +file 'example.f' sysf.len = $ - sysf