X-Git-Url: https://git.rrq.au/?a=blobdiff_plain;f=main.asm;h=f466a104d0b7caaba7e2f9f5f7ddfcf284a53e23;hb=38ab2f16dd683ac65c0567f3d7a079dcdc3edf2f;hp=4ddb26785e04a419d221f986de7c3ac223321f2a;hpb=fbde29458ada2d5943144e3b796339cee43474f3;p=rrq%2Fjonasforth.git

diff --git a/main.asm b/main.asm
index 4ddb267..f466a10 100644
--- a/main.asm
+++ b/main.asm
@@ -59,9 +59,15 @@ LIT:
   push rax
   next
 
-;; 0BRANCH is the fundamental mechanism for branching. If the top of the stack
-;; is zero, we jump by the given offset. 0BRANCH is given the offset as an
-;; integer after the word.
+;; 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:
+  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:
@@ -70,8 +76,7 @@ ZBRANCH:
   cmp rax, 0
   jnz .dont_branch
 .do_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
+  jmp BRANCH.start
 .dont_branch:
   add rsi, 8     ; We need to skip over the next word, which contains the offset.
   next
@@ -101,7 +106,7 @@ NEWLINE:
 
 ;; 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
+READ_WORD:
   dq .start
 .start:
   mov [.rsi], rsi
@@ -153,6 +158,60 @@ READ_WORD:  ; 400170
 
   next
 
+;; Takes a string on the stack and replaces it with the decimal number that the
+;; string represents.
+PARSE_NUMBER:
+  dq .start
+.start:
+  pop [.length]                 ; Length
+  pop rdi                       ; String pointer
+  mov r8, 0                     ; Result
+
+  ;; Add (10^(rcx-1) * parse_char(rdi[length - rcx])) to the accumulated value
+  ;; for each rcx.
+  mov rcx, [.length]
+.loop:
+  ;; First, calcuate 10^(rcx - 1)
+  mov rax, 1
+
+  mov r9, rcx
+  .exp_loop:
+    dec r9
+    jz .break
+    mov rbx, 10
+    mul rbx
+    jmp .exp_loop
+  .break:
+
+  ;; Now, rax = 10^(rcx - 1).
+
+  ;; We need to calulate the value of the character at rdi[length - rcx].
+  mov rbx, rdi
+  add rbx, [.length]
+  sub rbx, rcx
+  movzx rbx, byte [rbx]
+  sub rbx, '0'
+
+  ;; Multiply this value by rax to get (10^(rcx-1) * parse_char(rdi[length - rcx])),
+  ;; then add this to the result.
+  mul rbx
+
+  ;; Add that value to r8
+  add r8, rax
+
+  dec rcx
+  jnz .loop
+
+  push r8
+
+  next
+
+READ_NUMBER:
+  dq docol
+  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:
@@ -207,16 +266,74 @@ HELLO:
   dq NEWLINE
   dq EXIT
 
+;; .U prints the value on the stack as an unsigned integer in hexadecimal.
+DOTU:
+  dq .start
+.start:
+  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
+
 MAIN:
   dq docol
   dq HELLO
-  dq READ_WORD
-  dq LIT, you_typed_string
-  dq LIT, you_typed_string.length
-  dq TELL
-  dq TELL
-  dq NEWLINE
-  dq HELLO
+  dq READ_NUMBER, DOTU, NEWLINE
+  dq BRANCH, -8 * 4
   dq TERMINATE
 
 segment readable writable
@@ -231,6 +348,14 @@ READ_WORD.buffer rb READ_WORD.max_size
 READ_WORD.length db ?
 READ_WORD.char_buffer db ?
 
+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 ?
+
+PARSE_NUMBER.length dq ?
+
 ;; Return stack
 rq $2000
 return_stack_top: