An actual running implementation, which makes code that compiles.

I've not tested it very hard yet.  There are probably lots of small
bugs, and maybe some big ones.  There are certainly rough edges in the
error handling, particularly in the class-body parser which will get
cleaned up later.

More WIP.

Today's wip.

Refactoring more or less complete.  Maybe I should test it.

Daily work in progress.

Work in progress.  Mostly bug fixing.

Fix formatting badness.

Remove apparently dead files.

Don't write Lisp symbol names in uppercase: use `...' instead.

Otherwise it's too confusing to distinguish them from metavariables.

Change naming convention around.

Put `test', `proto', `impl', `parse', `output' on the end, not the
start.  This keeps pieces of the same chunk of functionality together in
listings.

Work in progress, recovered from old crybaby.

Massive reorganization in progress.

The code is a complete disaster area right now.

It lives!

The module parser is more-or-less done.  Output is more-or-less done.
Outstanding.  Now to remove the bugs...

Add .gitattributes file.

Another day, another commit.

Main highlight is that we now have output of class instances and direct
methods.  Yet to come are effective methods and entries, and vtables.

Today's work has been surprisingly focussed.  Incidental changes are
few; the most significant is probably trimming trailing whitespace from
the last line of a fragment, which eliminates some ugly blank lines in
the output.

Lots more has happened.

  * all reserved words are now banished
  * an ilayout now consists of, for each chain, a union of the ichains
    for each class on the chain -- makes referring to the bit which
    represents a superclass instance trivial; not yet hacked the
    effective method codegen to cope
  * unnecessary ichain and vt structures (ones which are copies of a
    superclass's) are suppressed -- we use the original directly
    (must document the new chain-tail tracking stuff); only one new
    ichain and vtable structure per class (though we still need all-new
    vtmsgs for each superclass).
  * header file output is complete and functional

More work.  Highlights:

  * start using new module import protocol
  * move bootstrapping to separate file
  * eliminated most of the non-C reserved words

Maybe I'll eliminate the C reserved words too.  It'll make the grammar
easier to extend.

Another day.

  * Wrote (but haven't compiled!) C runtime code.
  * Fettled runtime header.
  * Reformatted class definitions.  They don't deserve that much space.

Revamped module protocol to come.

Very ragged work-in-progress.

Most parts are in place.  Much rearrangement is needed.

Early work-in-progress.

Much needs to be done.