From: William Harold Newman <william.newman@airmail.net>
Date: Thu, 8 Feb 2001 15:08:37 +0000 (+0000)
Subject: 0.6.10.13:
X-Git-Url: http://repo.macrolet.net/gitweb/?a=commitdiff_plain;h=4fc9d21ae1d8a6a2f8ff70f589d5da103203de13;p=sbcl.git

0.6.10.13:
	fixed problems reported by Douglas Brebner 2000-01-01..
	make.sh and friends now use foo/bar instead of foo/bar/ to
		specify directories, since foo/bar/ fails on NetBSD.
	(SETF ALIEN:EXTERN-ALIEN) works (instead of dying with
		undefined function SB-KERNEL:%SET-SAP-REF-32).
---

diff --git a/BUGS b/BUGS
index ddd6bf7..68cbee7 100644
--- a/BUGS
+++ b/BUGS
@@ -411,6 +411,9 @@ returning an array as first value always.
   so that (TYPEP (MAKE-ARRAY 3) '(VECTOR SOMETHING-NOT-DEFINED-YET))
   returns (VALUES T T). Probably it should be an error instead,
   complaining that the type SOMETHING-NOT-DEFINED-YET is not defined.
+  Or perhaps UPGRADED-ARRAY-ELEMENT-TYPE should just fail when a type
+  isn't defined yet. (What if the definition of
+  SOMETHING-NOT-DEFINED-YET turns out to be SINGLE-FLOAT?) 
 
 41:
   TYPEP of VALUES types is sometimes implemented very inefficiently, e.g. in 
diff --git a/clean.sh b/clean.sh
index b72ce64..4c055de 100755
--- a/clean.sh
+++ b/clean.sh
@@ -13,10 +13,10 @@
 # this script (including "gmake clean" in the src/runtime directory)
 # several times in a row without failure.. so we leave the output/
 # directory in place.)
