obj
output
ChangeLog
+customize-target-features.lisp
local-target-features.lisp-expr
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
* 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
; :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.
;;
;;; 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))
(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
(/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.
(>= 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
(>= 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
;;; 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)
(,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
"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
(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)
;;; *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*))
\f
;;;; cold-init-related PACKAGE and SYMBOL tools
;; 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)
;;;
;;; 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
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)
/* 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;
;;; 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"
projects / sbcl.git / commitdiff