0.6.8.3: added CODE-COMPONENT slot for NO-DEBUG-INFO condition

.cvsignore

@@ -1,4 +1,5 @@
 obj
 output
 ChangeLog
+customize-target-features.lisp
 local-target-features.lisp-expr

INSTALL

@@ -100,10 +100,18 @@ To build the system binaries:
   2. If the GNU make command is not available under the name "gmake",
      then define the environment variable GNUMAKE to a name where it can
      be found.
-  3. If you like, you can edit the base-target-features.lisp-expr file
-     to customize the resulting Lisp system. By enabling or disabling
-     features in this file, you can create a smaller system, or one
-     with extra code for debugging output or error-checking or other things.
+  3. If you like, you can tweak the *FEATURES* set for the resulting
+     Lisp system, enabling or disabling features like documentation
+     strings or extra debugging code. The preferred way to do this is
+     by creating a file "customize-target-features.lisp", containing
+     a lambda expression which is applied to the default *FEATURES*
+     set and which returns the new *FEATURES* set, e.g.
+	(LAMBDA (LIST)
+	  (ADJOIN :SB-SHOW
+		  (REMOVE :SB-DOC
+			  LIST)))
+     (This is the preferred way because it lets local changes interact
+     cleanly with CVS changes to the main, global source tree.)
   4. Run "sh make.sh" in the same directory where you unpacked the 
      tarball. If you don't already have a SBCL binary installed
      as "sbcl" in your path, you'll need to tell make.sh what Lisp

NEWS

@@ -529,6 +529,13 @@ changes in sbcl-0.6.9 relative to sbcl-0.6.8:
 * The debugger now handles errors which arise when trying to print
   *DEBUG-CONDITION*, so that it's less likely to fall into infinite
   regress.
