1.0.6.22: fix occasional UNBOUND-VARIABLE errors in MAP-REFERENCING-OBJECTS

         * Introduced by the removal of (SAFETY 0) in room.lisp a while ago

1.0.6.21: get rid of a runtime compiler note in the PCL cache code

         * For some reason appeared only on x86-64, not x86.

1.0.6.20: add INSERT-ARRAY-BOUNDS-CHECKS declaration to WITH-PUSH-CHAR

* Part of the fun of having good abstractions is being able to
  throw all caution to the wind inside the abstraction.  This
  gives another little speedup on printing floats.

1.0.6.19: optimize BIGNUM-TRUNCATE'ing by small powers of two

* This is a common case when printing floating-point numbers.  On
  the simple "print a million single-floats" benchmark, this wins
  by about 20-25%;
* Also fold a few i+1 loop variables into their only use; doing so
  is not much worse that what we had before and slightly better if
  the backend supports DATA-VECTOR-REF-WITH-OFFSET.

1.0.6.18: Two fixes from Eric Marsden
... DEFPACKAGE :USE/:IMPORT-FROM takes package designators
... REMOVE-DUPLICATES / :TEST-NOT / vectors
Include test cases, and do a little bit of other tidying
of test case expected failures.

1.0.6.17: Housekeeping from specializer changes
Comments and documentation only.

1.0.6.16: add SB-POSIX:GETCWD

 * Based on patch by Tassilo Horn.

 * Factor out the growing buffer -logic used by both getcwd() and
   readlink(), and make it not leak memory so easily.

1.0.6.15: add SB-POSIX:LOCKF

 * Patch by Zach Beane, also add a CREDITS entry for him.

1.0.6.14: slightly more efficient FLONUM-TO-DIGITS

 * Implement SB-IMPL::WITH-PUSH-CHAR: an efficient way of constructing
   shortish strings one character at a time.

 * Use it instead of a string with fill-pointer in FLONUM-TO-DIGITS:
   Speeds up naive float printing tests by ~10%, and causes them to
   cons approx. 7% less.

1.0.6.13: minor fix to the compiler's interval-arithmetic

 * When calculating the interval of (* some-number constant-zero),
   multiply the signums of the interval endpoints, not the numbers
   themselves: this avoids compile-time breakage when the zero is a
   float and the non-zero number is too large to be represented as a
   float.

1.0.6.12: Improve user-subclassed SB-MOP:SPECIALIZER support
In order to support surface syntax for users in DEFMETHOD,
define and bootstrap a new SB-PCL:MAKE-METHOD-SPECIALIZERS-FORM
(a bit like SB-MOP:MAKE-METHOD-LAMBDA).  This or something like
it is fundamentally necessary to support EQL specializers, which
as syntax have a bit which is syntax and a bit which is
evaluated in the lexical environment of the DEFMETHOD form.

Bootstrapping it is a little tedious, but (eventually) work out
where parsed specializers can be made and where we don't yet
have FIND-CLASS in the bootstrap.  In the course of that, note
that we need to be able to parse and unparse specializers at
runtime: parsing to support FIND-METHOD; unparsing to get nice
names for our method functions in backtraces.  Define an
experimental interface for that, too (see NEWS).

In the process, fix a couple of bugs in NO-NEXT-METHOD handling;
it is not safe to assume that the compile-time method name can
be used to find the method object.  Instead, fight a little bit
with the file compiler to have a cons cell shared between the
method function and the method initargs, and arrange to have the
cell's CAR be set to the method once it is created; then we can
do NO-NEXT-METHOD sanely.

Tests for the no-next-method stuff, and adjust wonky find-method
specializer arguments in other tests.

1.0.6.11: PRINT-OBJECT method adjusted for new caches

 * "Oops" -- missed from the original cache commit.

1.0.6.10: put --disable-debugger back where it belongs

* it was accidentally deleted in a previous commit.

1.0.6.9: micro-optimize portions of the reader

