X-Git-Url: https://git.rrq.au/?a=blobdiff_plain;f=main.asm;h=5985b997af8095926394802fd7e6c59b636a5510;hb=bcba0c88f4eaddac8e0d8c0fa68264b2e81ee272;hp=4e1a05fa1253d00f6a3b85b1a3ceeb46286bcdf6;hpb=c6ef34f80b3c194834b1522657166c2a36bf4a29;p=rrq%2Fjonasforth.git

diff --git a/main.asm b/main.asm
index 4e1a05f..5985b99 100644
--- a/main.asm
+++ b/main.asm
@@ -1,18 +1,25 @@
 ;; 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. This module should define the following macros:
 ;;
-;;   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.
+;; Each of these functions should preserve the value of RSI and RSP. They may
+;; use other registers as they like.
+;;
+;; 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 the buffer pointed to by RCX.
+;;
+;; os_terminate
+;;   Shut down the system.
+include '%OS_INCLUDE%'
 
 ;; Print a string of a given length.
 ;;
@@ -22,13 +29,47 @@ format ELF64 executable
 ;;
 ;; Clobbers: RAX, RCX, R11, RDI, RSI
 macro sys_print_string {
-  mov rax, 1
-  mov rdi, 1
-  mov rsi, rcx
-  syscall
+  push r8
+  push r9
+  push r10
+
+  call os_print_string
+
+  pop r10
+  pop r9
+  pop r8
+}
+
+;; Read a character from the user into the given buffer.
+;;
+;; Input:
+;; - RSI = Character buffer
+;;
+;; Output:
+;; - BYTE [RSI] = Character
+;;
+;; Clobbers: RAX, RCX, R11, RDI, RSI, RDX
+macro sys_read_char {
+  push rbx
+  push r8
+  push r9
+  push r10
+  push r15
+
+  mov rcx, rsi
+  call os_read_char
+
+  pop r15
+  pop r10
+  pop r9
+  pop r8
+  pop rbx
 }
 
-;; }}}
+macro sys_terminate code {
+  mov rax, code
+  call os_terminate
+}
 
 ;; 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,9 +128,7 @@ macro forth_asm label, name, immediate {
 .start:
 }
 
-segment readable executable
-
-entry main
+section '.text' code readable executable
 
 include "impl.asm"      ; Misc. subroutines
 include "bootstrap.asm" ; Forth words encoded in Assembly
@@ -98,6 +137,8 @@ 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 +165,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'
@@ -195,38 +247,77 @@ forth_asm EMIT, 'EMIT'
   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
+  push rsi
+  mov rsi, .buffer
+  sys_read_char
+  pop rsi
 
-  mov rsi, [.rsi]
-  next
+  movzx rax, byte [.buffer]
+  ret
 
 .from_buffer:
   ;; Reading from buffer
-  mov [.rsi], rsi
+  mov rax, [input_buffer]
+  movzx rax, byte [rax]
 
-  mov rsi, [input_buffer]
-  mov rcx, [input_buffer_length]
+  inc [input_buffer]
+  dec [input_buffer_length]
+  ret
 
-  call pop_word
+;; 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 [input_buffer], rsi        ; Updated buffer
-  mov [input_buffer_length], rcx ; Length of updated buffer
-  push rdi                       ; Word buffer
-  push rdx                       ; Length of word buffer
+.read_alpha:
+  movzx rbx, [.length]
+  mov rsi, .buffer
+  add rsi, rbx
+  mov [rsi], al
+  inc [.length]
+
+  call KEY.impl
+
+  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
@@ -258,9 +349,7 @@ forth_asm TELL, 'TELL'
 
 ;; Exit the program cleanly.
 forth_asm TERMINATE, 'TERMINATE'
-  mov rax, $3C
-  mov rdi, 0
-  syscall
+  sys_terminate 0
 
 ;; Duplicate a pair of elements.
 forth_asm PAIRDUP, '2DUP'
@@ -422,11 +511,8 @@ forth_asm READ_STRING, 'S"'
   mov [.length], 0
 
 .read_char:
-  mov rax, 0
-  mov rdi, 0
   mov rsi, .char_buffer
-  mov rdx, 1
-  syscall
+  sys_read_char
 
   mov al, [.char_buffer]
   cmp al, '"'
@@ -452,10 +538,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 +666,7 @@ forth INPUT_LENGTH, 'INPUT-LENGTH'
   dq LIT, input_buffer_length
   dq EXIT
 
-segment readable writable
+section '.data' readable writable
 
 ;; 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 +698,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,8 +711,6 @@ 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.