X-Git-Url: https://git.rrq.au/?a=blobdiff_plain;f=main.asm;h=cbf8a139d6e4df42f6cfc6ab17b432b39a0efbe3;hb=623eb650651ba4105e4e91239c52b04ed0e5cd85;hp=d206134c08b968bee7d52fb94564de5c4bff8c6f;hpb=8bbafbbf07642341c7134325e8e743259cb159b0;p=rrq%2Fjonasforth.git

diff --git a/main.asm b/main.asm
index d206134..cbf8a13 100644
--- a/main.asm
+++ b/main.asm
@@ -23,14 +23,56 @@ macro popr x {
   add rbp, 8
 }
 
+;; The following macro generates the dictionary header. It updates the
+;; initial_latest_entry variable, which is used as the initial value of the
+;; latest_entry variable that is made available at runtime.
+;;
+;; The header contains a link to the previous entry, the length of the name of
+;; the word and the word itself as a string literal.
+;;
+;; This macro also defines a label LABEL_entry.
+initial_latest_entry = 0
+macro header label, name {
+  local .string_end
+
+label#_entry:
+  dq initial_latest_entry
+  db .string_end - ($ + 1)
+  db name
+  .string_end:
+label:
+
+initial_latest_entry = label#_entry
+}
+
+;; Define a Forth word that is implemented in assembly. See 'header' for details.
+macro forth_asm label, name {
+  header label, name
+  dq .start
+.start:
+}
+
+;; Define a Forth word that is implemented in Forth. (The body will be a list of
+;; 'dq' statements.)
+macro forth label, name {
+  header label, name
+  dq docol
+}
+
+
+
 segment readable executable
 
+entry main
+
+include "impl.asm"
+
 main:
   cld                        ; Clear direction flag so LODSQ does the right thing.
   mov rbp, return_stack_top  ; Initialize return stack
 
-  mov rsi, program
-  next
+  mov rax, MAIN
+  jmp qword [rax]
 
 program: dq MAIN
 
@@ -44,15 +86,76 @@ docol:
 
 ;; This word is called at the end of a Forth definition. It just needs to
 ;; restore the old value of RSI (saved by 'docol') and resume execution.
-EXIT:
-  dq .start
-.start:
+forth_asm EXIT, 'EXIT'
   popr rsi
   next
 
-EMIT:
-  dq .start
-.start:
+;; LIT is a special word that reads the next "word pointer" and causes it to be
+;; placed on the stack rather than executed.
+forth_asm LIT, 'LIT'
+  lodsq
+  push rax
+  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'
+  mov [.rsi], rsi
+
+  pop [find.search_length]
+  pop [find.search_buffer]
+  mov rsi, [latest_entry]       ; Start with the last added word
+  call find
+  push rsi
+
+  mov rsi, [.rsi]
+  next
+  push rsi
+
+  mov rsi, [.rsi]
+  next
+
+;; Given an entry in the dictionary, return a pointer to the codeword of that
+;; entry.
+forth_asm TCFA, '>CFA'
+  pop rax
+  add rax, 8                    ; [rax] = length of name
+  movzx rbx, byte [rax]
+  inc rax
+  add rax, rbx                  ; [rax] = codeword
+  push rax
+  next
+
+;; BRANCH is the fundamental mechanism for branching. BRANCH reads the next word
+;; as a signed integer literal and jumps by that offset.
+forth_asm BRANCH, 'BRANCH'
+  add rsi, [rsi] ; [RSI], which is the next word, contains the offset; we add this to the instruction pointer.
+  next           ; Then, we can just continue execution as normal
+
+;; 0BRANCH is like BRANCH, but it jumps only if the top of the stack is zero.
+forth_asm ZBRANCH, '0BRANCH'
+  ;; Compare top of stack to see if we should branch
+  pop rax
+  cmp rax, 0
+  jnz .dont_branch
+.do_branch:
+  jmp BRANCH.start
+.dont_branch:
+  add rsi, 8     ; We need to skip over the next word, which contains the offset.
+  next
+
+;; Duplicate the top of the stack.
+forth_asm DUP_, 'DUP'
+  push qword [rsp]
+  next
+
+;; Execute the codeword at the given address.
+forth_asm EXEC, 'EXEC'
+  pop rax
+  jmp qword [rax]
+
+;; Expects a character on the stack and prints it to standard output.
+forth_asm EMIT, 'EMIT'
   pushr rsi
   pushr rax
   mov rax, 1
@@ -65,75 +168,51 @@ EMIT:
   popr rsi
   next
 
-PUSH_NEWLINE_CHAR:
-  dq .start
-.start:
-  push $A
-  next
+;; Prints a newline to standard output.
+forth NEWLINE, 'NEWLINE'
+  dq LIT, $A
+  dq EMIT
+  dq EXIT
 