* use the more idiomatic (and better optimized) MAKE-ARRAY/REPLACE
  combination to grow the read buffer;
* host some special variable accesses and eliminate bounds checking
  in CASIFY-READ-BUFFER.

1.0.6.8: improve (SUBSEQ FOO 0 ...) on arrays with elements >= word-size

* check for a constant-valued start parameter and pass its value
  through to the loop-generating machinery.  Before we would have
  compared 'START to 0, which always fails; now we can recognize
  that case and generate better code.

1.0.6.7: thread-safe UPDATE-DFUN

 * Make GET-SPINLOCK detect unwanted recursion. Despite the old
   comments in GET/RELEASE-SPINLOCK, we can store EQ-comperable lisp
   objects in SPINLOCK-VALUE -- just like we do for mutexes.
   (Potentially freshly consed bignums that the old comments referred
   to are not sanely EQ-comperable, of course.)

 * Implement WITH-RECURSIVE-SPINLOCK.

 * Adjust thread.impure.lisp accordingly.

 * Add a per generic function spinlock. (We could use mutexes, but
   since contention is presumed to be rare we don't want to pay the
   wakeup syscall cost for every UPDATE-DFUN call: if and when our
   mutexes get smart doing the wakeup only when there are threads
   waiting we can and should switch this -- and probably almost all
   uses of spinlocks -- to mutexes.) This spinlock is grabbed to
   ensure that the dfun state, fin function, and name are all updated
   atomically.

1.0.6.6: delete remains of the unoptimized-cache function code paths

 * 1.0.6.3 did away with the main body of the code, but actual access
   points to the now-missing code paths were accidentally left in.

1.0.6.5: potential CLOS GC safety issue

 * EMIT-FETCH-WRAPPER needs to emit code that checks that it has a
   real standard instance (as opposed to a structure) before it can
   pull the slots: if the structure eg. has no slots at all we would
   be pulling garbage into a lisp variable, which is not good (TM),
   though it should be non-serious on GENCGC platforms.

   To make this fast we add a new slot to LAYOUT: FOR-STD-CLASS-P,
   which is always NIL for layouts, and T for wrappers.

 * Remove one redundant SET-DFUN, which may have been needed in long-gone
   days when cache vectors were resourced, but not anymore.

1.0.6.4: restore buildability on non-SBCL hosts

 * SB!VM, not SB-VM in genesis.lisp. Reported by Peter Graves on sbcl-devel.

1.0.6.3: thread and interrupt safe CLOS cache

 * New cache implementation. While the patch appears to modify
   src/pcl/cache.lisp, it is really a wholesale reimplementation.

   -- Use compare-and-swap to provide atomicity where necessary.

   -- Layouts are write-once, but cached values can be replaced
      atomically.

   -- Expanding the cache (or dropping invalidated and incomplete
      entries) copies the cache.

   -- Use ..EMPTY.. as a sentinel value to denote unused cache line
      slot.

   -- Cache index zero is no longer special.

   -- Maximum cache size is limited to avoid ridiculously huge caches.

   -- API changes in the cache code: MAKE-CACHE replaces GET-CACHE.
      PROBE-CACHE now returns a primary indicating a hit or a miss,
      and returns the probed value as the second return value.

 * Move remaining non-cache related code from cache.lisp.

 * Delete unused closure-based dispatch code (src/pcl/dlisp2.lisp). If
   we want to support a compilerless build at some future date this
   code can be always resurrected from the CVS -- or better yet, can
   be re-implemented.

 * Delete MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN, inlining it to the
   call-sites for easier understanding. (Yes, there is such a thing as
   too much abstraction.)

1.0.6.2: remove multiple layout-clos-hash slots

 * It seems that despite the claims of the paper "Efficient Method
   Dispatch in PCL" the multiple hash seeds yield a neglible benefit.

 * The soon-to-come thread safe cache also uses only a single hash
   value, so removing these now allows better performance comparisons:
   multiple hash values vs. single hash value vs. new cache.

 Actual work done mostly by Christophe Rhodes.

