Export scode-expression?.

Eliminate now-deprecated references to hash-table procedures.

Update hash-table documentation in the reference manual.

Mark all of the hash-table renames as deprecated.

Rename hash-table-entry-type:key{/,&}datum-weak.

This makes it consistent with the ephemeron naming.

Fix missed reference.

Rewrite the object hashing facility.

* Names have been changed to avoid conflicts with hash tables, and for
  consistency.  The old names are still available as deprecated renames.

* New implementation is much easier to read.

Add type and constructors for datum-weak hash tables.

Fix typo.

Refactor hash-table to clean up some issues noted in previous change.

* Export former %make-hash-table as make-hash-table*.

* Create new make-hash-table-type* which can create a type given an equality
  predicate and some keyword options.  If the equality predicate has registered
  properties, no additional options may be necessary, except perhaps to choose
  the entry type (which is specified by name).

* Change make-hash-table to accept the same options as make-hash-table-type* and
  to use the same defaulting.

* Change internal procedure follow-memo-crap to hash-metadata, which more
  accurately reflects its purpose: to get a properties table for the primary
  hash parameters.

Rename set-equality-predicate-hasher! -> set-equality-predicate-properties!.

Now has two required arguments: hash-function and rehash-after-gc?.
A rest argument is a keyword list for additional properties.

Change keyword-option-parser to expect defaults as a thunk.

Move int:modulo to primitive-arithmetic and export it.

Standardize hash tables on SRFI-69 names and deprecate others.

Change make-hash-table to be smarter about choosing the appropriate hash
function for a given equality predicate.

Also work around name collisions in rtlopt/rcse*.scm, and tweak the hash-table
implementation to favor SRFI-69.

Some work remains: the code around building hash-table types needs to be
re-thought: it's a little clunky and could usefully take advantage of keyword
arguments.  (These keyword arguments should also be supported by
make-hash-table.)  The hash function should be optional and use the
equality-predicate default.  The older %make-hash-table should be renamed and
exported as it's the right interface when using types.

Make sure that run-three-stages looks at "build" before "svm".

Eliminate remaining uses of find-matching-item.

Eliminate remaining uses of list-search-positive.

Downcase remaining symbols in the runtime system.

Only remaining such symbols are those that have explicit case.

Change SVM compiler to use new pop-return instruction.

Implement new SVM instruction: (pop-return).

Override definition of filter so that compilation using 9.2 works.

Implement scode-procedure-arity so that it can be run during cold load.

The lack of this prevented the cold load from running correctly when using
interpreted code, since it depended on a complex scode lambda implementation
that was loaded much later.

Change guarantee to show context of error.

Eliminate references to now-deprecated definitions.

Put back inadvertently-deleted bindings.

Mark deprecated list procedures and also more SRFI-1 procedures.

Change find-{,not-}matching-items procedures to call find instead.

Also eliminate find-unique-{,not-}matching-items procedures which aren't used
and aren't documented.  These are trivially solved with find-tail and any.

Tweak indentation.

Eliminate references to various list filters in favor of SRFI-1.

One unfortunate development is that somewhere in the compiler is some code that
depends on the result of a filtering option being newly allocated, while FILTER
shares the tail of the input list when it can.  I modified FILTER to stop doing
that, because it wasn't obvious which of the modified calls in the compiler was
causing the problem.

Optimize code generated for let*, let*-syntax, and letrec.

Thanks to Patric Jonsson for noticing this.

Another round of downcasing.

Downcase a lot more symbols and constants.

Add program to find symbols that depend on case folding.

Downcase a lot more symbols and constants.

Export char-changes-when-X predicates and char sets.

Downcase more symbols and constants.

Downcase more symbols and constants.

Downcase more symbols and constants.

Downcase more symbols and constants.

Downcase all symbols and constants.

Change *parser-canonicalize-symbols?* to affect symbols only.

Downcase symbols and constants in optiondb.

Downcase symbols and constants in optiondb.

Fix bug: mime decoder wasn't properly flushing its output.

