Convert string to NFC prior to hashing.

Change symbol->string and symbol-name to return immutable strings.

Update to reflect minor changes to string operations.

Much more work is needed to recraft this chapter to cover immutability.

Export mutable/immutable predicates.

In substring, only return arg string if it's in NFC.

Change substring? to call string->nfc on its arguments.

Change string-match and string-search to require NFC inputs.

This is because comparison requires that the strings be in the same
normalization form, and these procedures return indices into the strings.  We
can't normalize them after the call, because then the returned indices will
refer to strings that are potentially different from the arguments.

Since nearly all strings are in NFC by default this should not be a serious
drawback.

Additionally, the -ci versions of these procedures have been eliminated,
basically for the same reason.  If the caller needs that functionality they
should call string-foldcase themselves.

Note that this doesn't affect comparisons that don't return indices.

Change default result of string-builder to be NFC.

* Eliminate string-canonical-foldcase since string-foldcase now returns NFC.
* Don't return NFC strings from list->string and vector->string, instead return
  verbatim strings.

Merge branch 'master' of git.sv.gnu.org:/srv/git/mit-scheme

Redefine substring as different from string-copy.

They are different in only one respect: string-copy always returns a mutable
string, while substring always returns an immutable string.

Convert list->string, vector->string to use string-builder.

Fix call to string-builder that was missed.

Simplify string, string*, string-append, string-append*.

Fix typo causing memory corruption.

Fix typo.

XXX Obviously this needs an automatic test!

From mejja.

Change string-copy to return legacy string only if arg is also legacy.

Move NFC marking from canonical-composition to string->nfc.

Significantly simplify string-builder.

* Eliminate options; now just optional buffer-length.
* Result type is specified at build rather than up front.
* Eliminate never-exported make-string-builder.

Change string->nfc to return immutable value, and optimize a bit.

Support TEST environment variable in "make check".

Also clean up output slightly.

string->nfd: also convert mutable strings already in NFD.

Change string->nfd to return immutable value.

Change builder options to distinguish between mutable and legacy results.

Rearrange and optimize.  Also make ustring1 be zero-terminated.

Mark ignored binding.

Change Edwin's implementation of strings to work for all "string-ish" types.

Add tagging support for unicode-string.

Also generate better error for unknown type codes.

Change string primitives to uniformly support all "string-ish" types.

Change string-builder to generate immutable strings by default.

Also fix bug in string->list assumed mutable inputs.

Now that legacy string has the same layout as ustring1, merge handling of both.

Allow string operations to take Unicode strings with 1 byte per CP.

Change string comparisons to normalize to NFC prior to comparing.

The procedures that return index values have not been updated since it's not
obvious what to do with them.  Comparison is meaningless for non-normalized
strings, so it's necessary that all comparisons be done between normalized
strings.  This means either (a) require compared strings to be normalized before
calling the comparator, or (b) have the comparator do normalization on the
arguments.  If (b) is chosen, then the returned index value will be wrong in the
case where the arguments aren't normalized, as it will refer to the normalized
strings, not the arguments.

I'm considering choosing (b) and changing the definitions of these procedures to
return a slice into the normalized strings instead of an index.  However, the
upcoming implementation of immutable strings may make it simple for every
immutable string to be normalized, which may make (a) feasible.

For now I'm going to ignore this, which is fine as long as only ASCII strings
are compared.

Rewrite string-builder for performance.

Rewrite string copying for performance.

More refactoring of unicode-string layout.

Teach top-level clean target to clean tools too.

A round of small changes in preparation for supporting immutable strings.

Implement compiler support for new primitives.

Change Unicode strings to store flag in type bits of length.

D'oh! Hook up printer to new string type.

Implement primitives to read and write type/datum of object in memory.

Return end-index of TO from bytevector-copy!.

No need for X in the liarc bootstrap build.

Splice shell arguments with ${1+"$@"}.

Leave as "${@}" only where it is absolutely obvious there must be at
least one parameter anyway, e.g. because it is a full command line.

Fix bug: primitive-byte-ref returns a fixnum, not a raw number.

Also clean up and reorganize open-coding of memory references.

Fix typo.

Change unicode string representation to be more compact and flexible.

The new design is more densely coded and provides for immutable strings with
different coding, as well as memoization of NFC/NFD status.  However, in this
change only the standard 3-byte mutable representation is implemented.

Implement select-on-bytes-per-word for gnerating word-length-specific code.

Eliminate condition for open-coding integer->char.

Make sure that unicode strings are self-evaluating.

Strip down code generated for primitive memory references.

Implement open-coding of byte-ref primitives.

Implement more primitive refs, and restrict to pointers only.

Fix compilation issue.

Implement allocate-nm-vector.

Allocate new type unicode-string.

Implement bytes-per-object.

Eliminate unused multi-byte procedures.

No need to support a bunch of code that may never be used.

Add 'copy? option to string-builder.

Merge branch 'master' of git.sv.gnu.org:/srv/git/mit-scheme

Fix bug: string output port must copy input strings.

Fix bugs: typos caught by the macos compiler.

Add documentation for a few of the more recent string procedures.

Fix string-for-primitive: it wasn't handling slices.

Optimize string-in-nfX? since it's important that these be fast.

Normalize strings prior to hashing so equivalent sequences hash the same.

I've arbitrarily chosen NFD because its faster than NFC, but a case could be
made that NFC is preferable.

Eliminate Hangul Jamo from canonical cm/dm tables.

This makes the bands about 1 MB smaller.

Implement algorithmic Hangul Jamo compose/decompose.

Fix code-generation bug in fast-division.

Apparently this code was insufficiently tested.

Change NFC_QC to be a boolean-valued table and exploit that.

Have string builder track max code point written.

This is used for two distinct purposes in the finisher.

Change string-builder to normalize to NFC by default.

Change symbols to be in NFC.

Working NFC implementation.

Initial draft of NFC support; still need to write composition.

Add NFC_QC and Comp_EX tables.

Synthesize canonical-dm table and use it to speed up decomposition.

Fix bug in canonical-ordering algorithm.

Refactor test to make it easier to see the failures.

Boost default stack size -- I'm tired of blowing out the stack.

D'oh!  String normalization tests were broken, which explains why they pass.

Squeeze a little more space out of the tables.

Implement decomposition-type table and use it for correct NFD conversion.

Further compress the size of the UCD tables.

As of this latest set of changes the total size seems in the range of a megabyte
or so, which is much better than the 4-5 megabytes of earlier revisions.

Add a bunch of converters to/from bytevectors.

Fix some bugs in vector->string.

Add hack to force printing chars in old format; can be eliminated after 9.3.

More simplification.

Simplify parse-atom to not fold case.

Use ucd-X-value directly in ustring.

Convert all of the UCD tables to use bitwise tries.

Rework the character parser to handle backslash reasonably.

Add u16/u32 equivalents to bytevector.

Add draft of inversion-map code generator.

Update explanation of HIGH range.

Rename "signal" to "inversion list" since that's the accepted name.

Change normalization test to use characters instead of integers.

Speed up reading of #\x... characters.

Use string-builder instead of call-with-output-string.

Implement test case for string->nfd.