1.0.6.1: marginally nicer "name" for socket streams

 * "a socket" instead of "a constant string". It might be worth while
   to actually make this based on the socket-name and -peername,
   though.

1.0.6: release, will be tagged as sbcl_1_0_6

1.0.5.56: conditionally re-enable interrupts interrupting current thread

 * New variable: *IN-INTERRUPTION* is true IFF we're being called inside
   *IN-INTERRUPTION* and there are no intervening WITHOUT-INTERRUPTS.

 * INTERRUPT-THREAD calls the interrupt function inside WITH-INTERRUPTS
   when interrupting the current thread IFF *IN-INTERRUPTION* is true.

 * Remove bogus FIXME by yours truly from INVOKE-INTERRUPTION and
   properly explain what is going on -- and add another FIXME in its
   place.

 This makes nested SIGINTs DTRT.

1.0.5.55: interrupt safe REFILL-BUFFER/FD

 * Check for blocking / wait for new input before touching the stream.

 * Check that the SAP is still there after the wait, in case an interrupt
   handler or an FD handler closed the stream from under us.

 * Wrap the main action in WITHOUT-INTERRUPTS to prevent asynch unwinds
   from leaving the stream in an inconsistent state. (Since the read
   is going to be non-blocking it should be over soon enough.)

 * Arrange to signal errors outside the WITHOUT-INTERRUPTS.

1.0.5.54: fix thinko in src/code/array.lisp

* thanks to Eric Marsden

1.0.5.53: cleanup LOAD-TYPE macros

