X-Git-Url: https://git.rrq.au/?a=blobdiff_plain;f=main.asm;h=edcba0ae9421c712218041e64d4fc0872370f8d9;hb=2d2c007e5b5e2f9b79271d638863d77338969f38;hp=f665f952ba5c44ffa02204c2528ee5f4ca090daa;hpb=0e388e347f54e828df6b9b227c4009584b2173d7;p=rrq%2Fjonasforth.git

diff --git a/main.asm b/main.asm
index f665f95..edcba0a 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,33 +86,54 @@ 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
 
 ;; LIT is a special word that reads the next "word pointer" and causes it to be
 ;; placed on the stack rather than executed.
-LIT:
-  dq .start
-.start:
+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.
-BRANCH:
-  dq .start
-.start:
+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.
-ZBRANCH:
-  dq .start
-.start:
+forth_asm ZBRANCH, '0BRANCH'
   ;; Compare top of stack to see if we should branch
   pop rax
   cmp rax, 0
@@ -81,10 +144,18 @@ ZBRANCH:
   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.
-EMIT:
-  dq .start
-.start:
+forth_asm EMIT, 'EMIT'
   pushr rsi
   pushr rax
   mov rax, 1
@@ -98,71 +169,50 @@ EMIT:
   next
 
 ;; Prints a newline to standard output.
-NEWLINE:
-  dq docol
+forth NEWLINE, 'NEWLINE'
   dq LIT, $A
   dq EMIT
   dq EXIT
 
+;; 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]
 
-  mov rax, 0
-  mov rdi, 0
-  mov rsi, .char_buffer
-  mov rdx, 1
-  syscall
+  call read_word
+  push rdi                      ; Buffer
+  push rdx                      ; Length
 
-  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
 
+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.
-TELL:
-  dq .start
-.start:
+forth_asm TELL, 'TELL'
   mov rbx, rsi
   mov rcx, rax
 
@@ -177,32 +227,12 @@ TELL:
   next
 
 ;; Exit the program cleanly.
-TERMINATE:
-  dq .start
-.start:
+forth_asm TERMINATE, 'TERMINATE'
   mov rax, $3C
   mov rdi, 0
   syscall
 
-PUSH_HELLO_CHARS:
-  dq docol
-  dq LIT, $A
-  dq LIT, 'o'
-  dq LIT, 'l'
-  dq LIT, 'l'
-  dq LIT, 'e'
-  dq LIT, 'H'
-  dq EXIT
-
-PUSH_YOU_TYPED:
-  dq .start
-.start:
-  push you_typed_string
-  push you_typed_string.length
-  next
-
-HELLO:
-  dq docol
+forth HELLO, 'HELLO'
   dq LIT, 'H', EMIT
   dq LIT, 'e', EMIT
   dq LIT, 'l', EMIT
@@ -212,30 +242,120 @@ HELLO:
   dq NEWLINE
   dq EXIT
 
-MAIN:
-  dq docol
-  dq HELLO
+;; 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'
   dq READ_WORD
-  dq LIT, you_typed_string
-  dq LIT, you_typed_string.length
-  dq TELL
-  dq TELL
-  dq NEWLINE
-  dq BRANCH, -72
+  dq FIND
+  dq TCFA
+  dq EXEC
+  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
+
+  ;; 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
+
+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
+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 ?
 
 ;; Return stack
 rq $2000