Use runtime's string ports.

Also read file in one swell foop, rather than character by character
in a slow painful chain of indirections thousands of times slower.

We'll use legacy strings here because this code was all written under
the assumption that `string' meant byte vector, and legacy strings
still have that semantics.

Eventually this should all be adapted to use bytevectors instead for
storage, and interpret things as strings only as necessary for text
processing beyond mail data formats.

Implement position for string input ports.

Export binary-port-length too.

Fix binary-port-position for output ports.

Not sure if it'll DTRT for combined i/o ports; need more tests!

Export binary-port-position and set-binary-port-position!.

Currently busted for output ports.

Integrate string operations for order of magnitude speedup.

ucd-slc-value &c. return chars, not fixnums.

Use 32-bit xor rather than 64-bit xor for zeroing.

Split deeply nested expressions into named and typed temporaries.

No functional change intended, just makes stepping through with a
debugger easier.

Confirm that a couple screw cases in closure analysis work.

Once upon a time the Y combinator and U combinator would crash the
compiler.  It's been fixed now but let's at least immortalize the
code I had lying around that crashed it so it doesn't happen again.

Add some more release notes.

Fix whitespace change ignored by magit.

Move .dir-locals.el from src/ to top level dir.

Split test data out of "test-string-normalization".

Set indent-tabs-mode to t in this directory.

This has been true historically.  I'd like to eventually eliminate the use of
tabs in our code base.

Generate char sets for each UCD general category and numeric type.

And use these to avoid expensive computations in ucd-glue.

Fix bug in inverting empty character set.

Fix bug in string-copy!.

Add tests for string-copy!, which has a bug.

Add support for 'expect-failure? property on assertions.

This allows an individual assertion to be marked as broken.  When the problem is
fixed, the property can be removed.

Eliminate use of TC_LEGACY_STRING for symbol names.

Change all string operations that accept chars to work for any char.

They dump the bucky bits as needed to make this work.

Implement char->bitless-char.

x11/Makefile.am: Fix packaging, TAGS.

(Re)define c_sources so they appear in TAGS.  Include compile.scm in
EXTRA_DIST.  Punt empty un/install hooks and unnecessary overrides.

runtime/rfc2822-headers: Watch out for eof-object.

And leave parse-error calls in tail position, so as not to frustrate a
debugger expecting to return the correct answer.

ffi/build: Mixing strings and pathnames is problematic.

In this case rewrite-compressed-file expected a string.  It probably
should expect a pathname, but it is just going to get weird with it.

Update test-syntax-rename to work with syntax changes.

Add param:trace-syntax? to help debugging syntax expansion.

Add print method to quoted-identifier.

Fix: allow compiler to be compiled with current release.

Tweak all the syntax tests now that they are fixed.

Add assertion that does pattern matching; useful for syntax testing.

Eliminate now-unnecessary exports.

Rewrite environment implementation to clear up ambiguities.

See the extensive note at the beginning for details.

Implement spar-funcall to call a procedure and ignore its value.

Eliminate unnecessary use of strip-syntactic-closures.

Fix some minor bugs in syntax renaming.

In er-macro-transformer, guarantee that two renames of a symbol are eq?.

Syntax renaming now handles declarations correctly.

Eliminate inaccurate comment.

syntax-rules: eliminate use of rename for creating new identifiers.

This confusion is one of several that has resulted from long-term muddy thinking
on my part, and is a contributor to the bug that was filed.

Also, clean up the code a bit in preparation for further changes required by
R7RS.

Use the parser state, not the value produced, to determine success.

More polar screw cases.

Pass the _type_ of complex component through the parser.

Restores polar notation.

Oops, this broke polar notation.

Reject multiple zero real components by parse states.

Rejecting on a zero real part of parsing an imaginary suffix was cute
but leads to wacky quirks in accepted notation.

Add some more screw cases.

Reject inf and NaN with #e notation.

There is no exact infinity or exact NaN.

Provide notation for NaN payload and signalling NaN.

Reader has various edge cases we fail to make errors still.

string->number returns false on error.

Make this unreachable case an error.

Fix printing NaN sign.

More tests for signed NaN notation.

Only the positive quiet NaN with payload 0 is read/write invariant so
far.

Fix sign of NaN in reader.

Expand test-numpar.scm a little with some bugs.

Make flo:nan.0 reliably return a `positive' quiet NaN with payload 0.

Fix bug in flo:make-nan error reporting.

error_bad_range_arg takes argument number, not argument value.

flo:make-nan error reporting is busted.

Confirm #i works with inf and nan.

There is no exact infinity or NaN, so #e should reject them.

But we produce them anyway.

