Add title of SRFI.

Eliminate use of char-set-members.

Eliminate use of ascii-range->char-set.

Change REPL to recognize and print multiple values.

Extensive revision of Lists chapter in reference manual.

Eliminate use of list-head and list-tail.

Also make reverse* an alias for append-reverse.

Eliminate use of with-values.

Eliminate use of map*, append-map*, append-map*!.

Convert test-srfi-1 into a real test.

Rewrite foldX and reduceX for simplicity.

Deprecate the non-standard X-left procedures, as well as the X* mappings that
can be expressed using fold-right.

Eliminate use of fold-left.

Force indent-tabs-mode only for Scheme files.

SRFI 115 complete.

Pull Unicode segmentation support out of string and rewrite.

This is a nearly complete reimplementation, with a simpler and faster DFA,
providing a fold-like interface.

The describing rules are nearly identical to those in UAX #29, which makes them
much easier to write and understand.  Also, there's a debugging feature that
shows how the DFA evolves for a given string.

Implement more general zero-width assertions in the regexp NFA.

Round out the named char-set abstraction.

More SRFI 115 work.

Fixed issues with implementation of regexp-match-submatch*.
Implemented procedures for folding and transforming.

Implement regexp-search-all and fix two typos.

Use char-set:printing, not graphic, so we can type SPC in Edwin again.

Implement regexp replacement.

Add missing call to run-deferred-boot-actions.

Implement (w/FOO ...) patterns for SRFI 115.

Add support for case-folding of character sets.

Char-set refactor: SRFI 14 complete.

Char-set refactor: add another round of SRFI 14 support.

Also rename old char-set->string to char-set->ascii-string since it conflicted
with SRFI 14.

Char-set refactor: fill out some missing SRFI 14 procedures.

Char-set refactor: a bunch of small internal changes.

Expand the ilist and ranges abstractions in preparation for char-set refactor.

Reorganization in preparation for char-set refactor.

A bunch of renames in preparation for char-set refactor.

Move string-fold{,-right} into runtime.

Refactor regexp-rules to allow prefix arguments.

Rename SRE? -> VALID-SRE?.

Fix some issues with tags generation.

Fix typo in previous commit.

Fix wrong number of arguments.

Collapse NFA matcher node types together.

Optimize follow-epsilons to reuse the same hash table.

There's no reason to cons a new one on each call since we can just clear it
between calls.

Rewrite the NFA regexp interpreter into epsilon/matcher phases.

This greatly simplifies the interpreter's operation, and isolates the state
elision in the epsilon phase where it belongs.

Also added hash-consing of states, so that we can use eq? to compare them.

Change NFS nodes to have a clearer set of types.

This also allows more detailed analysis of the graph: we can now write a program
that will determine the initial character(s) of a regexp and use that to speed
up search.

Markup and tweaks for partial SRFI 14 support.

Implement NFA regexp engine and change srfi-115 to use it.

Implement char-set-size and update char-set:newline.

Partial implementation of SRFI 115.

Add character sets needed for SRFI 115.

Refactor regsexp for simplicity and future sharing.

* The rule engine has been moved to its own file, rewritten, and generalized.

* The recursive implementation has been moved to its own file and slightly
  edited.

* There's new support for match replacement.

Add define-deferred-procedure to capture a common pattern.

Implement complement, a predicate inverter.

Fix typo from earlier commit.

Implementation of the immutable strings of SRFI 140.

This does not include the mutable strings from SRFI 118.

Tighten up testing of duplicate imports to ensure R7RS compatibility.

Change list->string to take optional start and end args.

This extension matches SRFI 140.

Allow string-builder to take a zero argument.

This simplifies cases where the length of the result is known in advance and
passed as the buffer size.

On error, show a condition report instead of a condition object.

Update reference manual with changes to string-{splitter,trimmer}.

Modify string-splitter and string-trimmer to accept copier arg.

Change string-builder to use a vector as its buffer.

Hopefully this will be generally faster since it's slower to copy characters
into a mutable string than it is into a vector.

Implement UTF-{16,32} converters that use BOM.

This is needed for support of SRFI 140.

Fix bug in parsing of cond-expand.

Fix warning about re-exporting imported names from libraries.

Fix typo.

Use euclidean/ from division package as pointed out by Taylor.

Also fix typo.

Register srfi-133 and srfi-143 for cond-expand.

Finish implementing SRFI 143.

Add usual-integrations for SRFI-143 bindings.

Add some SRFI-143 renames to primitive arithmetic.

Integrate inline tests into testing framework.

Implement as-needed loading of libraries on import.

This does topological sorting to do the loads in the right order, but doesn't
handle dependency loops (yet).

Add implementation of simple directed graph algorithms.

Add ability to import a library into an existing environment.

Automatically pre-register libraries in standard places.

Add param:hide-notifications?.

Create a new directory src/libraries, to hold R7RS libraries.

Initially populate this with (srfi 133) and (mit inline-testing), plus unit
tests for the former.

Preserve the initial host-library-db.

Create a "standard" library providing access to the library database.

This is useful for programs that want to work directly on libraries.

Fix problems with reporting why an auto property isn't available.

The previous approach was not filtering the dependencies right.

Eliminate duplicate binding.