-NEWLINE:
-  dq docol
-  dq PUSH_NEWLINE_CHAR
+;; Prints a space to standard output.
+forth SPACE, 'SPACE'
+  dq LIT, ' '
   dq EMIT
   dq EXIT
 
 ;; Read a word from standard input and push it onto the stack as a pointer and a
 ;; size. The pointer is valid until the next call to READ_WORD.
-READ_WORD:  ; 400170
-  dq .start
-.start:
+forth_asm READ_WORD, 'READ-WORD'
   mov [.rsi], rsi
-  mov [.rax], rax
 
-.skip_whitespace:
-  ;; Read characters into .char_buffer until one of them is not whitespace.
-  mov rax, 0
-  mov rdi, 0
-  mov rsi, .char_buffer
-  mov rdx, 1
-  syscall
-
-  cmp [.char_buffer], ' '
-  je .skip_whitespace
-  cmp [.char_buffer], $A
-  je .skip_whitespace
-
-.alpha:
-  ;; We got a character that wasn't whitespace. Now read the actual word.
-  mov [.length], 0
-
-.read_alpha:
-  mov al, [.char_buffer]
-  movzx rbx, [.length]
-  mov rsi, .buffer
-  add rsi, rbx
-  mov [rsi], al
-  inc [.length]
+  call read_word
+  push rdi                      ; Buffer
+  push rdx                      ; Length
 
-  mov rax, 0
-  mov rdi, 0
-  mov rsi, .char_buffer
-  mov rdx, 1
-  syscall
-
-  cmp [.char_buffer], ' '
-  je .end
-  cmp [.char_buffer], $A
-  jne .read_alpha
+  mov rsi, [.rsi]
+  next
 
-.end:
-  push .buffer
-  movzx rax, [.length]
-  push rax
+;; Takes a string on the stack and replaces it with the decimal number that the
+;; string represents.
+forth_asm PARSE_NUMBER, 'PARSE-NUMBER'
+  pop [parse_number.length]     ; Length
+  pop [parse_number.buffer]     ; String pointer
 
-  mov rsi, [.rsi]
-  mov rax, [.rax]
+  push rsi
+  call parse_number
+  pop rsi
 
+  push rax                      ; Result
   next
 
-TYPE:
-  dq .start
-.start:
+forth READ_NUMBER, 'READ-NUMBER'
+  dq READ_WORD
+  dq PARSE_NUMBER
+  dq EXIT
+
+;; Takes a string (in the form of a pointer and a length on the stack) and
+;; prints it to standard output.
+forth_asm TELL, 'TELL'
   mov rbx, rsi
   mov rcx, rax
 
@@ -147,65 +226,196 @@ TYPE:
   mov rsi, rbx
   next
 
-PUSH_HELLO_CHARS:
-  dq .start
-.start:
-  push $A
-  push 'o'
-  push 'l'
-  push 'l'
-  push 'e'
-  push 'H'
+;; Exit the program cleanly.
+forth_asm TERMINATE, 'TERMINATE'
+  mov rax, $3C
+  mov rdi, 0
+  syscall
+
+forth HELLO, 'HELLO'
+  dq LIT, 'H', EMIT
+  dq LIT, 'e', EMIT
+  dq LIT, 'l', EMIT
+  dq LIT, 'l', EMIT
+  dq LIT, 'o', EMIT
+  dq LIT, '!', EMIT
+  dq NEWLINE
+  dq EXIT
+
+;; Duplicate a pair of elements.
+forth_asm PAIRDUP, '2DUP'
+  pop rbx
+  pop rax
+  push rax
+  push rbx
+  push rax
+  push rbx
   next
 
-PUSH_YOU_TYPED:
-  dq .start
-.start:
-  push you_typed_string
-  push you_typed_string.length
+;; Swap the top two elements on the stack.
+forth_asm SWAP, 'SWAP'
+  pop rax
+  pop rbx
+  push rax
+  push rbx
   next
 
-HELLO:
-  dq docol
-  dq PUSH_HELLO_CHARS
-  dq EMIT
-  dq EMIT
-  dq EMIT
-  dq EMIT
-  dq EMIT
-  dq EMIT
+;; Remove the top element from the stack.
+forth_asm DROP, 'DROP'
+  add rsp, 8
+  next
+
+;; The INTERPRET word reads and interprets user input. It's behavior depends on
+;; the current STATE. It provides special handling for integers. (TODO)
+forth INTERPRET, 'INTERPRET'
+  ;; Read word
+  dq READ_WORD
+  dq PAIRDUP
+  ;; Stack is (word length word length).
+  dq FIND                       ; Try to find word
+  dq DUP_
+  dq ZBRANCH, 8 * 8             ; Check if word is found
+
+  ;; Word is found, execute it
+  dq TCFA
+  ;; Stack is (word length addr)
+  dq SWAP, DROP
+  dq SWAP, DROP
+  ;; Stack is (addr)
+  dq EXEC
   dq EXIT
 