* when the LOAD-TYPE macros in the various backends hardcoded '3',
  they really meant (1- N-WORD-BYTES)--a little reflection on
  widetags, lowtags, and endian orderings should make this clear
  (we don't have a 64-bit big-endian port to drive it home, though);
* catch the spread of magic constants in code/array.lisp.

1.0.5.52: fix #!-sb-unicode build problems on x86-64

* just a few uncopied things from the x86 version...

1.0.5.51: fixed mixed up commit 1.0.5.50

 * SIMPLE-VECTOR-COMPARE-AND-SWAP, not SAFE-SIMPLE-VECTOR-COMPARE-AND-SWAP.

 * Missing tests.

 * Whitespace.

 * foreign.test.sh jugglery

   This path breaks foreign.test.sh on x86/Darwin even without
   touching it, indicative of still lingering Darwin issues. Any
   number of changes can mask this breakage: adding SAFE- prefix to
   SIMPLE-VECTOR-COMPARE-AND-SWAP is enough to make foreign.test.sh
   pass again, but so is adding a sneaky --eval nil in there as well
   -- among other things.

   Pain. Hate. Pain. See commentary in foreign.test.sh

   This time the issue doesn't seem to be foreign stack alignment
   related, though: forcing the compiler to use the fast call-out path
   always doesn't make the "small" case pass.

1.0.5.50: some compare-and-swap changes

 * Since we have a non-threaded %INSTANCE-COMPARE-AND-SWAP on all
   platforms, define DEFINE-STRUCTURE-SLOT-COMPARE-AND-SWAP on
   non-threaded builds as well.

 * Bounds checking SIMPLE-VECTOR-COMPARE-AND-SWAP, plus tests.

1.0.5.49: interrupt & GC & PA handling

 * On all FOREIGN_FUNCTION_CALL_FLAG platforms arch_pseudo_atomic_atomic is
   always accompanied by !foreign_function_call_active.

   For clarity move checking it to the a_p_a_a definitions on platforms that
   need it.

   TEST ALERT: This touches all the non-x86oid platforms, but I have
   not been able to test on them -- so a thinko/typo build-breakage is
   not impossible.

 * If we somehow ended up in interrupt_handle_pending in the middle of a PA
   section we might GC in the middle of it, or lose PA interrupted flags.

   Now we punt straight up if we get there in the middle of PA.

 * If we handled a pending interrupt outside GC-INHIBIT, but inside a PA
   section, with both GC_PENDING and SIG_STOP_FOR_GC_PENDING was true, we
   would be left running with GC_PENDING cleared without actually taking any
   action.

   The previous item actually fixes this, but for clarity make
   sig_stop_for_gc_handler clear the GC_PENDING and SIG_STOP_FOR_GC_PENDING
   iff it actually stops the thread.

 * The single UWP implementation for WITHOUT-GCING was incorrect: if
   we had a GC but no interrupts pending when checking for pending
   interrupts and GCs, and caught an asynch unwind at that point we
   could be left running with the GC pending (and/or related signals
   blocked).

   Due to the increased cost of WITHOUT-GCING, check first if GC is
   already disabled before taking the UWP code path.

1.0.5.48: Git friendly clean.sh

 * Ignore .git.

1.0.5.47: cacheability of EMFs from methods with non-standard specializers
... the second return value from
COMPUTE-APPLICABLE-METHODS-USING-CLASSES promises that the
first return value can be cached.  It doesn't promise that an
arbitrary computation on the specializers will work, so we need
not to go down that codepath.
... so refuse to build dispatch discriminating functions if any
method of the generic function has a non-standard
        (non-PCL-native) specializer, as operations such as
SB-PCL::SPECIALIZER-CLASS and SB-PCL::TYPE-FROM-SPECIALIZER
will fail on such specializers
... rework SPECIALIZER-CLASS-OR-NIL to call the new function
STANDARD-SPECIALIZER-P.
... test case.

1.0.5.46: improve handling of non-standard subclasses of SB-MOP:SPECIALIZER
... define SPECIALIZER-CLASS-OR-NIL for use in RAISE-METATYPE,
and adjust RAISE-METATYPE to handle NIL return values.
... add commentary around RAISE-METATYPE to explain what all the
metatypes actually mean.
... EMIT-FETCH-WRAPPER was missing a CONDITION-INSTANCE case,
and further drew fine distinctions where there were none...
... so delete BUILT-IN-OR-STRUCTURE-WRAPPER, and call WRAPPER-OF
instead.  (But leave in the GC safety bug reported sbcl-devel
2007-05-10.)
... one more fix to PARAMETER-SPECIALIZER-DECLARATION-IN-DEFMETHOD
for CLASS-EQ specializers on built-in-classes.

1.0.5.45: metatypes-related refactor
Many of the dlisp functions took (metatypes applyp) arguments,
when in fact all they were using was the length of the metatypes
argument and the applyp boolean.  Make this explicit, to assist
in understanding when the identity of metatypes actually
matters.

1.0.5.44: fix reading of a suppressed #. in sb-cover

         * Suppressing of #. in the source location recording read-table was
           implemented incorrectly. (Reported by James Knight)
         * Don't silently ignore read errors.
         * Use a dummy source location map for top level forms for which
           an error was signaled, rather than NIL. Otherwise the compiler's
           and sb-cover's tlf numbering could get out of sync.

1.0.5.43: change memory layout on FreeBSD

* Move read-only-space and neighbours to lower space to avoid
  potential conflicts with runtime user space.

* Move dynamic-space to higher space so that kern.maxdsiz can be
  increased at least 1GB.

Brief memory layout of FreeBSD:

+------------+ -- 0x00000000
|    free    |
+------------+ -- 0x08000000
| user space |
+------------+ -- brk (grows downward)
~            ~
+------------+ -- 0x28000000 (0x08000000 + maxdsiz)
| mmap,shlib |
~            ~
+----------- + -- stack top (grows upward)
| stack space|
+------------+ -- 0xC0000000
|   kernel   |
+------------+ -- 0xFFFFFFFF

1.0.5.42: fix (setf aref) on single-float vectors

          Obvious patch by Christophe, reported by Eric Marsden.

10.\7f\7fCVS: ----------------------------------------------------------------------

1.0.5.40: probably fix win32 build

         * sb!unix::micro-seconds-per-internal-time-unit was defined in a
           #-win32 block
         * Reported by Yaroslav Kavenchuk

1.0.5.39: sb-sprof call counting

         * Add support for deterministically tracking the amount of times
           that certain functions were called during a sb-sprof profiling
           run.
         * The goal is to allow people to easily see whether a lot of time
           is spent in function X due to it being called often, or due to
           the average call being slow.
         * The benefit over using sb-profile is that a) the reporting
           of the call counts is integrated into the normal sb-sprof
           interface and b) there's a lot less overhead, since we're just
           counting calls, not tracking cpu usage / consing.

