code/bit-bash.lisp::
 Add {{{BYTE-BASH-COPY}}} for copying bytes

code/exports.lisp::
 Add {{{BYTE-BASH-COPY}}}

compiler/generic/vm-fndb.lisp::
 Add {{{BYTE-BASH-COPY}}}

compiler/generic/vm-tran.lisp::
 Call {{{BYTE-BASH-COPY}}} in the deftransform for {{{REPLACE}}}.

Check that the start and end indices make sense for the given
strings.  This is important before we start bashing random parts of
the string, potentially overwriting other objects.

This fixes the immediate issue, but there are still problems with
very long strings.  The bit-index for such strings won't fit in an
(unsigned-byte 32).

vm-fndb.lisp:
o Correct the defknown to have the correct arg types (vm::offset
  instead of index).

vm-tran.lisp:
o Update deftransform to use vm::offset instead of index.

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.)

may get confused with source locations if the reader macros are
installed.

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.

add zero so that they behave exactly like the sxhash function in
hash-new.lisp.

unicode-utf16-extfmt-2009-06-11.

branches.

compiler/generic/vm-tran.lisp:
o On sparc and ppc, make the abs deftransform give up for 32-bit
  integers, to give the VOP a chance.

compiler/ppc/arith.lisp:
o Add vop for abs for (signed-byte 32).

when the length of the vector was a multiple of 32.

deftransforms.  This causes a warning to be produced for

   (defun foo (f d)
     (declare (type (simple-array single-float (*)) f)
              (type (simple-array double-float (*)) d))
     (setf (aref f 0) (aref d 0)))

(from Lynn Quam, cmucl-imp 2004-03-30).  Previously, no warning was
produced and all code including the function return was deleted.  Now
a warning is produced and the code is not deleted.

This is a workaround.

boot6-sxhash to bootstrap this change for ppc.

computation.

symbol.

zero on creation, and is computed when sxhash is called, which is then
cached.

on sparc.

using division to multiplication by a magic multiplier.  (From
Hacker's Delight on signed and unsigned division.)

	  (let* ((string (symbol-name symbol))
		 (length (length string)))
	    (if (or (< length 3)
		    (not (char= (elt string 0) #\*))
		    (not (char= (elt string (1- length)) #\*)))
		(error "Symbol does not follow dynamic conventions.")
		(if prefix
		    (intern (cs prefix (subseq string 1 (1- length))))
		    (intern (subseq string 1 (1- length)))))))
	 => spurious code deletion note that goes away when the local
	    variable length is renamed to something else.

	* src/compiler/generic/vm-tran.lisp (subseq, copy-seq) <deftransform>:
	Use len as local variable name instead of cl:length.

array-element-type-treated-as-declaration

wherein the compiler believes type declarations on array elements
without checking them, e.g.

	(DECLAIM (OPTIMIZE (SAFETY 3) (SPEED 1) (SPACE 1)))
	(DEFSTRUCT FOO A B)
	(DEFUN BAR (X)
	  (DECLARE (TYPE (SIMPLE-ARRAY CONS 1) X))
	  (WHEN (CONSP (AREF X 0))
	    (PRINT (AREF X 0))))
	(BAR (VECTOR (MAKE-FOO :A 11 :B 12)))

prints a structure out.

This patch makes the compiler use the specialized (upgraded) element
type instead of the declared element type for aref.

check the length of the result matches the sequence type length, if
given.

bit-operations deftransforms, which occurred for bit-vectors of sizes near
the ARRAY-DIMENSION-LIMIT.  The fix is based on the corresponding changes
by Christophe Rhodes in version 0.7.3.5 of the corresponding file in the
SBCL CVS repository.

around the problem with the original version wherein the compiler
spends huge amounts of time deriving the type of the START variable.

if necessary. This then allows the inlining of the simple-array accessor
which may reduce consing and may give better performance overall.

subseq transform, limiting the :end to the string length and the
:start to the :end.

It is typically better not the throw away bits of the key, and the
hash may be a 29 bit unsigned fixnum. Similarly modify sxmash to use
all 29 bits rather than just 26 bits.

to be compiled to fast native code, and to make use of the sign bit.
Fix and update the sxhash double-float transform to be consistent.
Add a transform for the sxhash of long-floats.

if the dimensions are not known, in which case inline a check for an
array header and if so get the array data vector; from Juan Jose
Garcia Ripoll.