Implement INTERPRET-STRING

INTERPRET-STRING works, but the program crashes on startup, because sys.f uses
words that assume that they are being run with user input, for example S" and
READ-WORD.

Implement POP-WORD

Embed sys.f into binary and start working on POP-WORD

Refactor INTERPRET so we also have INTERPRET-WORD

Add notes about loading files from disk

Move some Forth words to separate 'bootstrap.asm' file

Move printing syscall to a macro

This will allow us to more easily replace it with the UEFI
implementation.

Add syntax=fasm to FASM files

Implement subroutine to read character

Implement a subroutine to print a byte-string of a given length

Add "Hello world" UEFI application

Set up QEMU and add some notes on UEFI

Separate example code from sys.f and add build instructions

Add support for comments

Reimplement HELLO in Forth

This implementation is a bit awkward right now, but we should be able to clean
it up later.

Implement looping words and add fibonacci example

Define ELSE

Define IF and THEN

Add error handling to parse_number

Fix bug in interface of parse_number

This procedure did not actually do what it claimed to be doing. It just happened
to work with the way it was called.

Implement some arithmetic words

Define ':' and ';' in Forth

Support compilation mode in INTERPRET

Now we can do

  S" BOOP" CREATE ] DOCOL HELLO 3 2 + .U NEWLINE EXIT [ BOOP

Add space for immediate flag

We don't actually use this for anything yet.

Implement CREATE

We can now do stuff like:

  S" 3HELLO" CREATE
  S" DOCOL" FIND >CFA ,
  S" HELLO" FIND >CFA ,
  S" HELLO" FIND >CFA ,
  S" HELLO" FIND >CFA ,
  S" EXIT" FIND >CFA ,
  3HELLO

Implement ','

Add variables 'LATEST' and 'HERE'

These will be used for compilation.

Automatically parse integers in INTERPRET

Implement '!' and '@' commands and add 'STATE' variable

Refactor: Create INTERPRET word

(We will probably want to write this in assembly when we add more
functionality.)

Move some assembly functions to separate module

Remove some unused code

Support executing words that the user enters

Add metadata to all words using macro

Implement FIND

I could only be bothered to add some of the words to the dictionary in this
commit. We should probably have a macro for that.

Implement word for reading numbers

Implement .U

Also implement BRANCH

I feel like we should theoretically be able to implement this in terms of
0BRANCH, but since we don't have a mechanism for getting the "outer" value of
RSI inside the function, we can't just implement it as

  : BRANCH 0 0BRANCH ;

In that case, RSI would point to EXIT when executing 0BRANCH.

Rename TYPE to TELL

This is what jonesforth uses, so we'll use the same convention.

Implement 0BRANCH

Add comments to Forth words that we expect to keep

Implement and use LIT

Implement READ_WORD

Implement TYPE

Change indentation to use 2 spaces

Add notes on IO and compilation

Add list of built-in variables

Terminate program correctly

Remove unused code

Add extension to notes file

Add somewhat working hello world

We exit by segfaulting, which is not very elegant.

Implement basic return stack

Add notes on how literals are handled

Add documentation describing how definitions are stored

Implement "next" macro and add related notes

Add notes about dictionary

Hello world in FASM