snapshot before branching

reformat to 80 columns

reformat to 80 columns

cleanup

experimental load actions

slight rebranding

revised to build raw EFI disk

Fix path issue for 'os/uefi.asm'

This fixes #2. Looks like I forgot to update the path for this in the last commit
66af56e (Restructure project directories).

Restructure project directories

We now split the project into three different directories:

- src/ for assembly code;
- init/ for Forth code that is run automatically;
- lib/ for Forth code that the user can type in.

Implement UEFI functionality in Forth

This is pretty cool. We can now print string and draw rectangles using UEFI,
with words that are defined in Forth. See example.f (which uses uefi.f) for an
example of how to draw a rectangle.

This removes support for the Linux backend that was recently merged in 9b08dec,
because it doesn't really make sense to maintain this backend if we're going to
be defining Forth words that only work on UEFI anyway.

Revert support for Linux backend

Now that we're implementing UEFI-related words directly in Forth, it doesn't
make much sense to provide an alternative Linux backend. That was a dead end.

Refactor UEFI graphics code and move example to example.f

Use Graphics Output Protocol to draw a rectangle

Implement UTF16" to store UEFI-compatible string

Support calling EFI functions directly from Forth

Obviously, this doesn't work with the Linux backend. Maybe we'll have to remove
that again, since it would basically require a UEFI emulator.

Add startup.nsh to QEMU drive

This reduces the amount of typing that we have to do. Now the UEFI application
automatically runs on startup.

Add alternative Linux backend

You can now run:

    make main && ./main

To run the interpreter without needing to boot up a virtual machine.

Note that this mode uses per-line buffering by default, so you may have to press
enter where you would normally only need a space.

Implement Linux backend

You can now run:

    make main && ./main

To run the interpreter without needing to boot up a virtual machine.

Note that this mode uses per-line buffering by default, so you may have to press
enter where you would normally only need a space.

Add placeholder implementation of Linux backend

Clean up OS interface

We got rid of those weird macros that would try to preserve a bunch of registers
for no reason. The OS interface was changes slightly to allow for simpler
implementation and usage.

Rename UEFI procedures to generic naming scheme

Supply UEFI module path as environment variable

We'd like to have multiple backends -- e.g. Linux instead of UEFI. That would
make testing less cumbersome.

Also remove an outdated comment.

Make S" work inside compiled words

The approach we're using here is kinda silly and cause by the fact that I
wasn't/still aren't very familiar with Forth outside of trying to implement it
myself.

From doing a bit of reading, it sounds like S" is primarily intended to be used
inside definitions -- not at runtime. So now we use the old, weird S" (that has a
single static buffer and only works at runtime) to bootstrap the system, then
replace it with a more sensible S" that only works at compile time.

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