-TERMINATE:
-  dq .start
-  .start:
-  mov rax, $3C
-  mov rdi, 0
+  ;; No word is found, assume it is an integer literal
+  ;; Stack is (word length addr)
+  dq DROP
+  dq PARSE_NUMBER
+  dq EXIT
+
+;; .U prints the value on the stack as an unsigned integer in hexadecimal.
+forth_asm DOTU, '.U'
+  mov [.length], 0
+  mov [.printed_length], 1
+  pop rax                       ; RAX = value to print
+  push rsi                      ; Save value of RSI
+
+  ;; We start by constructing the buffer to print in reverse
+
+.loop:
+  mov rdx, 0
+  mov rbx, $10
+  div rbx                       ; Put remainer in RDX and quotient in RAX
+
+  ;; Place the appropriate character in the buffer
+  mov rsi, .chars
+  add rsi, rdx
+  mov bl, [rsi]
+  mov rdi, .rbuffer
+  add rdi, [.length]
+  mov [rdi], bl
+  inc [.length]
+
+  ;; .printed_length is the number of characters that we ulitmately want to
+  ;; print. If we have printed a non-zero character, then we should update
+  ;; .printed_length.
+  cmp bl, '0'
+  je .skip_updating_real_length
+  mov rbx, [.length]
+  mov [.printed_length], rbx
+.skip_updating_real_length:
+
+  cmp [.length], 16
+  jle .loop
+
+  ;; Flip buffer around, since it is currently reversed
+  mov rcx, [.printed_length]
+.flip:
+  mov rsi, .rbuffer
+  add rsi, rcx
+  dec rsi
+  mov al, [rsi]
+
+  mov rdi, .buffer
+  add rdi, [.printed_length]
+  sub rdi, rcx
+  mov [rdi], al
+
+  loop .flip
+
+  ;; Print the buffer
+  mov rax, 1
+  mov rdi, 1
+  mov rsi, .buffer
+  mov rdx, [.printed_length]
   syscall
 
-MAIN:
-  dq docol
-  dq HELLO
-  dq READ_WORD
-  dq PUSH_YOU_TYPED
-  dq TYPE
-  dq TYPE
-  dq NEWLINE
+  ;; Restore RSI and continue execution
+  pop rsi
+  next
+
+;; Takes a value and an address, and stores the value at the given address.
+forth_asm PUT, '!'
+  pop rbx                       ; Address
+  pop rax                       ; Value
+  mov [rbx], rax
+  next
+
+;; Takes an address and returns the value at the given address.
+forth_asm GET, '@'
+  pop rax
+  mov rax, [rax]
+  push rax
+  next
+
+;; Get the location of the STATE variable. It can be set with '!' and read with
+;; '@'.
+forth STATE, 'STATE'
+  dq LIT, var_STATE
+  dq EXIT
+
+;; Get the location of the LATEST variable. It can be set with '!' and read with
+;; '@'.
+forth LATEST, 'LATEST'
+  dq LIT, latest_entry
+  dq EXIT
+
+;; Get the location at which compiled words are expected to be added. This
+;; pointer is usually modified automatically when calling ',', but we can also
+;; read it manually with 'HERE'.
+forth HERE, 'HERE'
+  dq LIT, here
+  dq EXIT
+
+forth MAIN, 'MAIN'
   dq HELLO
+  dq INTERPRET
+  dq BRANCH, -8 * 2
   dq TERMINATE
 
 segment readable writable
 
-you_typed_string db 'You typed: '
-.length = $ - you_typed_string
+;; 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
+;; used by FIND to look up words.
+latest_entry dq initial_latest_entry
+
+;; The STATE variable is 0 when the interpreter is executing, and non-zero when
+;; it is compiling.
+var_STATE dq 0
+
+FIND.rsi dq ?
 
 READ_WORD.rsi dq ?
-READ_WORD.rax dq ?
-READ_WORD.max_size = $FF
-READ_WORD.buffer rb READ_WORD.max_size
-READ_WORD.length db ?
-READ_WORD.char_buffer db ?
+READ_WORD.rbp dq ?
+
+DOTU.chars db '0123456789ABCDEF'
+DOTU.buffer rq 16               ; 64-bit number has no more than 16 digits in hex
+DOTU.rbuffer rq 16
+DOTU.length dq ?
+DOTU.printed_length dq ?
 
+;; Reserve space for compiled words, accessed through HERE.
+here dq here_top
+here_top rq $2000
 
 ;; Return stack
 rq $2000