code/misc.lisp::
* Remove :i486 from *features*

code/multi-proc.lisp::
* Change :i486 to :x86 on the off chance that multi-proc will be
  ported to other archs.

compiler/x86/cell.lisp::
compiler/x86/macros.lisp::
compiler/x86/memory.lisp::
* Remove guard on backend-featurep :i486 since we got rid of :i486 and
  have it always enabled now.

entries with just the file path, removing the revision number, date,
author and state.  The actual information is now computed during
compilation and stored in the fasl itself.  (See ticket:48.)

boot-2010-02-1 as the bootstrap file.  You should probably also use
the new -P option for build.sh to generate and update the po files
while building.

sse2-packed-2008-11-12).

Fix typo.

and *RUNTIME-FEATURES* and setting them appropriately as files are
loaded so that recompiling CMUCL produces a result with the same set
of features.  *RUNTIME-FEATURES* is a subset of *FEATURES* that is
written out to internals.h so the C code can be compiled
appropriately.

A simple bootstrap with boot17 is needed.

Fix a typo in apply-with-bindings.

Add string-stream and file-stream, required by the ANSI spec, as
structure classes.  Make the string streams and fd-stream,
respectively, inherit from them.  Add bootstrap magic.

Add features to multiprocessing that make it more compatible with ACL.  These
include process run reasons, arrest reasons, and property lists.

a timeout; it had been incorrectly returning nil when the fd was
immediately usable which caused trouble for CLX as noted by Fred Gilham.

timeout was given. Fixes CLX event handling.

when a timeout was given and wait was true.

calls - only return when usable or upon an error.

locks will work even if multi-processing is not initialised.

the pthread implementation. Add new structures recursive-lock and
error-check-lock. Make-lock now accepts a :kind key which defaults to
:recursive for backwards compatibility. Rework with-lock-held to
handle the error-check locks, and add a new key :wait - when :wait is
Nil and the lock is not free the body is not executed.

approximately twice as long as requested.

internal to the LISP package; fixes failures to throw to the top level.

Add a new example function Startup-Idle-and-Top-Level-Loops to enter
the idle loop and start a new process to run the top level loop.

the *all-processes* list, function affected: make-process,
destroy-process, restart-process, disable-process, and enable-process.

Save and restore the process wait return value when a process is
interrupted in case a process is interrupted before it reads the
return value.

make-stack-group.  The binding stack size didn't match the actual
vector length which was recently reduced, this typically led to heap
and bindings stack corruption.  Better abstract the creation of the
initial binding stack, adding a new function initial-binding-stack.

package.

print-unreadable-object macro.

Bind *read-eval* to nil and catch any errors when reading the password
object in the lisp connection listener!

port, and add at least some simple password protection.

next process wait timeout and use this as the select timeout if it
occurs sooner than the default timeout. This helps reduce the time
blocked when processes wait for short periods, for example during
graphics animation.

listen for connections on a TCP port and start a new top-level
process for each connection.

error occurs.

sys:wait-until-fd-usable but uses process-wait so avoids blocking if
there are other runnable processes.

Redefine the sleep function to use process-wait-with-timeout to avoid
blocking if there are other runnable processes.

for the CLX holding-lock macro. New support function
lock-wait-with-timeout.

Update the eval-stack for the current stack-group when scrubbing to
ensuring that the stack-top is valid and maybe flush an old stored
vector.

Completely scrub the stored binding stack for the current stack group.

Implement the lock waiting in a separate function rather than
inlining. This ensures that the wait predicate is fast native code so
that locking in byte-compiled and interpreted code doesn't slow the
scheduler.

rather than inheriting the current stack.

Add support for scrubbing the binding and eval stacks of all the
processes - call this before GC.

stacks rather than inheriting those of the current stack group. The
alien stack, the eval stack, and the shallow bindings are allocated
afresh for the new stack-group, but some work on the VOPs is needed to
handle the control stack. Initial bindings for the following symbols
are setup by default: * ** *** - + ++ +++ /// // /.

Exploit this new option during the creation of new processes. The user
visible change is that new processes now have a fresh set of bindings
rather than inheriting those of the parent process.

During the unwinding and rebinding of the binding stacks there is the
possibility that *interrupts-enabled* will briefly set to true which
may cause an unexpected interrupt. For now mask the interrupts during
the binding stack switch; a better fix may be to implement these
functions in assembly routines using pseudo-atomic to block
interrupts.

all the processes giving them some chance to unwinding, before
shutting down multi-processing. Can be restarted by init-multi-processing.

Ensure that processes are activated when sent an interrupt by
destroy-process, otherwise inactive processes can't be destroyed.

possible from the initial process). When a process throws to
%end-of-the-world the exit value is noted in the *quitting-lisp*
variable and further process creation is blocked. Have the idle loop
try to gracefully destroy all the processes when *quitting-lisp*
before exiting.