Add getmem, relmem, and fmtmem functions.

Dynamic memory allocation is going to be important for STS, even with as little
as 16KB of memory.  Defragmenting memory is also important, as we don't want to
waste memory due to accumulation of chunks too small to use.

When STS runs a program, it may bring in dependent libraries using the segment
loader as well.  Many programs can depend on the same libraries; as a result,
these libraries can be loaded at potentially different addresses.  To help keep
track of where these libraries are placed, STS relies on dynamically allocated
memory.  That's why getmem, relmem, and fmtmem functions exist.

How to use:

First you must format your memory pool.

	pool p !
	/pool reqsize !
	fmtmem

This creates the initial data structures required by getmem and relmem later.
The name isn't a joke -- formatting the memory pool will, as with formatting a
disk, destroy any previous allocations in the pool, so make sure you invoke it
knowing what you're doing.

Acquiring memory is possible using getmem:

	pool poolbase !		(if not already done elsewhere)
	/region reqsize !
	getmem
	result @ if ( handle error here ) then
	p @ memptr !

Make sure to release it again with relmem:

	memptr @ p !
	relmem

Note that defragmentation happens on allocation, not on free.  Hence, getmem
should not be used in real-time situations.  Pre-allocate your resources under
those circumstances.
Fix memory reservation split bug.

p=getmem(8) { allocates 16 byte block }
relmem(p) { frees that block; heap now has two chunks marked free }
q=getmem(8) { allocate 1st block again }

Originally, a chunk split happened regardless of size of request versus
first-fit chunk.  Since 1st available chunk size == allocated size, this
resulted in corrupting the 2nd chunk, which caused applications to crash.  Fix
is to check to see if we need to split the chunk in the first place.  If not,
just return the chunk as-is.
Add ENOTFOUND error for filesystem ops
Fix defragmentation bug when getting memory.

p=getmem(16)
relmem(p)
p=getmem(17)

would cause getmem to deadlock.

Apparently, my terminating condition for the defragmentation loop was not set
correctly.
Add rudimentary support for loadseg system call.

Supports only one code hunk per file.  Presently doesn't support relocation
records, but those should be on the easy side of implementing.
Support relocation records in loadseg.
Fixed test-loadseg heading comment.
refactoring constants into unique file
Documented constants.
A crude "disk" editor for SD card images.

This editor will let me edit SD card images before I place them on a real SD
card device.  In addition, it can let me work on making a repository of "disk
images" suitable for use with unit-level testing.
Start development of filesystem implementation.
Perform filename syntax sanity checking on open.

Filenames are required to conform to the DEV:FILENAME syntax at all times.
This ensures upward compatibility for when I implement support for installable
filesystems later on.
Search directory for file to open.

Limited!  This only searches the first directory block.  It isn't yet aware
that it should search the remaining directory blocks if a file isn't found.
That will be coming next.
Look at all directory sectors to find a file.

Previously, we only consulted a single directory sector.  Now, all sectors in
the directory (as allocated by the file named $DIR) are scanned for potential
matches.
Support Read-ing of files up to 1 sector in length.
Fix Read to work with files > 1 sector in length
Directory cleanup for actual implementation.
Separate IPL into its own image.

Make sure that the sys/ directory exists prior to building the IPL image.  It
compiles to sys/$IPL.
Isolate kernel into its own build artifact.

As with $IPL, make sure the sys/ directory exists, as the kernel will compile
into a file called $SYS.
Add Go tool to make an FS5 image for booting.

Bundles IPL, kernel, and zero or more non-system files and properly constructs
the volume's directory accordingly.  All files are properly sized automatically
-- you don't need to allocate file storage manually.

However, you need to make sure you reserve enough directory sectors.  If you
don't, file corruption may occur.