1.0.5.38: PCL cache-lookup code emission refactoring

 * Pass cache-variable name explicitly to EMIT-DLAP.

 * Use a gensym for the miss-tag.

 * Factor cache lookup code emission to a separate function EMIT-CACHE-LOOKUP.

1.0.5.37: cleanup a small thinko from previous x86-assem.S refactoring

 * EBP is available to use in ALLOC, so use it.

1.0.5.36: x86 allocation cleanup

 * Ensure stack alignmenment on calls to alloc() on Darwin.

 * Ensure that DF is cleared on calls to alloc().

 * Preprocessorize the alloc_foo definitions.

1.0.5.35: stack alignment on x86/Darwin, once more

 * Stack alignment cannot be changed after arguments have been pushed
   on stack: ALLOCATE-NUMBER-STACK-SPACE is the place to do this, and
   nowhere else.

 * Use the RESET-STACK-POINTER logic on all x86 platforms for
   simplicity.

 * Factor out the alignment logic to ALIGN-STACK-POINTER.

 * Clear DF unconditionally when calling out, which means that Solaris
   doesn't need to switch it back and forth. (Darwin, Solaris, and Win32
   all need DF cleared for call-out.)

1.0.5.34: faster STRING-TO-OCTETS for unibyte and UTF-8 encodings

* redo DEFINE-UNIBYTE-MAPPER to use a lookup table instead of
  a big CASE statement (optimizes for the common (?) case of
  mostly ASCII characters and gives smaller code);
* STRING->LATIN% now optimistically assumes that there are
  no encoding errors in the string and allocates an
  appropriately-sized octet vector upfront, falling back to
  the slower path if an encoding error is detected;
* do more or less the same thing for UTF-8 encoding, except
  that there is no slow path (since UTF-8 can encode all
  characters, unlike unibyte encodings)
* we have a ton of external formats; use a hash table for
  *EXTERNAL-FORMAT-FUNCTIONS* rather than a list to cut down
  on lookup time (this alone is worth ~10% without the other
  optimizations above...).

Code cleanups:

* use string package names like every other source file;
* properly separate function names from arglists;
* don't pass END parameters when we don't use them.

End result is ~20-30x speedup for unibyte encodings (depending
        on the encoding--LATIN-1 is ~20x, whereas something like CP857
        is ~30x) when encoding ASCII strings; smaller but still
        significant speedups when encoding non-ASCII strings.  UTF-8
        encoding is ~5-6x faster, which also means that we're faster
        than TRIVIAL-UTF-8 for encoding now (decoding is an entirely
        different matter).

1.0.5.33: fix botched commit 1.0.5.32: partial fix for DISASSEMBLE buglet

  * Test for >= length, not > length.

  * Record the remaining WARNING in BUGS.

1.0.5.32: partial fix for DISASSEMBLE bug reported by Peter Graves

  * Test for >= length, not > length.

  * Record the remaining WARNING in BUGS.

1.0.5.31: Make sb-introspect's FUNCTION-ARGLIST safer
... less likely to read off some random word in memory
as an arglist.

1.0.5.30: small PCL re-organization
 * Move some non-cache code from src/pcl/cache.lisp to wrapper.lisp and
   dlisp.lisp.

 No functional changes.

1.0.5.29: fix a race-condition in deadline.impure.lisp
 * The thread that is supposed to hold the mutex might no yet have
   grabbed it.

