Block interrupts, _then_ lock.

Otherwise an interrupt might try to acquire the lock while we already
hold it, leading to deadlock.

Rework profiler to be more useful.

Just make a histogram of stacks and print that.

Fix check for arity of hash: must be binary, not unary.

Process pending thread events when unblocking them.

Partly fixes bug where profiler never got a chance to run when the
program was doing most of its work in short routines that block and
unblock thread events, like opening and closing files.

Only partly, because it seems something else unblocks thread events
without processing them -- until we do another block/unblock cycle as
in channel-close.  Verified that very little time is actually spent
in channel-close; haven't yet tracked down who the culprit is.

Integrate some subroutines that turn up hot in profiles.

Merge branch 'riastradh-20190527-unicodereplacechar'

Implement character replacement on ill-formed octet sequences.

- (utf8->string bv start end #t) now replaces by U+FFFD.

  Existing behaviour of (utf8->string bv [start end]) is unchanged so
  that utf8->string will fail noisily rather than quietly fail to be
  invertible by string->utf8 on certain inputs.

- Generic I/O input now replaces ill-formed octet sequences by U+FFFD.

  TODO: Add (port/set-coding-error port <action>) for <action> =
  replace or <action> = error, perhaps.

TODO: This does not exactly implement the replacement algorithm
recommended as a best practice by Unicode 9, §3.9, pp. 127-129.  That
algorithm is inconveneint because our decoder is factored into (a)
claiming a length based on the first code unit, and then (b)
consuming exactly that many bytes; the algorithm requires us to
refactor it so that part (b) can say `never mind' and consume fewer
bytes than (a) requeste.

Set port coding to ISO-8859-1 for IMAP.

This is a sleazy workaround: sometimes the input is really encoded as
UTF-8, but passing it through Scheme `strings' as ISO-8859-1 works
out to approximately the not-wrong thing.  Really we should be
operating on octets, not on characters-as-if-they-were-octets.

Fix enumerate-graphics-types per documentation.

Treat strings returned from primitives as UTF-8 coded.

In particular, make sure that filenames are treated this way, because this is
normal for modern unix systems.  This change mostly affects filenames, but also
environment variables and command-line strings.

This is necessary because strings passed to primitives are converted to UTF-8
bytevectors.  Otherwise, a non-ASCII filename returned by a primitive won't be
converted back to the same bytes when passed to another primitive.

On macOS, support building without Xcode installed.

However, command line tools must be installed.

x11-test: Expect the correct device name.  Use x-graphics-draw-arc.

x-graphics-draw-arc: Add missing parameters.

Make this run on ucode without nonnegative-fixnum-length/mask.

Specify arity in newer primitives.

Fix spelling error.

This came from the text of SRFI 9, which I've also corrected.

Eliminate unused handler for printing URIs.

Add test to make sure that string slices print correctly.

Fix bug in printing of string slices.

Remove cleverness for SIGTERM and SIGHUP.

SIGTERM shouldn't be caught; instead just leave the default behavior.  SIGHUP is
sent by Emacs when the *scheme* buffer is killed; it must kill the process or
we're left with a detached process.

Fix recursion in n-ary append.

Test append on dotted lists.  I broked it.

Add release note about cross-compilation.

Add release notes about big-endian and powerpc.

Use arity-dispatched procedures for APPEND and APPEND!.

APPEND turns up hot in the compiler, because LAP = quasiquote.  Let's
skip some round-trips through the microcode, shall we?

Simplify and factor out carefully checking for stack overflows.

Confirm delv does not blow out the stack.

Add some tests of blowing out the stack with SRFI 1.

Tidy up deletion routines in list.scm.

- Share code.
- Use constant stack space.

Merge branch 'riastradh-20190210-letrecdefn'

- Improve performance of LETREC* and unary LETREC.
- Convert various multi-way LETRECs to internal definitions.

The compiler knows about internal definitions.  Teaching to recognize
patterns of LET and SET! produced for LETREC semantics is a lot of
trouble, and internal definitions are usually much more legible
anyway.

This is a lot of little commits in case I made a mistake so you can
bisect to find the mistake.

Convert multi-LETREC to internal definitions in edwin/undo.scm.

Convert multi-LETREC to internal definitions in edwin/txtprp.scm.

Convert multi-LETREC to internal definitions in edwin/tterm.scm.

Convert multi-LETREC to internal definitions in edwin/tparse.scm.

Convert multi-LETREC to internal definitions in edwin/string.scm.

Convert multi-LETREC to internal definitions in edwin/occur.scm.

Convert multi-LETREC to internal definitions in sos/class.scm.

Convert multi-LETREC to internal definitions in uri.scm.

Convert multi-LETREC to internal definitions in thread.scm.

Convert multi-LETREC to internal definitions in stream.scm.

Convert multi-LETREC to internal definitions in srfi-1.scm.

Convert multi-LETREC to internal definitions in rfc2822-headers.scm.

Convert multi-LETREC to internal definitions in ordvec.scm.

Convert multi-LETREC to internal definitions in list.scm.

Convert multi-LETREC to internal definitions in lambda-list.scm.

Convert multi-LETREC to internal definitions in dispatch-cache.scm.

Convert multi-LETREC to internal definitions in arith.scm.

Convert multi-LETREC to internal definitions.

The compressor turns up hot in profiles.  This doesn't make a big
difference but it saves some closure consing and reduces some
indentation levels.

Add some LETREC and LETREC* tests.

Use internal definitions for LETREC* and unary LETREC.

The compiler will recognize these better than LET and SET!; teaching
it to recognize LET and SET! is more trouble than I want to deal with
at the moment.  Internal definitions at the scode level have LETREC*
semantics anyway, and with only a single binding, LETREC and LETREC*
coincide.

Eliminate potentially-problematic use of delay for char-set-predicate.

Use arity-dispatched procedures for MAP, FOR-EACH, &c.

Requires shuffling initialization order in make.scm a little bit so
that we can call MAKE-ARITY-DISPATCHED-PROCEDURE in list.scm.

Saves a trip through the microcode to compute the lexpr for each call
to MAP and FOR-EACH, which turned up hot in profiles.

Integrate NULL-LIST?.

This is used all over common SRFI 1 list operations, so what should
have been a pair of conditional branches turned into unknown
procedure calls, sometimes through a trampoline to fill in default
arguments, which turned up in profiling the compiler.

Add GENERAL-CAR-CDR to usual integrations.

The compiler explicitly calls this for every RTL accessor, so that
would explain why this primitive was turning up hot.  Should speed up
the compiler a little to avoid diving into microcoded primitives for
every attempt to get a piece out of an RTL expression during the RTL
passes!

Put char-set microcode table back in data structure.  Edwin needs this.

Cache char set table.

This is a provisional kludge to make string searches by character set
in Edwin less obscenely expensive than they are at the moment, which
is killing IMAIL.

Formerly we just cached these in the char-set object itself.

Integrate record accessors and modifiers where convenient.

Limited to record types with:

- a defined predicate name we can pass to GUARANTEE, and
- no parent type so we can statically determine the field offsets.

Obviously it would be better if the compiler could do the flow
analysis to figure out where it can statically partially evaluate
RECORD-ACCESSOR and RECORD-MODIFIER, but, y'know, exercise for the
reader.

Defer unmasking timer interrupt until after daemon is marked running.

Otherwise we might re-enter on timer interrupt.

Avoid consing closures if we're low on space.

Can't see why I chose to discard recent samples a decade ago.

Dust off stack sampler.

Use of compiled-code-address? will be needed by the
riastrah-20181220-closentry{...} branch.

Test restarting trapped references.

This is busted on x86 because of a compiler bug involving register
reuse, to be fixed on the riastradh-20181220-closentry{...} branch.

Fix the rest of the indentation in this file.

No functional change.

Fix bug in test introduced by eliding open-block for SYNTAX.

While here, fix indentation.

Eliminate simple-top-level-environment.

This hasn't worked as intended since the reader was rewritten.

Change param:reader-fold-case? to be settable.

x11: Fix declaration of x_graphics_set_clip_rectangle.

x11 version 1.3

x11: Punt import-x11.

runtime.pkg: Trim old, unnecessary package exports.

The (runtime x-graphics) package doesn't use have-select? nor (lately)
make-image-type.  (The (x11 device) package imports make-image-type.)

x11: Link to deprecated (runtime x-graphics) bindings when loaded.

x11: Rename device type to "x".

Don't return open block at top level when syntaxing a single form.

x11: Fix x-graphics-vdc-extent and x-graphics-set-clip-rectangle.

x-graphics-vdc-extent should have had one argument and returned a
vector, and x-graphics-set-clip-rectangle needed to accept floats.

Change tests to use sub-tests as originally intended.

I messed it up the first time and Taylor had to patch around my mess.

Eliminate unnecessary consing in char-set-empty?.

Find all relevant shared objects.  Handle NMV headers in vectors.

Fix pasto for LIARC build of SOS.

gitignore LIARC build products.

Don't leave the intermediate run-build shell process hanging around.

Run the ChaCha self-tests too.

Refuse to let the MD5 primitives run unless self-test passes.

Fix buffer overflow in self-test.  Derp.

This self-test was not used; there's a separate test in test-md5.scm
which is fine.  (The result in this self-test is also correct -- it
just never got tested anywhere.)

Fix byte ordering: encode state words in little-endian; don't memcpy!

How did I miss this earlier!?

Exploit oddness to get bit-for-bit identical results on +/-.

Fixes test failure on NetBSD/powerpc:

;|logit-logistic-1/2/(.2310585786300049 1.)| failed 1 sub-tests out of 1 in 0. seconds:
     assertion 1: value was -.23105857863000487 but expected an object = to -.2310585786300049

Use a much simpler endian-independent execute cache mechanism.

Requires no changes to the SVM1 byte code, so existing unlinked .com
files will continue to work (except for those created in the past
couple hours with my big-endian bodge that entailed no changes to the
little-endian hack), although built bands will confuse the microcode
because what cmpint stores in execute caches in memory changed.

- Before linking, an execution cache is simply the two words, as
  before on little-endian systems:

    <frame size> (fixnum)
    <name> (symbol)

- After linking, the frame size remains untouched and the name is
  replaced by the untagged address of the target:

    <frame size> (fixnum)
    <target> (untagged)

- INVOCATION:UUO-LINK now generates an (indirect-jump (pc-relative
  <cache>)) instruction, which already does the right thing:
  dereferences PC + offset to find a instruction address, and then
  jumps to that address.

Fix lambda-body -> scode-lambda-body straggler.

Design big-endian uuo link execute caches.

The little-endian hack to overwrite the tag with instructions doesn't
work on big-endian because it's the datum, not the tag, that's at the
end of the word in the frame size.

There's no room for the instructions before anything here, so add
another word and move the frame size to the end.  Kinda wasteful --
for that matter, it's not clear why we need to have any instructions
here at all, when we could just have INVOCATION:UUO-LINK compile to
an IJUMP instruction itself.

Teach SVM back end how to assemble big-endian instruction streams.

Gotta do 'em backwards because the words are backwards in a bit
string on big-endian systems.

Fix ordering of _words_ in fasumped bit strings on big-endian.

Apparently the byte order within a word affects the word order within
a bit string.

Tweaks to make Edwin cross-compilable.

Nothing architecturally limits powerpc to high memory.

Individual operating systems may, but none that I've encountered.

We may revisit this if we change SVM1 to always work in high memory.

Use HOST_CC, default CC, to compile findprim.

This needs to run on the host system, not on the target system.

This way we can cross-compile the microcode if you have a C
cross-compiler handy, which makes iterating development a lot faster
when the target's native C compiler is painfully slow.

Make powerpc floating-point exceptions fit in fixnums on 32-bit.

Load with load-option so this gets LIARC bundles correctly.

Mkdir lib/lib with -p in configure so it is idempotent.

Disable constant-folding machine-dependent primitives in LIARC.

These are not valid across word size changes, but LIARC does not
expose compiler:cross-compiling?.

One more round of rework for LIARC.

Keep the host actions and target actions separated by a stamp file as
with other cross-compilation.

Name the targets:

- cross-host does the actions on the host (some day, all of them),
  and creates stamp_cross-host

- cross-target does the actions on the target, which all depend on
  the host actions only through stamp_cross-host

- all does cross-host and then cross-target.

With any luck, this should preserve the behaviour of non-cross
builds.

Still missing: Makefile.tools doesn't work _from_ a system with LIARC
yet to cross-compile, because we have no way to build a fresh runtime
or create bundles outside the standard build.

=> We should not depend on a full fresh runtime, only on the macros.

=> We should have a way to link bundles.  (For that matter, we should
   have a notion of shared libraries that can be loaded independently
   and with shared read-only physical memory, rather than as a bodgy
   sequence of bands copying the data around.)

Fix bug: characters with bucky bits not printing right.

Avoid WRITE in URI->STRING.

We use this early on in loading an image -- before we have
initialized all the LIARC objects (indeed, in the course of
initializing LIARC objects), which may themselves have predicates in
the print method dispatcher.