gtk/swat-pole-zero: Quiet warnings about colors and fonts.

Fill unit circle with canvas-color.

Remove <box-ink> (gtk_render_focus), the last stylish ink.

Use a rectangle ink in the demo instead.

It is too hard to calculate a stylish ink's extent, because it depends
on the style context -- the current theme's colors, line widths, etc.

Merge branch 'master' into Gtk.

src/etc/compile-svm.sh: Use max heap to cross-compile on i386.

Running the secondary GC daemons after compiling a directory helps,
but 10000KiW is still too small.  Cross-compilation of edwin/snr hangs
unless 12000KiW can be had.

Abort the console thread when heap is low.

Previously, a random running thread was aborted, e.g. the
single-threaded workload.  Recently, just the notification subscribers
were aborted.  But it is common for there to be NO subscribers,
e.g. during a single-threaded workload (our own build!).  Now the
console thread is also aborted (and notifications are punted).

run-gc-finalizers: Avoid deadlock in this GC daemon.

If a GC interrupts a finalizer operation that is holding the
finalizer's lock, it will deadlock in the GC daemon unless it can
punt.

GC daemons may run when there is no current thread(!).

Thus they cannot use signal-thread-event which, if there is no current
thread, will not return.  (Why DOES signal-thread-event call
run-thread?)

Fix try-lock-thread-mutex to work when there is no current thread.

GC daemons need to run when there is no current thread.  Try-lock-
thread-mutex was intended for their use.  They do not mind
occasionally skipping an opportunity to clean, including the rare
times when a GC interrupt occurs with no current thread -- in the
thread system of a quiescent world.

Try-lock-thread-mutex was signaling spurious deadlocks when GC daemons
ran with no current thread.  Free locks appeared to be owned by #F --
the current thread.

Fix directory-read to NOT drop the occasional file.

char_pointer_to_string was used instead of
char_pointer_to_string_no_gc even though there is no way to retry
the OS_directory_read().

debug.c (verify_heap, dump_heap_at): Avoid SIGSEGVing.

Check that all pointers and block offsets are valid heap addresses
before following them.  Do not dump words past Free (in bogus objects
at the end of the heap).

utils.c (copy_history): Do not update Free unless it all fits.

This just keeps bogus pointers out of the heap so that verify_heap
cannot complain about them.

world-monitor: truncate lines

dist/make-src-files: Include tests/ in the source distribution.

Eagerly transport list CDRs to linearize lists.

src/microcode/debug.c (verify_heap): Verify pointers.

src/microcode/typename.txt: Rename obsolete types.  Re-sort.

src/microcode/debug.c: Improve verify_heap.  Add verify_stack.

Scan the stack and note if it is not "sealed" ("closed"?).  It should
have either a return code or a compiled entry at the top.  Also note
any extraordinarily large objects.

src/microcode/stack.h (STACK_LOCATIVE_LESS_P): Rename _ABOVE_P.

The stack direction neutral name STACK_LOCATIVE_ABOVE_P(a,b) makes
more sense next to STACK_BOTTOM and STACK_TOP.

src/microcode/gcloop.c (gc_type_map): Undefine obsolete types.

runtime/world-report.scm edwin/world-monitor.scm: minor fixes

Add missing case for thread-execution-state STOPPED.  Add "monitor" flag.

Remove REDUCE-LEFT from documentation.

Proper implementation of FOLD-LEFT.  Implement FOLD and REDUCE using FOLD-LEFT.  Remove REDUCE-LEFT.

Don't export REDUCE-LEFT from (runtime list).

Use FOLD-LEFT instead of REDUCE-LEFT.

Undo delayed adding of hash-table to population.  Instead, skip uniqueness check on new hash-tables.

src/planetarium/geometry.scm (3d-~=): Misplaced paren.

Merge branch 'master' into Gtk.

Add open-unix-server-socket and unix-server-connection-accept...

...and close-unix-server-socket.