1.0.5.28: new contrib: sb-cover, a code coverage tool

         Still somewhat experimental, so it might be changed incompatibly once
         people start actually using it. Or maybe even removed, if it's not
         found to be useful in practice. More documentation on interpreting
         the output and on the limitations of the coverage tool will be
         committed later.

         * Compiler
           * Instrument all forms found in the original source code
             when the store-coverage-data optimization quality is larger
             than 1.
           * The instrumentation is fairly lightweight; just literal conses that
             are modified when the form is executed.
           * This requires hacking the compiler to allow modifying literals
             when we know what we're doing.
           * Add some extra source location tracking capabilities to handle
             non-cons source forms better (though still not perfectly).
         * Contrib
           * Get the instrumentation data from the compiler, and create
             a aggregate report + pretty annotate source code reports
             (as html) from it.
           * The latter uses a modified version of the source code tracking
             read-table from Swank, written by Helmut Eller.

1.0.5.27: Stepper support for MIPS.

1.0.5.26: Whitespacing.

1.0.5.25:
Fix argument signedness format.

1.0.5.24:
Silence compiler warning.

1.0.5.23:
Fix spelling.

1.0.5.22:
Delete obsolete depends: dummy target.

1.0.5.21:
Code formatting.

1.0.5.20: make class-eq specializers work in defmethods
Mostly for consistency: this is not an exported extension or
anything.  But it was gratuitously broken before, and it was
also broken in ways preventing user-defined specializers from
working.  So fix it and test it, with a comment saying that it's
OK to break it deliberately.

(User-defined specializers do not currently work, even after
this change.)

1.0.5.19: restore building on cmucl 19a-ish
... sb!xc:macroexpand in code seen by the host compiler.  (Said
code was never executed by the host compiler, because of
the return value of fopcompileable-p)

1.0.5.18: trapping-based stepper on the Sparc
... implement instrumentation for :before and :around cases;
... as suggested by Juho, use NTH-INTERRUPT-CONTEXT rather than
allocating a SAP in a signal handler;
... actually run the tests on sparc too.

1.0.5.17: Top-level DECLARE signals an error
... probably the user meant a top-level DECLAIM, but in the
absence of proof an error is a decent choice for undefined
behaviour.

1.0.5.16: Follow the change of linux-os.c:futex_wait().

1.0.5.15: fix SB-BSD-SOCKETS tests on chrooted NetBSD

         * Handle dangling /dev/log symlink
         * Patch by Richard Kreuter

1.0.5.14: make PURIFY a no-op on gencgc

         * Purification doesn't really make any sense with gencgc, since we
           have an uncollected generation with a write barrier these days.
         * Apparently it had also bitrotted on ppc/gencgc between 1.0.0 and
           1.0.4, causing crashes with software doing (SAVE-LISP-AND-DIE
           ... :PURIFY T), for example Maxima. (Reported by Rex Dieter)
         * So make PURIFY a no-op on gencgc, and remove about 600 lines worth of
           #ifdeffed OAOO violations from purify.c.
         * Allows shrinking the static and read-only spaces into something
           sensible (arbitrary value of 1MB selected), and moving all of them
           closer together to reduce the virtual address space footprint.
         * Move + shrink the linkage-table while we're at it.

1.0.5.13: better wordbreaks in manual
Patch from Richard Kreuter, sbcl-devel 2006-12-22

Also fix the Gray input stream example to inherit from an input
stream rather than from an output stream.

1.0.5.12: fix threaded Linux builds

 * Undo merge damage: missed one COMPARE-AND-EXCHANGE -> COMPARE-AND-SWAP rename.

1.0.5.11: fix non-threaded build

 * SIG_STOP_FOR_GC only on threaded platforms.

 * GET-MUTEX was broken for non-threaded builds.

1.0.5.10: interrupt-proofing SUB-GC

 * When SUB-GC is entered with GC and interrupts enabled we cannot just
   blithely set *GC-PENDING*, as unwinding from an interrupt would cause
   us to run with GC blocked for an unbounded time: disable interrupts
   before setting it.