Fix typo in previous change.

Eliminate define-expr-item-compiler in favor of define-item-compiler.

Not sure what I was thinking when I wrote that code; it was simply wrong.

Move definition of access entirely into mit-syntax.

Eliminate redundant code in cons-stream*.

Reorder definitions in mit-macros into topical groups.

Change spar-transformer->runtime to provide default environment.

Rename :FOO syntax names so that they aren't potential keywords.

Tweak quasiquote implementation to use shorter names.

Also refactor descend-pair slightly for brevity.

Change and to be defined by syntax-rules.

Also belatedly define the feature full-unicode.

Rewrite local-declare using syntax-rules.

Convert define-integrable, fluid-let, and paramaterize to scons-rule.

Change unsyntaxer:* variables to be parameters and export them.

Fix broken unsyntaxing of scode sequences.

Also fix over-long lines.

Make second arg to scons-set! optional.

Refactor how keywords are matched.

* spar-arg:compare renamed to spar-arg:id=? and second argument is optional,
  defaulting to spar-arg:form.

* patterns (noise ...), (noise-keyword ...), and (keyword ...) are eliminated.

* New pattern (ignore-if predicate arg...) ignores a subform if calling the
  predicate is satisfied.

* Renamed (value-if ...) to (keep-if ...) with same semantics: keeps a subform
  if calling the predicate is satisfied.

* New pattern (value arg) is like (values arg...) but a little clearer.

Change spar pattern (elt ...) to (subform ...).

Rename spar*elt* to spar*subform*.

Change pattern->spar to make * and + operators implicitly listify.

Eliminate special bindings for constants in pattern->spar.

Also change leading : to $ to avoid making names look like keywords.

Rewrite patterns as (elt (list ...)) rather than (list (elt ...)).

Convert and-let* to scons-rule.

Add some simple optimizations.

Convert a bunch more macros to scons-rule.

Use folding to eliminate loops in macros.

Rewrite COND and DO to use spar rules.

Change scons-call to not quote its operator.

Instead one must explicitly call scons-close when necessary.

Add context to items, for errors that happen during item compilation.

Formalize the context of a syntax error.

Implement spar-not.

Rewrite COND-EXPAND to use spar rule.

Change spars to set up error context when calling out to procedures.

Tweak CASE to use new keyword pattern.

Rename spar-seq to spar-and.

Tweak spar patterns.

* Rename (quote <x>) to (noise <x>).
* Rename (keyword <id>) to (noise-keyword <id>).
* Implement (keyword <id>) that matches <id> and then pushes it.

Clarify that spar-push-if pushes the form, and spar-push-elt the elt.

Rewrite CASE as a spar-transformer.

Implement spar-if and associated pattern.

Simplify spars pattern language.

Also change some of the terms to be clearer: I'm anticipating how the
documentation will read.

Eliminate parse-define-form.

Rewrite core of pattern compiler to use rules.

Implement spar-arg:compare and (keyword id) pattern.

More macros converted to new model, plus a lot of fixes and tweaks.

Implement syntax-constructor ("scons") mechanism.

This eliminates a potential problem with RSC and ER macros, which typically
construct ordinary list structure using quasiquote and renaming the keywords.
Unfortunately this will fail if the use environment has redefined the quasiquote
and/or quote keywords.  These constructors are careful not to use any keywords
except renamed ones; they also hide most of the renaming while providing a
simple procedural interface.

Handle case where debugging-info has an old-style pathname.

Don't write pathnames into debugging info.

Implement spar-top-level to cut down on boilerplate.

Tweak.

Change record predicate to check for child types.  Reported by Arthur.

Make record inheritance comply with SRFI 131.

Implement pattern language to make spars more terse.

Add forgotten export.

Change spar-match-null to a procedure.

Simplify spar interface a bit more.

Implement record inheritance at Arthur's request.

Eliminate default-inits arg from make-record-type.

This will allow all optional args to be removed after 9.3.

Streamline definition of record-type proxies.