Add MONITOR-WORLD Edwin command displaying an animated world-report.

Add a WORLD-REPORT procedure to write a state-of-the-world report...

...showing the current time, heap free, recent GC statistics, and the
known threads.

Add crude thread time accounting.

src/runtime/savres.scm (disk-save): Save time world was restored.

src/runtime/output.scm (write-strings-in-paragraph): Add.

src/runtime/gcnote.scm (gc-statistic->string): Abbreviate...

...to keep each line under 80 columns (at least at first).

Typos.

Don't blow out the stack in STREAM->LIST.

Don't add table to rehash population until an entry is created.

Add STREAM-LAST and STREAM-TRUNCATE.  Fixed a typo.

terrain: Fix glx-viewport-draw method.

Remove redundant (now incorrect) call to with-glx-widget (i.e.
glXMakeCurrent).  GL no longer allows recursive locking.

Fix %trace to use outf-error instead of generic IO.  The latter may
suspend-current-thread during a callback.

Punt glColorMaterial and much frobbage (e.g. setting params to their
defaults) copied from examples.  Minimize differences between
draw-colored and draw-shaded.

gl: glx:swap-buffers already does a gl:flush.

Merge branch 'master' into Gtk.

Return 0 from OS_test_select_* ONLY if there are no pending...

...interrupts or subprocess status changes.

Add foreach_async_signal and an ASYNC flag for signal descriptors.

glibio.c uses this to set up its signal forwarder.

Do not randomize the FPU control word in x87_read_environment.

Looks like a typo: eax not replaced by rdi.

Do not initialize the floating-point environment in x86-64 assembly.

The floating-point environment is managed (and needs to be
initialized) by libc.

Do not initialize the floating-point environment in i386 assembly.

The floating-point environment is managed (and needs to be
initialized) by libc.

Add interrupts_p and OS_select_registry_entry for glib/glibio.c.

Add an ignore_status_change parameter to OS_pause for SMP-IDLE.

OS_pause previously returned immediately if there were pending
interrupts OR subprocess status changes, as required by a blocking
test-select-registry primitive.  That made it useless to the SMP-IDLE
primitive, which spins in the idle loop until the io-waiter (or a
timer interrupt handler) gets around to syncing subprocess statuses.
It will spin too after getting a SIGCHLD until statuses are synced.

Remove last diff from master in runtime/.