1.0.5.9: experimental semi-synchronous deadlines

 * WITH-DEADLINE provides an interface to a synchronous deadline/timeout
   facility that can interrupt execution only on blocking IO and when
   waiting on locks (latter Linux only for now.)

 * DECODE-DEADLINE provides an interface that implementors of blocking
   functions can use to hook into the deadline mechanism.

 * Add SB-IMPL::*ON-DANGEROUS-SELECT* for debugging: can be used to
   warn/ signal an error / obtain a backtrace when SBCL calls select
   without a timeout while interrupts are disabled.

 * Undocumented and unexported periodic polling functionality has been
   removed from SERVE-EVENT, but can be reinstated should it be
   desired.

1.0.5.8: always display package prefixes when symbols conflict

* Patch by Kevin Reid, sbcl-devel 2007-04-28.

1.0.5.7: missing test case for 1.0.4.40

 * Also add a test-case for the bad type declatation fixed in PCL in
   1.0.4.40.

1.0.5.6: compare-and-swap / instance-set-conditional refactoring

 * Rename *-COMPARE-AND-EXCHANGE *-COMPARE-AND-SWAP.

 * DEFINE-FULL-COMPARE-AND-SWAP, use it to implement
   %INSTANCE-COMPARE-AND-SWAP (previously %INTANCE-SET-CONDITIONAL) on x86oids.

 * Implement %SIMPLE-VECTOR-COMPARE-AND-SWAP. Not used right now, but required
   by a forthcoming patch.

 * Implement non-x86oid (non-threaded) versions of the above.

 * Check that the slot isn't raw in DEFINE-STRUCURE-SLOT-COMPARE-AND-SWAP.

 * Whitespace.

1.0.5.5: &ENVIRONMENT fixes

 * Place the binding for &ENVIRONMENT in the correct scope for
   ignore declarations.

 * Place the local-decls return value from PARSE-DEFMACRO in the
   right scope in DEFSETF.

 * Tests.

1.0.5.4: signal handler consing causing GCs

 * Skip GC attempt if interrupts are enabled but GC signals are
   blocked in the context we would restore.

   This can happen at least when a signal handler conses while GC
   signals are blocked, so what we take a PendingInterrupt trap while
   in the original handler.

1.0.5.3: compiling a SUBSEQ on a SIMPLE-VECTOR should not give notes

 * One type declaration, one TRULY-THE, and two test-cases.

1.0.5.2: non-racy WITH-SPINLOCK-AND-WITHOUT-GCING

 * It used to be possible for an interrupt or a GC request to come
   in during the small window after RECEIVE-PENDING-INTERRUPTS, but
   while we were running with interrupts and GC disabled. This would
   leave it pending and block further ones -- without any guarantee
   when the next one would come in.

   Experimentally this could also deadlock GC, but the code path
   leading to that is not entirely clear.

 * WITHOUT-GCING can be implemented by using just a single UWP, so do
   it like that.

1.0.5.1: remove ldso-stubs.S in clean.sh
(patch from Timothy Ritchey sbcl-devel 2007-04-26)

1.0.5:
release, will be tagged as sbcl_1_0_5

1.0.4.111: NEWS editing

 * Hash-table functions aren't quite interrupt safe yet, aka brutal honesty.

 * Missing dots.

1.0.4.110: make -sb-unicode builds work again

* SB!VM:COMPLEX-CHARACTER-STRING-WIDETAG is not bound when #!-sb-unicode

1.0.4.109: rewrite source that mixed quasiquotes and circular lists

         * CLisp didn't like the combination, use a macrolet instead
         * Patch by Luis Oliveira

1.0.4.108: turn mach-exception-handler on for macos/x86 and x86_64
 * have make-config.sh add mach-exception-handler to the features by
   default. This gets around the CrashReporter problems and enables
   debugging of SBCL processes with GDB.

1.0.4.107: fix doc/make-doc.sh if "make" command is not GNU make.

First build problem found by James Knight's BuildBot. :-)

