Refactor the syntax-output codewalkers to use predicate dispatchers.

Make sure the open-block tag is computed correctly.

Use keyword syntactic environment to implement keywords.

Introduce syntactic-environment/reserve to handle common case.

This also means that syntactic-environment/define is only used for keyword
items.

Rename accessors for syntactic closures.

Make sure that scode object tags are correctly computed.

Add missing rename to host-adapter. Thanks Joe Marshall for another catch.

Greatly simplify SCode abstraction and change names to contain "scode".

Also remove all FOO-components and FOO-subexpressions procedures.
More work remains: the lambda abstraction is an unholy mess and needs to be
cleaned up.  The scan-defines stuff also merits some consideration.

Eliminate unused import from compiler C backend.

Rename file "ustring" to "string" and update package name too.

Large number of file renames.

Also deletes a few unused files.

Merge gensym into symbol and add mutex for its counter.

Don't use vertical brackets when unparsing uninterned symbol.

Move fixart and thread-low to earlier in the cold load.

Eliminate long-obsolete starbase support.

Add a few missing subdirs into Tags.sh computation.

Rewrite syntax-environment to use bundles.

Allow bare symbols as elements in bundle-interface specification.

Fix bug: bundle-interface predicates can't use dispatch-tag<= during cold load.

I don't think they need to do this anyway, since inheritance isn't part of this
design.

Push yet more predicate machinery into boot.

Rename value-binder to variable-binder.

Move bundle implementation to early in the cold load.

Add unparser for variable items.

Avoid shift of negative, which is undefined in C.

Eliminate unnecessary implementation note.

I may change the implementation in the near future.

Defer enabling runtime handling of errors until end of cold load.

Otherwise, once the error system is initialized, a subsequent cold-load error
causes an infinite loop.  At least this way there's some information about what
went wrong.

Fix typo reported by jmarshall.

Tweak bundle index lookup; fix bundle tests.

Refactor the bundle implementation.

* The interface is now the predicate rather than the tag.
* New procedures bundle-constructor and bundle-accessor.
* define-bundle-interface generates a BOA constructor and uses it.

Rewrite define-like and let-like syntax for simplicity.

Two small simplifications.

Eliminate null-binding-item.

Fix bug: Can't call output/sequence with an empty list.

Rewrite define-bundle-interface to do renaming manually.

Automatic renamer was clumsy and error-prone.

Fix bug: trace was depending on a string being mutable when it wasn't.

Be a little more honest about unsyntaxing macro definitions.

Refactor bundle interfaces to be dispatch tags.

Also add some unit tests.

Fix bug in macro expansion for define-bundle-interface.

Add extra tests to make sure that tagging dispatches right.

Merge predicate-metadata and predicate-lattice into predicate.

Add Tags.sh to tests directory.

Move set-{dispatch-tag,predicate}<=! into boot for use in cold load.

Eliminate remaining differences between record tags and types.

Also simplify internals of record a bit as a consequence.

Strip angle brackets off of dispatch-tag names when printing.

Change strip-angle-brackets to work on symbols too.

Replace record-type with the associated dispatch tag.

Add EXPRESSION clauses to boolean assertions in test-parametric-predicate.

Otherwise it's too hard to figure out what went wrong.

Fix typo in earlier refactor.

Rename "tag" to "dispatch-tag" and move bindings to global env.

This name is at least somewhat specific, so it should be OK in global.

Merge dispatch-tags and tags into a single implementation.

Fix bug: forgot to initialize record conditions.

Change tag representation so extra field is always a vector.

The original reason for using records in that field is no longer relevant now
that we have metatags to identify the tag type.

Refactor tag implementation to use "metatags".

This allows predicate dispatch to differentiate between different kinds of
tags.  Otherwise all tags look the same, even if they are functionally
different.

Of course now it's not possible to differentiate between metatags, because they
all of the same tag; but that shouldn't be a problem.

Fix bug: record-type-type-tag was missing a tag.

Move weak sets from predicate-metadata to boot.

Also flesh out slightly for future use.

Eliminate predicate-description.

Put guarantee and friends into "boot" for cold-load access.

Implement simple weak sets.

blowfish: Doco typo.

gdbm: Doco typos.

ffi: Missing alienate_float_environment causes foreigners to SIGFPE.

Refactor handling of explicit tag supersets.

Was hash table, now is weak list.

Implement weak-pair procedures as primitives and open-code them.

Also put the primitives in "boot" so they are available early.

Eliminate tagging strategies altogether.

The structure of the tagged data belongs outside of the core code.

Fix test: was depending on tagging strategy to differentiate datum tests.

Fix bug: two copies of unicode-char? were causing confusion.

Add "assertion number" to failure reports.

This is clumsy but better than nothing.

Eliminate tagged-object-{tag,datum} since they're identical to the % ones.

Do stupid macrology to work around lack of vector-ish open coding.

Fix open-coding of default-object?.

Not sure why this makes any difference, but it seems to.

Fix bug in compilation of %record with 0 or 1 arguments.

Implement tagged-object primitives and open-code them in compiler.

Also push record and tagged-object primitives into "boot" so they are available
early in the cold load.

Simplify the story of tagging strategy.

It's still not quite right, but it is at least somewhat closer.

Use macro to speed up implementations of record accessors.

Remove documentation for now-obsolete generic-procedure dispatch.

Simplify predicate-tagging so that it provides only the essentials.

This too is subject to change.  The tagging strategy idea needs to be revisited
in a larger context since it doesn't account complex structures like records.

Eliminate record-entity names and support.

Delete some unnecessary procedures.

Tweak dispatch-tag slightly.

Push definition of register-predicate! to beginning of cold load.

Eliminate use of record-specific printing registration.

Clean up the ad hoc handling of boot-time predicate registrations.

Use weak hash tables for predicate lattice.

Eliminate unused (and not fully thought out) unregister-predicate!.

Fix cold-load initialization so that predicate tag tables are built right.

Thanks Joe!  Fix thinko in code generation for define-structure.

Remove some unused and undocumented record-type accessors.

Included are record-type-extension, set-record-type-extension!,
set-record-type-default-inits!, and %set-record-type-default-inits!.

Move srfi-1 support to beginning of cold load.

Minor simplification.

Move dispatch-tag print method into gentag.scm.

Eliminate special support for defstruct printers.

In future just use define-unparser-method.

Search for root-level "build" directory when finding STAGE0.

Add optional argument to specify build directory.

Implement simple script to show all of the .crf files.

Move all of the generic-procedure support from runtime into sos.

It's slated to be entirely replaced by predicate dispatchers.

Ignore build directory called "build".

Make sure that a record's type name is an immutable string.

Implement string->immutable.

Clean up handling of entities with records as extra.

Implement record-entity? and record-entity-predicate.
Also clean up printing support for these.

Convert record support to use new predicate dispatchers.