Don't rewrite library imports after parsing them.

It's more convenient to have the retain their syntax, so that they can be used
by programs using reflective access to the libraries.

Be more careful when checking for unquote in repl eval.

Furthur improve error reporting for libraries.

Just have one legacy library: (mit legacy runtime)

Otherwise it's a pain to figure out where all the exports are, since they aren't
necessarily where you might think.

Also, this eliminates deprecated bindings.

Improve error reporting for library imports.

Fix problem with syntaxing of DO.

This wouldn't work correctly in some weird edge cases.  Specifically, it was
trying to detect the 'else and '=> keywords, but comparing them in the syntactic
environment outside of the DO, not the one inside of it.  Fixed by rewriting the
macro to defer the cond-clause processing until the interior environment was
available.

Fix typo in earlier change.

Add printer for bytevectors and limit printing of vectors.

Change debug printer to print vectors correctly.

Fix cold-load problems when cross-compiling from 10.1.10.

A reader has alerted me to a caveat about IEEE 754 min/max.

Fix bugs in min/max on signalling NaN inputs.

Fix floating-point min/max tests, and mark them xfail.

I misread IEEE 754 semantics on min/max for _signalling_ NaN.

If given a number and a _quiet_ NaN, min/max are to return the
_number_.  But if given a _signalling_ NaN, min/max are to return a
quiet version of the NaN.

References:

Sec. 5.3 `Homogeneous general-computational operations',
subsec. 5.3.1 `General operations',
on minNum/maxNum/minNumMag/maxNumMag reads:

  `minNum(x, y) is...the canonicalized number if one operand is a
   number and the other is a quiet NaN.'

  `When either x or y is a signaling NaN, then the result is according
   to 6.2.'

Sec. 6.2 `Operations with NaNs' reads:

  `Under default exception handling, any operation signaling an invalid
   operation exception and for which a floating-point result is to be
   delivered shall deliver a quiet NaN.'

     [Consequently, _if_ min/max raise invalid-operation and
      nevertheless return a result, they shall return a quiet NaN.]

  `Signaling NaNs shall be reserved operands that, under default
   exception handling, signal the invalid operation exception (see 7.2)
   for every general-computational and signaling-computational
   operation except for the conversions described in 5.12.'

     [min/max (i.e., minNum/maxNum/minNumMag/maxNumMag) are listed
      under homogeneous general-computational, so this clause applies.]

Subsec. 6.2.3 `NaN propagation' further reads:

  `An operation that propagates a NaN operand to its result and has a
   single NaN as an input should produce a NaN with the payload of the
   input NaN.'

  `If two or more inputs are NaN, then the payload of the resulting NaN
   should be identical to the payload of one of the input NaNs if
   representable in the destination format.'

Change record types to be immutable.

The primary reason for this is to make the predicates slightly faster,
eliminating the need to look up the type markers in the predicates.

Additionally, make-record-type now accepts these additional options using a
keyword list.  The define-record-type macro has not been updated to support
these new options, but that will come soon.  Consequently the files using these
options have been modified to use make-record-type directly.

Finally, a small tweak was needed so that multiple values are available earlier
in the cold load.

Fix aliasing problem with sub-record predicates.

Add test to check that it works.

Restore compatibility with SRFI 131.

Also add some tests for records, and fix several bugs revealed by them.

Refactor record layout following a suggestion from Taylor.

New layout is identical for records that don't have a parent type.  For those
that do have a parent type, the layout is like this:

    root-marker
    root-fields
    sub1-marker
    sub1-fields
    sub2-marker
    sub2-fields
    ...

The primary advantage of this layout is to make the record predicate be constant
time, as opposed to the previous design in which it could be linear in the depth
of the parent chain.

In addition, a number of record operations have been bummed for slightly better
performance, and the layout of record types has been altered to keep track of
the type information in a way that's better organized for generating the record
operations.

There are some behavioral changes:

* This implementation is slightly incompatible with SRFI 131, since it prohibits
  a child from having a field name that's the same as one of its ancestors.
  I'll probably change this for compatibility.

* Only a root record type can have an applicability method, and that method is
  called for all sub-types of that root type.  Arguably this is reasonable
  behavior.

* Non-root fasdumpable records must have proxy markers for all of their
  component types.  Previously, only the record type stored in slot 0 needed to
  have a fasdumpable proxy.  This isn't an immediate issue since fasdumpable
  records are used very sparingly at the moment and probably won't be supported
  outside of the runtime system.

Tweak my special hack.

Implement any-duplicates?.

Fix syntax bug that showed up in syntax-rules.

Merge branch 'riastradh-20190917-fixamd64uuojmp'

Fix tospace/newspace confusion.

This did not manifest in my testing on NetBSD because it happened
that on NetBSD, the tospace and newspace are always separated by more
than 4 GB, so the bogus jmprel32_offset was never used during GC,
e.g.:

   newspace=0x17dd7f8 tospace=0x7f7feeb00000 delta=17523427132673

I suspect it is the cause of Chris's problems on macOS, so this
should fix Chris's issue on macOS and speed things up even more for
everyone.

Revert "Workaround for inexplicable fatal error on macOS."

This reverts commit 689da8bf97534063f1800caf544a694de81d511e.

Will fix in a subsequent commit.