1.0.4.106: refactoring FILE-POSITION on FD-STREAMS, some cleanups

 * Make the underlying FILE-POSITION on FD-STREAMs interrupt-safe.
   This is not enough to make FILE-POSITION on FD-STREAMs interrupt
   safe, as the ANSI-STREAM layer is not -- or at least I doesn't look
   like it to me.

 * Split FD-STREAM-FILE-POSITION into two parts for easier reading,
   and make the error behaviour more ANSI compliant.

 * Move FLUSH-OUTPUT-BUFFER to FINISH-FD-STREAM-OUTPUT to make it a
   one-stop-shopping implementation of finish-output for FD-STREAMs.

 * New function: FD-STREAM-OUTPUT-FINISHED-P, which returns false if
   there is any pending output on the stream.

 * Add comments explaining why certain VECTOR-SAP usages are safe
   without pinning the vector -- at least on x86oids.

 * Instead of (IF #-WIN32 P #+WIN32 T #-WIN32 THEN #+WIN32 ELSE),
   let us use #-WIN32 ELSE #+WIN32 (IF P THEN ELSE)...

1.0.4.105: remove clisp from the list of working build hosts

         * It's not like it's actually worked for anyone in ages, but
           people keep trying to use it...

1.0.4.104: don't mutate constant strings in genesis

         * CLisp rightfully complains about this when used as a build host

1.0.4.103: fix build with OpenMCL as the host

         * OpenMCL doesn't do the right thing with #+foo #+foo bar bar
         * An invalid slot type declaration

1.0.4.102: SB-SYS and stream cleanups

 * Factor out looping on SERVE-ALL-EVENTS to FINISH-FD-STREAM-OUTPUT.

 * Make IO-TIMEOUT a subclass of TIMEOUT.

 * Remove spurious SB!SYS: prefixes from src/code/stream.lisp and
   fd-stream.lisp.

 * Delete stale symbols ALLOCATE-SYSTEM-MEMORY-AT, C-PROCEDURE,
   POINTER, POINTER>, POINTER<, SERVER, SERVER-MESSAGE, and
   WITH-ENABLED-INTERRUPTS from SB-SYS. (Also delete commented out
   implementation of W-E-I in target-signal.lisp.)

1.0.4.101: new STRING-OUTPUT-STREAM implementation

 * Instead of copying the output string each time we need to expand
   it, maintain a chain of buffers. For large inputs the improvement
   is vast, for small inputs the performance characteristics are
   essentially the same. One the average seems to cons about 30% less.

1.0.4.100: gray streams manual fixes

         * From Richard Kreuter

1.0.4.99: fix big-endian build

         * Reported by Harald Hanche-Olsen

1.0.4.98: Win32 build fix
  * Win32 doesn't do sigaltstack, and thus has no SIGSTKSZ.

1.0.4.97: Oops. Fix bug introduced in x86 vop if-eq in 1.0.4.73.

1.0.4.96: oops, missed one case in the HAIRY-DATA-VECTOR-REF changes

        * SIMPLE-STRING is a special case in EXTRACT-UPGRADED-ELEMENT-TYPE

1.0.4.95: small genesis cleanups

 * Factor most of the logic to munge lisp-names to C-names into C-NAME
   and C-SYMBOL-NAME.

   Also translate #\/ to #\_, fixing duplicate definition warnings for
   static-symbols.h.

1.0.4.94 make-target-contrib.sh self-announcement
    * patch by Yaroslav Kavenchuk

1.0.4.93: backtrace_from_fp

        * Split the ldb x86oid backtrace into two parts (backtrace and
          backtrace_from_fp), to make debugging e.g. thread deadlocks
          from gdb easier. For example: call backtrace_from_fp($rbp, 10)

1.0.4.92: faster generic array access

        * Replace the typecase-based HAIRY-DATA-VECTOR-* with a table-driven
          dispatch on widetags
        * Move bounds checking of one-dimension AREFs into HAIRY-DATA-VECTOR-*
          from the caller, so that we can avoid doing a full ARRAY-DIMENSION
          in the common case.
        * 3-5x speedup on generic array accesses