The predicate sexpr in master works only because (fix:= 0 #f).
Replace the generic arithmetic (= (or #f 0) 0) only to remove the last
diff with master in runtime/.

Remove extra call to maybe-signal-io-thread-events in yield-current-

This must have snuck in with a large merge.

Remove unused load-option/suppress-loading-message?.

Reduce runtime/ diffs between this branch and master.

Remove obsolete nonblocking/subprocess-wait.

Reduce runtime/ diffs between this branch and master.

Remove (stash) debugging %traces in runtime/.

Reduce runtime/ diffs between this branch and master.

Punt without-preemption; use without-interrupts during callouts.

Using without-preemption in (runtime ffi) causes timer interrupts to
be ignored -- COMPLETELY ignored in the glxgears demo's animation
loop.  It is probably no more helpful in with-obarray-lock(?).

Punt without-preemption; use without-interrupts during callouts.

Its use in (runtime ffi) causes timer interrupts to be ignored --
completely ignored in the glxgears demo's animation loop.  It is
probably no more helpful in with-obarray-lock(?).

gtk: Get with Gtk+ v3.16; punt widget colors; use GtkCssProviders.

Eliminate or replace calls to deprecated Gtk+ functions.  Punt gtk-
widget-parse-color, gtk-widget-bg-color, etc.  Add gtk-widget-set-
name, gtk-widget-get-style-context, gtk-style-context-add-provider,
<gtk-css-provider>, etc.

gtk: Port GtkScrolledView and GtkPanedView to Gtk+ 3.10.8.

gtk: Port GtkScrolledView and GtkPanedView to Gtk+ 3.14.13.

gtk: No need to frob subprocess-wait anymore.

Hook/subprocess-wait is gone.  The default subprocess-wait is now
nonblocking/subprocess-wait.

glib: Use g_free to free a *GError allocated with g_try_malloc0.

gtk: Port GtkScrolledView and GtkPanedView to Gtk+ 3.16.7.

Attempt to pick from multiple implementations per the Gtk+ version.

gtk: Remove deprecated enums.

Merge branch 'master' into Gtk.

Update copyright years.

dist/update-copyright.scm: Translate last-copyright-year.

dist/update-copyright.scm: Update files in place.

Start with a clean working tree and you can `git reset --hard HEAD'
when the translation goes badly.

Note last-statistic early in signal-gc-events.

The signaled thread events may run whenever, perhaps after
last-statistic is changed.  Ensure all the thread events get the same
statistic -- the last-statistic when the events were sent.

edwin: Eliminate redundant thread event when setting run-light.

Using inferior-thread-output! in wait-for-input's thread event signals
another thread event unnecessarily.  The new inferior-thread-run-
light! just sets the flags.

Eliminate multiple trigger-gc-deamons!.

The GC notification in GC events reveals that the after-gc interrupt
handler can run multiple times after one GC.  This seems to happen
when a timer interrupt occurs during trigger-gc-daemons!.  Thread
switching leads to re-signaling.  (Was it assumed interrupt handlers
would not allow thread switching?)

This new interrupt handler is applied with interrupt-mask NOT
/timer-ok and allows timer interrupts only after clearing the after-gc
bit.  A substitute mechanism prevents "us from getting into a loop
just running the daemons."

Add clock time (HH:MM) to GC notifications.

This makes it easier to see if a long running program is GCing more than
infrequently.

edwin: Add a timeout parameter to the peek-no-hang input operations.

Factor the busy loop out and name it keyboard-peek-busy-no-hang.  Use
it in the peek-no-hang input operations to implement the timeout.

Add register-gc-event, deregister-gc-event, registered-gc-event.

Punt the hook/record-statistic! fluid.  With-gc-notification now uses
dynamic-wind to register and deregister a GC thread event for the
current thread.

Do not use ANY fluid state (e.g. nearest-cmdl/port) during a GC.  Use
the console-i/o-port in hook/gc-start and hook/gc-finish.  GCs can
happen in the thread system when there is no current thread.

The fluid state IS defined during the GC thread events.  At the start
of such events, signal a REPL abort if the heap is low.

Replace subprocess status ticks with thread events.

Without without-interrupts, ticks do not work.  It is possible to
block even though a subprocess has changed state between the last
observation of the global status tick and the suspend.  Passing the
observed tick to suspend-current-thread would allow it to check for
new ticks in the atomic section wherein it decides if the thread
should suspend, but replacing without-interrupts with with-thread-
events-blocked suggests a cleaner solution: subprocess thread events.

The new procedures register-subprocess-event and deregister-
subprocess-event are now used by Edwin.  ANY main loop managing
subprocesses AND IO should be using register-subprocess-event along
with with-thread-events-blocked and suspend-current-thread to reliably
block for either in an SMPing world.

Block-on-io-descriptor now uses with-thread-events-blocked instead of
without-interrupts but it does NOT use register-subprocess-event AND
WILL NOT UNBLOCK WHEN A SUBPROCESS CHANGES STATUS.

Unfortunately this breaks Edwin on OS2 and Win32 where it is now
possible for Edwin to block for keyboard input without noticing that a
subprocess has exited.  Edwin's main loop in these worlds needs to be
updated to use a "suspend loop" and register-subprocess-event even
though they do not actually multi-process.

Subprocess-wait now uses a suspend loop like the one in block-on-io-
descriptor rather than blocking for the rest of the thread's timeslice
in the process-wait primitive.  Synchronous subprocess management now
uses this procedure instead of the curious subprocess-wait*, the only
remaining procedure using ticks.

Thus SUBPROCESS-GLOBAL-STATUS-TICK and SUBPROCESS-STATUS-TICK are
eliminated.

Reimplement permanently-register-io-thread-event for SMPability.

Remove permanent tentries (waiting thread entries) from
io-registrations.  Replace them with an event wrapper that loops,
re-registering after the wrapped event finishes.  The loop assumes IO
is being consumed during the event.  If not, it may spin forever.

Remove the notion of registering for the "front" of the queue too.

The X graphics device must take care to de-register its IO event
before closing the display, else the thread system may apply test-
select-registry to a closed descriptor.

edwin: Fix inferior threads' wait-for-input.

Set the run-light BEFORE setting inferior-thread-changes?.  Edwin may
accept-thread-output and clear the flag before it handles the thread
event (which will set the run-light, but not -changes?).

Do NOT use permanently-register-io-thread-event in Edwin.

Edwin does not consume the IO in the thread event.  This worked in a
uni-processing world where another thread could consume the IO in
round-robin fashion, but in an SMPing world there is no way to know
when it is appropriate to signal another event.  In a naive
implementation (without special handling of these events), an idle
processor would spin, queuing MANY "IO ready" events to one thread
until another thread consumed the IO.

Edwin's X11 and console display types now block for IO on multiple
descriptors, the X or tty descriptor PLUS the subprocess output
descriptors.  They no longer use permanent IO thread events to handle
the latter.

Edwin's remaining uses of permanently-register-io-thread-event are in
single-threaded OS2 and Win32 worlds.  The runtime's only uses are in
the OS2 and X11 graphics devices where the IO *is* consumed during the
event.

doc/user-manual: Unix Installation: minor edits.

Fix gdbm plugin instructions; there is no configure script in src/gdbm/.

svm: finish-cross-compilation of everything using a large heap.

Update versions to 9.2.1.

Don't let mime decoding errors crash imail.

Automate the mime codec tests.  Still need work.

Make all mime decoders signal a common condition type.

Document REFERENCE-BARRIER.

ffi: Fix callouts that return a struct or union.

I missed a hunk while porting Peter Feigl <craven@gmx.net>'s patch to
commit cf1e855.

Use without-interruption and more locking(!) in gcfinal.scm.

Prepare the GC daemon to run concurrently with other threads; lock each
finalizer while it is cleaned in run-gc-finalizers.

Add without-interruption to add-to-, remove-from-, remove-all-from-,
with--lock, and make-gc-finalized-object, NOT to search- or -elements.
Reset-gc-finalizers also lost its without-interrupts, but it is an
after-restore event already executed without-interrupts.

Remove without-interrupts from runtime/process.scm.

Serial access to a subprocess is the responsibility of the user.  Thus
subprocess-i/o-port and close-subprocess-i/o do not need without-
interrupts to implement it.

Closing a port twice should not signal an error, so subprocess-delete
and close-subprocess-i/o do not need even without-interruption.
However they should close the port before clearing the subprocess
slot, else an abort could drop the port and it's channels may not be
closed for an arbitrarily long time.

Status sync could miss changes and subprocess-i/o-port and
make-subprocess could drop a subprocess or port if aborted mid-stride.
They now use without-interruption.

Remove without-interrupts from runtime/os2graph.scm.

Remove without-interrupts from runtime/x11graph.scm.

Replaced it with without-interruption.  Presumably the desire was to
keep the permanently registered IO thread event from interrupting
itself.

Remove without-interrupts from runtime/random.scm.

Use a mutex to serialize access to the default random state.  Serial
access to other random states is still the responsibility of the user.

Remove without-interrupts from runtime/queue.scm.

Add make-serial-queue and use it in runtime globals: the event
distributors, GC daemons and REPLs.  Note that the "safe" queue
operations, when applied to non-serializing queues in SMPing worlds,
are NOT thread-safe.  This only happens in LIAR, SWAT, Edwin, X11
Graphics and OS2 Graphics -- single-threaded applications.

Serialize access to the population-of-1d-tables.

Allow create-thread to be run by multiple threads concurrently while
still accessing the population-of-1d-tables serially.

Remove without-interrupts from runtime/intrpt.scm.

It was only used in the internal install procedure where an "atomic"
updated was described.  Punted that and assumed the procedure is not
run in multiple threads concurrently.  It should be called only during
the single-threaded cold load or in a careful developer's REPL(?).

Remove without-interrupts from runtime/io.scm.

Channel-read and channel-write used without-interrupts for atomicity,
to avoid calling primitives with a channel another thread has closed.
The resulting errors may have been expensive to handle, but the cheap
technique of calling without-interrupts is ineffective in SMPing
worlds.  Assuming most channels are used by one thread and will not
encounter these errors, just punt the calls to without-interrupts.

Serialize modifications to the channel table (esp. channel-close) via
the open-channels gc finalizer's atomic section and the new
with-gc-finalizer-lock procedure.

Remove tty-input-channel and tty-output-channel from general use.
They are only used in a cold load initialize-package! procedure and an
after-restore reset-console procedure.  They are not fit for general
use, creating a new channel object each time they are called, only the
newest one of which is returned by descriptor->channel.  Assume these
procedures are only used in single threaded fashion.

In open-pty-master, directory-channel-open and make-select-registry,
replace without-interrupts with without-interruption to avoid dropping
a channel or registry because of an inopportune abort.  GC finalizers
like open-channels and open-directories (and select-registry-
finalizer) are already serializing.

Do NOT export channel-descriptor-for-select to the () package.  Assume
select registries and their result vectors are used ONLY internally,
in single threaded fashion, by the thread system.  Punt the
unnecessary and now useless calls to without-interrupts.

In dld-load-file and dld-unload-file, serialize access to the
dld-handles via dld-handles-mutex.

Remove without-interrupts from runtime/infutl.scm.

Without-interrupts was used to make atomic accesses to the
uncompressed-files cache and the wrappers-with-memoized-debugging-info
population.  To replace it, a serial population is used and the
uncompressed-files cache is punted.  The latter is hopefully
unnecessary on modern machinery.

Remove without-interrupts from runtime/hashtb.scm.

Serial access to particular hash tables is (now?) the responsibility
of the user -- all access, not just modifications (because of lazy
rehashing).  Serial access to the list of all address hash tables is
now the responsiblity of a serial population.

Most calls to with-table-locked! (aka without-interrupts) are now
calls to without-interruption (to postpone inopportune aborts).

Remove with-absolutely-no-interrupts from runtime/hash.scm.

Use a thread mutex to serialize access.  Simplify an ancient
implementation by using the new datum weak and key weak hash table
types. Initialize the package AFTER (runtime hash-table).

Remove without-interrupts from runtime/global.scm.

Clean-obarray runs as a secondary-gc-deamon and thus, in SMPing
worlds, it may run in parallel with other threads on other processors.

A number of primitives and compiler utilities modify the obarray so an
SMPing microcode will use a pthread mutex to serialize access to it.
Clean-obarray now uses a new procedure, with-obarray-lock, that uses
new primitives to participate in the serialization.

Remove without-interrupts from runtime/generic.scm.

Serial access to particular generic functions is still the
responsibility of the user.  Serial access to the
generic-procedure-records table is now ensured by a thread mutex.

Remove without-interrupts from runtime/geneqht.scm.

Serial access to a particular table is still the responsibility of the
user (e.g. SOS procedures?), but the list of all address hash tables
is now a serial population.

Add make-serial-population.

Also add empty-population! and for-each-inhabitant.

Do not export the /unsafe procedures even to (runtime); require that
they be explicitly imported (specifically exported?).  Use the /unsafe
procedures in (runtime 1d-property) and (runtime thread) package
initializations to avoid trying to lock the population-of-populations
too early in the cold load.