-rm -rf obj/* output/* doc/user-manual/ \
-  doc/user-manual.junk/ doc/DBTOHTML_OUTPUT_DIR*
-# (The doc/user-manual.junk/ and doc/DBTOHTML_OUTPUT_DIR* directories
-# are created when the Cygnus db2html script when it formats the the
+rm -rf obj/* output/* doc/user-manual \
+  doc/user-manual.junk doc/DBTOHTML_OUTPUT_DIR*
+# (The doc/user-manual.junk and doc/DBTOHTML_OUTPUT_DIR* directories
+# are created by the Cygnus db2html script when it formats the the
 # user manual, and since this db2html script is the one which is
 # currently used to format the manual for the standard binary
 # distribution, we automatically clean up after it here in the 
diff --git a/src/code/target-sap.lisp b/src/code/target-sap.lisp
index 56f0789..b63c33d 100644
--- a/src/code/target-sap.lisp
+++ b/src/code/target-sap.lisp
@@ -9,152 +9,129 @@
 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
 ;;;; files for more information.
 
-(in-package "SB!SYS")
-;;; FIXME: Shouldn't these be IN-PACKAGE SB!KERNEL instead? (They're
-;;; not dependent on the OS, only on the CPU architecture.)
+(in-package "SB!KERNEL")
 
 ;;;; primitive SAP operations
 
+;;; Return T iff the SAP X points to a smaller address then the SAP Y.
 (defun sap< (x y)
-  #!+sb-doc
-  "Return T iff the SAP X points to a smaller address then the SAP Y."
   (declare (type system-area-pointer x y))
   (sap< x y))
 
+;;; Return T iff the SAP X points to a smaller or the same address as
+;;; the SAP Y.
 (defun sap<= (x y)
-  #!+sb-doc
-  "Return T iff the SAP X points to a smaller or the same address as
-   the SAP Y."
   (declare (type system-area-pointer x y))
   (sap<= x y))
 
+;;; Return T iff the SAP X points to the same address as the SAP Y.
 (defun sap= (x y)
-  #!+sb-doc
-  "Return T iff the SAP X points to the same address as the SAP Y."
   (declare (type system-area-pointer x y))
   (sap= x y))
 
+;;; Return T iff the SAP X points to a larger or the same address as
+;;; the SAP Y.
 (defun sap>= (x y)
-  #!+sb-doc
-  "Return T iff the SAP X points to a larger or the same address as
-   the SAP Y."
   (declare (type system-area-pointer x y))
   (sap>= x y))
 
+;;; Return T iff the SAP X points to a larger address then the SAP Y.
 (defun sap> (x y)
-  #!+sb-doc
-  "Return T iff the SAP X points to a larger address then the SAP Y."
   (declare (type system-area-pointer x y))
   (sap> x y))
 
+;;; Return a new SAP, OFFSET bytes from SAP.
 (defun sap+ (sap offset)
-  #!+sb-doc
-  "Return a new sap OFFSET bytes from SAP."
   (declare (type system-area-pointer sap)
 	   (fixnum offset))
   (sap+ sap offset))
 
+;;; Return the byte offset between SAP1 and SAP2.
 (defun sap- (sap1 sap2)
-  #!+sb-doc
-  "Return the byte offset between SAP1 and SAP2."
   (declare (type system-area-pointer sap1 sap2))
   (sap- sap1 sap2))
 
+;;; Convert SAP into an integer.
 (defun sap-int (sap)
-  #!+sb-doc
-  "Converts a System Area Pointer into an integer."
   (declare (type system-area-pointer sap))
   (sap-int sap))
 
+;;; Convert an integer into a SAP.
 (defun int-sap (int)
-  #!+sb-doc
-  "Converts an integer into a System Area Pointer."
   (declare (type sap-int-type int))
   (int-sap int))
 
+;;; Return the 8-bit byte at OFFSET bytes from SAP.
 (defun sap-ref-8 (sap offset)
-  #!+sb-doc
-  "Returns the 8-bit byte at OFFSET bytes from SAP."
   (declare (type system-area-pointer sap)
 	   (fixnum offset))
   (sap-ref-8 sap offset))
 
+;;; Return the 16-bit word at OFFSET bytes from SAP.
 (defun sap-ref-16 (sap offset)
-  #!+sb-doc
-  "Returns the 16-bit word at OFFSET bytes from SAP."
   (declare (type system-area-pointer sap)
 	   (fixnum offset))
   (sap-ref-16 sap offset))
 
+;;; Returns the 32-bit dualword at OFFSET bytes from SAP.
 (defun sap-ref-32 (sap offset)
-  #!+sb-doc
-  "Returns the 32-bit dualword at OFFSET bytes from SAP."
   (declare (type system-area-pointer sap)
 	   (fixnum offset))
   (sap-ref-32 sap offset))
 
+;;; Return the 64-bit quadword at OFFSET bytes from SAP.
 #!+alpha
 (defun sap-ref-64 (sap offset)
-  #!+sb-doc
-  "Returns the 64-bit quadword at OFFSET bytes from SAP."
   (declare (type system-area-pointer sap)
 	   (fixnum offset))
   (sap-ref-64 sap offset))
 
+;;; Return the 32-bit SAP at OFFSET bytes from SAP.
 (defun sap-ref-sap (sap offset)
-  #!+sb-doc
-  "Returns the 32-bit system-area-pointer at OFFSET bytes from SAP."
   (declare (type system-area-pointer sap)
 	   (fixnum offset))
   (sap-ref-sap sap offset))
 
+;;; Return the 32-bit SINGLE-FLOAT at OFFSET bytes from SAP.
 (defun sap-ref-single (sap offset)
-  #!+sb-doc
-  "Returns the 32-bit single-float at OFFSET bytes from SAP."
   (declare (type system-area-pointer sap)
 	   (fixnum offset))
   (sap-ref-single sap offset))
 
+;;; Return the 64-bit DOUBLE-FLOAT at OFFSET bytes from SAP.
 (defun sap-ref-double (sap offset)
-  #!+sb-doc
-  "Returns the 64-bit double-float at OFFSET bytes from SAP."
   (declare (type system-area-pointer sap)
 	   (fixnum offset))
   (sap-ref-double sap offset))
 
+;;; Return the LONG-FLOAT at OFFSET bytes from SAP.
 #!+(or x86 long-float)
 (defun sap-ref-long (sap offset)
-  #!+sb-doc
-  "Returns the long-float at OFFSET bytes from SAP."
   (declare (type system-area-pointer sap)
 	   (fixnum offset))
   (sap-ref-long sap offset))
 
+;;; Return the signed 8-bit byte at OFFSET bytes from SAP.
 (defun signed-sap-ref-8 (sap offset)
-  #!+sb-doc
-  "Returns the signed 8-bit byte at OFFSET bytes from SAP."
   (declare (type system-area-pointer sap)
 	   (fixnum offset))
   (signed-sap-ref-8 sap offset))
 
+;;; Return the signed 16-bit word at OFFSET bytes from SAP.
 (defun signed-sap-ref-16 (sap offset)
-  #!+sb-doc
-  "Returns the signed 16-bit word at OFFSET bytes from SAP."
   (declare (type system-area-pointer sap)
 	   (fixnum offset))
   (signed-sap-ref-16 sap offset))
 
+;;; Return the signed 32-bit dualword at OFFSET bytes from SAP.
 (defun signed-sap-ref-32 (sap offset)
-  #!+sb-doc
-  "Returns the signed 32-bit dualword at OFFSET bytes from SAP."
   (declare (type system-area-pointer sap)
 	   (fixnum offset))
   (signed-sap-ref-32 sap offset))
 
+;;; Return the signed 64-bit quadword at OFFSET bytes from SAP.
 #!+alpha
 (defun signed-sap-ref-64 (sap offset)
-  #!+sb-doc
-  "Returns the signed 64-bit quadword at OFFSET bytes from SAP."
   (declare (type system-area-pointer sap)
 	   (fixnum offset))
   (signed-sap-ref-64 sap offset))
diff --git a/src/cold/shared.lisp b/src/cold/shared.lisp
index 790caa5..96c9700 100644
--- a/src/cold/shared.lisp
+++ b/src/cold/shared.lisp
@@ -72,17 +72,18 @@
 
 ;;;; some tools
 
-;;; Take the file named X and make it into a file named Y. Sorta like UNIX, and
-;;; unlike Common Lisp's bare RENAME-FILE, we don't allow information
-;;; from the original filename to influence the final filename. (The reason
-;;; that it's only sorta like UNIX is that in UNIX "mv foo bar/" will work,
-;;; but the analogous (RENAME-FILE-A-LA-UNIX "foo" "bar/") should fail.)
+;;; Take the file named X and make it into a file named Y. Sorta like
+;;; UNIX, and unlike Common Lisp's bare RENAME-FILE, we don't allow
+;;; information from the original filename to influence the final
+;;; filename. (The reason that it's only sorta like UNIX is that in
+;;; UNIX "mv foo bar/" will work, but the analogous
+;;; (RENAME-FILE-A-LA-UNIX "foo" "bar/") should fail.)
 ;;;
-;;; (This is a workaround for the weird behavior of Debian CMU CL 2.4.6, where
-;;; (RENAME-FILE "dir/x" "dir/y") tries to create a file called "dir/dir/y".
-;;; If that behavior goes away, then we should be able to get rid of this
-;;; function and use plain RENAME-FILE in the COMPILE-STEM function
-;;; above. -- WHN 19990321
+;;; (This is a workaround for the weird behavior of Debian CMU CL
+;;; 2.4.6, where (RENAME-FILE "dir/x" "dir/y") tries to create a file
+;;; called "dir/dir/y". If that behavior goes away, then we should be
+;;; able to get rid of this function and use plain RENAME-FILE in the
+;;; COMPILE-STEM function above. -- WHN 19990321
 (defun rename-file-a-la-unix (x y)
   (rename-file x
 	       ;; (Note that the TRUENAME expression here is lifted from an
@@ -190,17 +191,6 @@
    (pathname obj)))
 (compile 'compile-stem)
 
-;;; basic tool for building other tools
-#+nil
-(defun tool-cload-stem (stem)
-  (load (compile-stem stem
-		      :src-prefix *src-prefix*
-		      :obj-prefix *host-obj-prefix*
-		      :obj-suffix *host-obj-suffix*
-		      :compile-file #'compile-file))
-  (values))
-#+nil (compile 'tool-cload-stem)
-
 ;;; other miscellaneous tools
 (load "src/cold/read-from-file.lisp")
 (load "src/cold/rename-package-carefully.lisp")
@@ -349,7 +339,7 @@
 ;;; (This function is not used by the build process, but is intended
 ;;; for interactive use when experimenting with the system. It runs
 ;;; the cross-compiler on test files with arbitrary filenames, not
-;;; necessarily in the source tree, e.g. in "/tmp/".)
+;;; necessarily in the source tree, e.g. in "/tmp".)
 (defun target-compile-file (filename)
   (funcall *in-target-compilation-mode-fn*
 	   (lambda ()
diff --git a/src/cold/warm.lisp b/src/cold/warm.lisp
index b759273..ac79fe5 100644
--- a/src/cold/warm.lisp
+++ b/src/cold/warm.lisp
@@ -27,7 +27,7 @@
 ;;;; do belong in cold load and will hopefully make it back there reasonably
 ;;;; soon). -- WHN 19991207
 
-(dolist (stem '(;; FIXME: The files here from outside the src/pcl/ directory
+(dolist (stem '(;; FIXME: The files here from outside the src/pcl directory
 		;; probably belong in cold load instead of warm load. They
 		;; ended up here as a quick hack to work around the
 		;; consequences of my misunderstanding how ASSEMBLE-FILE works
diff --git a/src/pcl/env.lisp b/src/pcl/env.lisp
index 90c8f38..dec5e0b 100644
--- a/src/pcl/env.lisp
+++ b/src/pcl/env.lisp
@@ -28,7 +28,7 @@
 ;;; FIXME: This stuff isn't part of the ANSI spec, and isn't even
 ;;; exported from PCL, but it looks as though it might be useful,
 ;;; so I don't want to just delete it. Perhaps it should go in
-;;; a contrib/ directory eventually?
+;;; a "contrib" directory eventually?
 
 #|
 ;;; TRACE-METHOD and UNTRACE-METHOD accept method specs as arguments. A
diff --git a/stems-and-flags.lisp-expr b/stems-and-flags.lisp-expr
index 0cbd283..7e947a4 100644
--- a/stems-and-flags.lisp-expr
+++ b/stems-and-flags.lisp-expr
@@ -31,7 +31,7 @@
 ;;; FIXME: Perhaps now that a significant number of files are built
 ;;; in warm load instead of cold load, this file should now be called
 ;;; cold-stems-and-flags.lisp-expr? Also, perhaps this file should move
-;;; into the src/cold/ directory?
+;;; into the src/cold directory?
 (
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;; miscellaneous
diff --git a/tests/alien.impure.lisp b/tests/alien.impure.lisp
new file mode 100644
index 0000000..94315cd
--- /dev/null
+++ b/tests/alien.impure.lisp
@@ -0,0 +1,27 @@
+;;;; This file is for compiler tests which have side effects (e.g.
+;;;; executing DEFUN) but which don't need any special side-effecting
+;;;; environmental stuff (e.g. DECLAIM of particular optimization
+;;;; settings). Similar tests which *do* expect special settings may
+;;;; be in files compiler-1.impure.lisp, compiler-2.impure.lisp, etc.
+
+;;;; This software is part of the SBCL system. See the README file for
+;;;; more information.
+;;;;
+;;;; While most of SBCL is derived from the CMU CL system, the test
+;;;; files (like this one) were written from scratch after the fork
+;;;; from CMU CL.
+;;;; 
+;;;; This software is in the public domain and is provided with
+;;;; absolutely no warranty. See the COPYING and CREDITS files for
+;;;; more information.
+
+(cl:in-package :cl-user)
+
+;;; In sbcl-0.6.10, Douglas Brebner reported that (SETF EXTERN-ALIEN)
+;;; was messed up so badly that trying to execute expressions like
+;;; this signalled an error.
+(setf (sb-alien:extern-alien "gencgc_oldest_gen_to_gc" sb-alien:unsigned)
+      (sb-alien:extern-alien "gencgc_oldest_gen_to_gc" sb-alien:unsigned))
+
+;;; success
+(quit :unix-status 104)
diff --git a/tests/pathnames.impure.lisp b/tests/pathnames.impure.lisp
index 51ceb80..4afbba0 100644
--- a/tests/pathnames.impure.lisp
+++ b/tests/pathnames.impure.lisp
@@ -56,7 +56,7 @@
 ;;; handle the following case exactly (otherwise we get an error:
 ;;; "#'IDENTITY CALLED WITH 2 ARGS."
 (setf (logical-pathname-translations "demo2")
-        '(("test;**;*.*" "/tmp/demo2/test/")))
+        '(("test;**;*.*" "/tmp/demo2/test")))
 (enough-namestring "demo2:test;foo.lisp")
 
 ;;; When a pathname comes from a logical host, it should be in upper
diff --git a/version.lisp-expr b/version.lisp-expr
index 105efcb..8c7d29b 100644
--- a/version.lisp-expr
+++ b/version.lisp-expr
@@ -15,4 +15,4 @@
 ;;; versions, and a string like "0.6.5.12" is used for versions which
 ;;; aren't released but correspond only to CVS tags or snapshots.
 
-"0.6.10.12"
+"0.6.10.13"