x86 push can take a memory reference operand.

Conveniently, it evaluates rsp before modifying it too.

Shaves about 1% off the runtime.

Print newline in debugging-printer primitive.

Disable allocator open coders.

These don't actually do anything useful.  What they do is open-code a
type check -- and then branch to the same primitive call whether the
type check passed or failed.  So they serve only to expand the code.
This appears to have been an aborted experiment in the HP PA-RISC back
end from 1993.

Add missing type checks to some bit string operations.

Bit string primitives are missing type checks.

Teach pp to respect custom print methods for tagged vectors.

pp doesn't respect custom print methods for tagged vectors.

Rework vector tag printer methods so they work again.

XXX Needs tests, but these are a pain to construct...

pp _is_ busted after all but it takes a hairier example.

pp is not busted; I just didn't know about pp-avoid-circularity.

TIL.

Make pp's job easier in this test.  (Still busted.)

Fix find-shared-objects.  pp is still busted.

find-shared-objects is busted for multiple references.

pp is busted on circular data structures.

Allow the full form of FLUID-LET with ACCESS.

FLUID-LET of ACCESS broke.

(Yes, I know it's legacy, but I need it for another test at the
moment.)

Tickled a bug in connectivity analysis with arity error.

Compiler chokes on a variable named |#[continuation]|.

Open-code some flonum predicates on amd64.

- flonum-is-equal?
- flonum-is-finite?
- flonum-is-infinite?
- flonum-is-nan?
- flonum-is-normal?
- flonum-is-zero?

Teach sf about flo:safe-zero? and flo:safe=.

Speed this up a little at the expense of coverage.

Add some more spot checks.  Zero is not exact here, for sign.

Test some more edge cases and exception flags.

Teach Scheme about the floating-point subnormal-operand exception.

Make flo:clear-exceptions! register interest in fp env.

Not sure why I made it conditional before.  Makes sense for
flo:raise-exceptions! for functions whose callers might or might not
want them, but usually you do flo:clear-exceptions! only if you are
actually going to use them afterward.

Earlier change to flo:clear-exceptions! is busted.

In particular, the pattern

(flo:preserving-environment
 (lambda ()
   (flo:clear-exceptions! (flo:supported-exceptions))
   ...))

ought to give you an environment where the exceptions are cleared,
but it doesn't.

Teach the compiler about more boolean and function primitives.

Recursively integrate after substitution.

The declarations in this context may have changed.  This way, you can
get a lot of straight-line floating-point arithmetic like so:

(define (flo:sinh-taylor19 x)
  (declare (no-type-checks))
  (let* ((x^2 (flo:* x x))
         (t8 (flo:/ 1. 121645100408832000.))
         (t7 (flo:+ (flo:/ 1. 355687428096000.) (flo:* x^2 t8)))
         (t6 (flo:+ (flo:/ 1. 1307674368000.) (flo:* x^2 t7)))
         (t5 (flo:+ (flo:/ 1. 6227020800.) (flo:* x^2 t6)))
         (t4 (flo:+ (flo:/ 1. 39916800.) (flo:* x^2 t5)))
         (t3 (flo:+ (flo:/ 1. 362880.) (flo:* x^2 t4)))
         (t2 (flo:+ (flo:/ 1. 5040.) (flo:* x^2 t3)))
         (t1 (flo:+ (flo:/ 1. 120.) (flo:* x^2 t2)))
         (t0 (flo:+ (flo:/ 1. 6.) (flo:* x^2 t1))))
    (declare (integrate t0 t1 t2 t3 t4 t5 t6 t7 t8 x^2))
    (flo:* x (flo:+ 1. (flo:* x^2 t0)))))

Previously, the number of variables in this sequence that would be
integrated depended on the number of surrounding integrated calls in
the body of the let (!).

Restore parallel compilation of compiler.

Fix thinko.

Use real:abs, real:copysign.

These aren't guaranteed to be flonums here.

Mixed-exactness complex numbers are pretty silly.

Sqrt is busted on sone mixed-infinite/exact cases.

Make ieee754-binary-hex-string follow IEEE 754-2008.

New procedure (flo:logb x) gives the integer exponent of x.

Implement and fix fenceposts in inf and NaN encoding.

Use ieee754-binary-parameters to reduce magic constants.

Fix broken hexadecimal floating-point printing.

What was I thinking.  This is all wrong if the top bit is not 1.

Note copysign procedure.

Remove bogus note about flo:compare and flo:safe-compare.

Never actually committed these; decided a four-way comparison wasn't
worth it without a motivating application.  Won't work for anything
that expects a three-way -1/0/+1 compare.