Implement '\'-style comments

Implement the 'KEY' primitive for user input

This is a lower-level primitive for getting user input. We now also use this to
implement READ-WORD.

Clarify some explanations in the README

Update README with link to UEFI tutorial

Add instructions for running on real hardware

Improve build instructions in README

Handle newlines (in both input and output)

Show the user's input on screen as they are typing

Make it run on UEFI!

The program is now usable, albeit barely, running inside QEMU, with the only
dependency being UEFI! Very cool!

Right now, no output is printed to the screen when you type characters, newlines
aren't printed correctly, and the program doesn't accept Enter as valid
whitespace when reading input.

Get rid of remaining "loose" syscalls

Remove old code from example.f

Improve README and update information about sys.f

Finish implementing embedded sys.f

OK, this works... barely!

We have to omit the final newline in sys.f for it to work. We should probably
take another look at that.

But, it does technically work: We can now run just ./main, and the sys.f file
will be run automatically from inside the program. Very cool!

Use a different approach to reading from buffers

We now store INPUT-BUFFER as a global variable. Words like S" and READ-WORD
automatically use this INPUT-BUFFER if it's available.

Our program currently segfaults on startup, which is probably because of at
least one of the following:

1. We don't handle the case where an input buffer ends in whitespace in
   INTERPRET-STRING.
2. We don't do anything to resume reading from user input when the buffer has
   been exhausted.

Implement BUF"

This still doesn't actually work, because our definition of : doesn't make sense
when we're reading input from the buffer.

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