+* The build system now uses an additional file, customize-target-features.lisp,
+  to allow local modifications to the target *FEATURES* list. (The point of
+  this is that now I can set up a custom configuration, e.g. with :SB-SHOW
+  debugging features enabled, without having to worry about propagating it
+  into everyone's system when I do a "cvs update".) When no
+  customize-target-features.lisp file exists, the target *FEATURES* list
+  should be constructed the same way as before.
 ?? signal handling reliability
 ?? fixed some bugs mentioned in the man page:
   ?? DEFUN-vs.-DECLAIM

base-target-features.lisp-expr

@@ -187,7 +187,7 @@
  ; :propagate-float-type
 
  ;; According to cmu-user.tex, this enables the compiler to infer result
- ;; types for mathematical functions a la SQRT, EXPT, and LOG, allowing
+ ;; types for mathematical functions like SQRT, EXPT, and LOG, allowing
  ;; it to e.g. eliminate the possibility that a complex result will be
  ;; generated.
  ;;

src/code/byte-interp.lisp

@@ -277,7 +277,7 @@
 ;;; FIXME: This doesn't seem to be needed in the target Lisp, only
 ;;; at build-the-system time.
 ;;;
-;;; KLUDGE: This expands into code a la
+;;; KLUDGE: This expands into code like
 ;;; (IF (ZEROP (LOGAND BYTE 16))
 ;;;     (IF (ZEROP (LOGAND BYTE 8))
 ;;;	 (IF (ZEROP (LOGAND BYTE 4))

src/code/class.lisp

@@ -339,7 +339,7 @@
     (unless name
       (compiler-error "can't dump anonymous LAYOUT: ~S" layout))
     ;; Since LAYOUT refers to a class which refers back to the LAYOUT,
-    ;; we have to do this in two stages, a la the TREE-WITH-PARENT
+    ;; we have to do this in two stages, like the TREE-WITH-PARENT
     ;; example in the MAKE-LOAD-FORM entry in the ANSI spec.
     (values
      ;; "creation" form (which actually doesn't create a new LAYOUT if

src/code/cold-init.lisp

@@ -85,7 +85,7 @@
   (/show0 "entering !COLD-INIT")
 
   ;; FIXME: It'd probably be cleaner to have most of the stuff here
-  ;; handled by calls a la !GC-COLD-INIT, !ERROR-COLD-INIT, and
+  ;; handled by calls like !GC-COLD-INIT, !ERROR-COLD-INIT, and
   ;; !UNIX-COLD-INIT. And *TYPE-SYSTEM-INITIALIZED* could be changed to
   ;; *TYPE-SYSTEM-INITIALIZED-WHEN-BOUND* so that it doesn't need to
   ;; be explicitly set in order to be meaningful.

src/code/cross-float.lisp

@@ -79,7 +79,7 @@
 			 (>= significand (expt 2 23))
 			 (assert (< 0 significand (expt 2 24)))
 			 ;; Exponent 0 is reserved for denormalized numbers,
-			 ;; and 255 is reserved for specials a la NaN.
+			 ;; and 255 is reserved for specials like NaN.
 			 (assert (< 0 exponent 255))
 			 (return (logior (ash exponent 23)
 					 (logand significand
@@ -124,7 +124,7 @@
 			 (>= significand (expt 2 52))
 			 (assert (< 0 significand (expt 2 53)))
 			 ;; Exponent 0 is reserved for denormalized numbers,
-			 ;; and 2047 is reserved for specials a la NaN.
+			 ;; and 2047 is reserved for specials like NaN.
 			 (assert (< 0 exponent 2047))
 			 (return (logior (ash exponent 52)
 					 (logand significand
@@ -171,7 +171,7 @@
 ;;; cross-compilation host Lisps are likely to have exactly the same
 ;;; floating point precision as the target Lisp. If it turns out to be
 ;;; a problem, there are possible workarounds involving portable
-;;; representations for target floating point numbers, a la
+;;; representations for target floating point numbers, like
 ;;;   (DEFSTRUCT TARGET-SINGLE-FLOAT
 ;;;     (SIGN (REQUIRED-ARGUMENT) :TYPE BIT)
 ;;;     (EXPONENT (REQUIRED-ARGUMENT) :TYPE UNSIGNED-BYTE)

src/code/cross-sap.lisp

@@ -32,9 +32,10 @@
 		      (,int-fun (sap-int x) (sap-int y)))))
 	       '((sap< <) (sap<= <=) (sap= =) (sap>= >=) (sap> >) (sap- -))))
 
-;;; dummies, defined so that we can declare they never return and thereby
-;;; eliminate a thundering herd of optimization notes a la "can't optimize this
-;;; expression because we don't know the return type of SAP-REF-8"
+;;; dummies, defined so that we can declare they never return and
+;;; thereby eliminate a thundering herd of optimization notes along
+;;; the lines of "can't optimize this expression because we don't know
+;;; the return type of SAP-REF-8"
 (defun sap-ref-stub (name)
   (error "~S doesn't make sense on cross-compilation host." name))
 #.`(progn

src/code/debug.lisp

@@ -64,9 +64,9 @@
 "The prompt is right square brackets, the number indicating how many
   recursive command loops you are in. 
 Any command may be uniquely abbreviated.
-The debugger rebinds various special variables for controlling i/o,
-  sometimes to defaults (a la WITH-STANDARD-IO-SYNTAX) and sometimes to 
-  its own values, e.g. SB-DEBUG:*DEBUG-PRINT-LEVEL*.
+The debugger rebinds various special variables for controlling i/o, sometimes
+  to defaults (much like WITH-STANDARD-IO-SYNTAX does) and sometimes to 
+  its own special values, e.g. SB-DEBUG:*DEBUG-PRINT-LEVEL*.
 Debug commands do not affect * and friends, but evaluation in the debug loop
   do affect these variables.
 SB-DEBUG:*FLUSH-DEBUG-ERRORS* controls whether errors at the debug prompt

src/code/query.lisp

@@ -16,7 +16,7 @@
   (string-trim " 	" (read-line *query-io*)))
 
 ;;; FIXME: The ANSI documentation for these says that they
-;;; prompt with strings a la "(Y or N)" or "(Yes or No)", but
+;;; prompt with strings like "(Y or N)" or "(Yes or No)", but
 ;;; these implementations don't.
 
 (defun y-or-n-p (&optional format-string &rest arguments)

src/cold/shared.lisp

@@ -220,8 +220,20 @@
 ;;; *SHEBANG-FEATURES* instead of *FEATURES*, and use the #!+ and #!-
 ;;; readmacros instead of the ordinary #+ and #- readmacros.
 (setf *shebang-features*
-      (append (read-from-file "base-target-features.lisp-expr")
-	      (read-from-file "local-target-features.lisp-expr")))
+      (let* ((default-features
+	       (append (read-from-file "base-target-features.lisp-expr")
+		       (read-from-file "local-target-features.lisp-expr")))
+	     (customizer-file-name "customize-target-features.lisp")
+	     (customizer (if (probe-file customizer-file-name)
+			     (compile nil 
+				      (read-from-file customizer-file-name))
+			     #'identity)))
+	(funcall customizer default-features)))
+(let ((*print-length* nil)
+      (*print-level* nil))
+  (format t
+	  "target features *SHEBANG-FEATURES*=~@<~S~:>~%"
+	  *shebang-features*))
 
 ;;;; cold-init-related PACKAGE and SYMBOL tools
 

src/compiler/dump.lisp

@@ -333,7 +333,7 @@
 	      ;; FIXME: The comment at the head of DUMP-NON-IMMEDIATE-OBJECT
 	      ;; says it's for objects which we want to save, instead of
 	      ;; repeatedly dumping them. But then we dump arrays here without
-	      ;; doing anything a la EQUAL-SAVE-OBJECT. What gives?
+	      ;; doing anything like EQUAL-SAVE-OBJECT. What gives?
 	      (dump-array x file))
 	     (number
 	      (unless (equal-check-table x file)

src/compiler/main.lisp

@@ -1115,8 +1115,8 @@
 ;;;
 ;;; Otherwise, we bind *CONSTANTS-BEING-CREATED* and
 ;;; *CONSTANTS-CREATED-SINCE- LAST-INIT* and compile the creation form
-;;; a la LOAD-TIME-VALUE. When this finishes, we tell the dumper to
-;;; use that result instead whenever it sees this constant.
+;;; much the way LOAD-TIME-VALUE does. When this finishes, we tell the
+;;; dumper to use that result instead whenever it sees this constant.
 ;;;
 ;;; Now we try to compile the init form. We bind
 ;;; *CONSTANTS-CREATED-SINCE- LAST-INIT* to NIL and compile the init

src/compiler/x86/parms.lisp

@@ -189,8 +189,7 @@
   breakpoint
   function-end-breakpoint
   single-step-breakpoint)
-;;; FIXME: It'd be nice to replace all the DEFENUMs with something
-;;; a la
+;;; FIXME: It'd be nice to replace all the DEFENUMs with something like
 ;;;   (WITH-DEF-ENUM (:START 8)
 ;;;     (DEF-ENUM HALT-TRAP)
 ;;;     (DEF-ENUM PENDING-INTERRUPT-TRAP)

src/runtime/coreparse.c

@@ -94,7 +94,7 @@ lispobj load_core_file(char *file)
 
     /* KLUDGE: This kind of conditionalization everywhere that 32-bit
      * ints are used is really nasty. It would be much nicer to define
-     * a typedef a la addr_as_int once and for all in each
+     * a typedef like addr_as_int once and for all in each
      * architecture file, then use that everywhere. -- WHN 19990904 */
 #ifndef alpha
     long header[CORE_PAGESIZE / sizeof(long)], val, len, *ptr;

version.lisp-expr

@@ -11,8 +11,8 @@
 ;;; we control the build, we can always assign an appropriate and
 ;;; relevant result, so this must be a string, not NIL.
 ;;;
-;;; Conventionally a string a la "0.6.6" is used for released
-;;; versions, and a string a la "0.6.5.12" is used for versions which
+;;; Conventionally a string like "0.6.6" is used for released
+;;; 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.8.3"
+"0.6.8.4"