Move the array library into the data module.

Keep more data around about ir instructions. Implement a half-baked type
inference routine to propagate information about floats up the tree, so we know
whether to put floats into special registers as early as possible.

Start factoring out the hardware op code.

Sort of keep track of registers and register classes. Start walking the
generated instruction tree --- holy cow, they look like instructions!

Collapse several rule arrays into one; actually generate the array properly.

Rename struct insn to struct em (throughout).

Stupid stringlist is stupid. Use a proper data structure, properly abstracted
out (so other things can use it).

Rethink the way patterns are mapped to rules; generate emitters (probably
badly).

We now record the code fragments to be emitted by each rule.

Instruction selection is so important the file needs a longer name.

Some instruction selection is now happening.

More grammar changes.

IR codes are now owned by mcgg; ir terminals are inserted into the table during
compilation (so you can refer to them).

Crudely bolt on mcgg to mcg itself.

Parameters are parsed with getopt. Simplify, constify.

Change the predicate stuff to use costs instead; now you can use when clauses
on leaves. Remove an iburg premature optimisation (required for above).

Lots of exploratory new grammar for instruction definitions and string and
fragment emission (none of which is hooked up to anything yet).

Add support for labelled tree nodes.

Fix some late-night typo bugs.

Procedure compilation now happens after the entire EM file has been read in (so
that we can look inside data blocks which might be defined in the future...
sigh, csa and csb). csa and csb no longer generate invalid IR.

Replaced the block splicer with a trivial block eliminator (which rewrites
jumps to blocks which contain only a jump). Don't bother storing the bb graph
in the ir nodes; we can find it on demand by walking the tree instead ---
slower, but much easier to understand and more robust. Added a terrible map
library.

Each pass now lives in its own source file; much cleaner.

Add a bodged in algorithm for converting basic block communication from stacked
variables to SSA. Also add dead block removal and block splicing. IR code is
much better now.

Tracing cleanup. Simplified the IR code. Some more opcodes.

Massive grammar overhaul and refactor. Hacked in support for predicates, where
instructions can be turned on and off based on their parameters. New lexer
using a lexer. Now quite a lot of the way towards being a real instruction
selector.

Run through clang-format.

Strip out surplus files. Rewrite README.

Import iburg.

Import iburg.

Create hacky fake basic blocks for data fragments, used to track which
instruction labels descriptor blocks refer to; this allows csa and csb to know
where they're going.

Treebuilder now gets to the bottom of my test file, merrily generating
(probably horribly broken) IR.

Store the EM code up front and build the basic block graph *before*
generating the IR code. Lots more IR code.

Archival checking of the half-written IR treebuilder.

ANSIise to fix warnings.

Abstract out the EM reader; skeleton of the tree builder.

Basic skeleton of em parser.

Merge pull request #3 from kernigh/ego-fix

Fix bugs with memory allocation in ego.

Fix bugs with memory allocation in ego.

cf/cf_loop.c and share/put.c tried to read the next pointer in an
element of a linked list after freeing the element.  ud/ud_copy.c
tried to read beyond the end of the _defs_ array: it only has
_nrexpldefs_ elements, not _nrdefs_ elements.

These bugs caused core dumps on OpenBSD.  Its malloc() put _defs_ near
the end of a page, so reading beyond the end crossed into an unmapped
page.  Its free() wrote junk bytes and changed the next pointer to
0xdfdfdfdfdfdfdfdf.

Add unlink system call.

Cleanup some stray files.

Add modeline, fix formatting.

Updated.

More documentation.

First half of the ackbuilder documentation.

Makefiles are now slightly less inaccurate. Does actually seem to do sensible
incremental builds now. I loathe make.

Add an install target.

Distributions are a pain --- let's not bother any more. Instead, we just tag
the repository and download a complete snapshot, old and ancient stuff and all.

Remove the old make-based build system, plus some big chunks of horribly
obsolete protomake build system.

Clean up the top level makefile.

Fix a fun bug where, every now again, ego would get its temporary files mangled
and generate invalid calls to the optimisers.

Previously ego would generate a temporary file template that looked like
/tmp/ego.A.BB.XXXXXX, call mktemp() on it to randomise the XXXXXX, and then
replace A and BB with data.

However, it used strrchr to find the A and B. Which would fine, except when
mktemp produced an A or a B in the randomised part...

This code was written on 4 March 1991. I was 16.

Forgot to check a file in.

ego now builds and is used.

This needed lots of refactoring to ego --- not all platforms have ego descr
files, and ego will just crash if you invoke it without one. I think originally
it was never intended that these platforms would be used at -O2 or above.

Plats now only specify the ego descr file if they have one.

filenamesof() an installable now returns all installed files, not just the ones
at the top level (necessary to make a lot of the dependency stuff work when
using tools which depend on installables).

Fix linking bug where em_decode would generate binary data instead of text.

Run through clang-format.

Run through clang-format.

Run through clang-format.

Run through clang-format.

Run through clang-format.

Push through clang-format.

Run through clang-format.

Push em_ego.c through clang-format before working on it.

Build the examples when doing a normal build; this exercises the compiler as a
whole and is one step further towards a proper test suite.

aal doesn't build the ranlib table if you don't set -DAAL.

Add files which got missed in the initial build pass.

liblinux is no more; its files are now in libsys.

rpi has a time() function; don't try to call gettimeofday().

Print hex numbers actually properly this time.

Raspberry Pi backend now builds.

Wildcards are allowed to match no files now.

Filename variables now get passed into ackbuilder on the command line.

Fix dependency error (only shows up with make, not ninja. Odd).

Fix compiler warnings and 64bitisms.

Er, oops; the ninja build system is in a package called ninja-build.

Backport to Lua 5.1 (because 5.2 on Travis doesn't have luaposix...).

Add another Travis library.

Update Travis metadata.

LED builds now.

Move the em_code headers into the em_code module.

Move util/data into modules/src/em_data, for consistency with the other
modules.

linux68k builds now.

installables need to depend on their source files...

Turns out I wasn't building the syscall libraries. Do so.

Wasn't exporting the plat headers; refactor to make this a little cleaner.

linux386 builds. Also, forgot to turn back on the language runtimes.

Biggish refactor to break cycles; my build rules were full of them. cpm builds,
which requires top and topgen.

Add cycle detection, because it was ruining my day. Allow targets to be stored
in a file called build-<target>.lua to allow better dividing up of build rules
(to break cycles).

Pascal runtime library now builds.

Pascal compiler builds.

Modula-2 runtime library now builds.

Fixed a small bug where two line number directives next to each other wouldn't
be parsed properly (the second one would be treated as Modula-2 syntax).

The Modula-2 compiler now builds.

The Basic runtime builds now.

The Basic compiler works now.

replace() gets confused if you give it a singleton list as its parameter.

Replaced the funky and hard-to-compile ACK malloc with a much smaller
and simpler one stolen from K&R. libc builds now.

Most of libc builds now (missing malloc).

Target lists can now have keyed items ({["foo"] = "+target"); this is
used by both installable and by clibrary{} to allow headers to be
installed into subdirectories.

We can build our first C file.

Add check for undefined variables. Find undefined variables. Fix undefined
variables.