Commit [95a6db] Maximize Restore History

0.6.8.9:

tweaked DEFCONSTANTs to be more ANSI-compliant (as required
when building using an XC host incorporating changes
from the previous commit) and generally cleaner
got rid of DEFCONSTANT WRAPPER-LAYOUT completely, which was
used only by STRUCTURE-WRAPPER, which is now gone
added SB-INT:DEFCONSTANT-EQX to help ANSIfy DEFCONSTANTs
merged several small files into primordial-extensions.lisp
converted DEFMACRO DEFCONSTANT to use EVAL-WHEN instead of
IR1 magic, in order to make it ANSI enough for
DEFCONSTANT-EQX to work
removed various nested EVAL-WHENs (to help cross-compiler)
identified bug IR1-3, added workaround in DO-EVAL-WHEN-STUFF
incremented fasl file version (because of mismatch between
old IR1 magic %DEFCONSTANT/%%DEFCONSTANT behavior and
new EVAL-WHEN %DEFCONSTANT behavior)
deleted some unused code
fixed (DEFCONSTANT X 1) (DEFVAR X) (SETF X 2) bug

William Harold Newman William Harold Newman 2000-11-05

1 2 3 > >> (Page 1 of 3)
changed BUGS
changed NEWS
changed make-host-2.sh
changed make-target-2.sh
changed package-data-list.lisp-expr
changed src
changed src/code
changed src/code/bignum.lisp
changed src/code/bit-bash.lisp
changed src/code/boot-extensions.lisp
changed src/code/byte-types.lisp
changed src/code/debug-info.lisp
changed src/code/debug-int.lisp
changed src/code/defstruct.lisp
changed src/code/early-extensions.lisp
changed src/code/eval.lisp
changed src/code/float-trap.lisp
changed src/code/format-time.lisp
changed src/code/host-alieneval.lisp
changed src/code/late-type.lisp
changed src/code/lisp-stream.lisp
changed src/code/macros.lisp
changed src/code/print.lisp
copied src/code/early-defboot.lisp -> src/code/primordial-extensions.lisp
BUGS Diff Switch to side-by-side view
Loading...
NEWS Diff Switch to side-by-side view
Loading...
make-host-2.sh Diff Switch to side-by-side view
Loading...
make-target-2.sh Diff Switch to side-by-side view
Loading...
package-data-list.lisp-expr Diff Switch to side-by-side view
Loading...
src
Directory.
src/code
Directory.
src/code/bignum.lisp Diff Switch to side-by-side view
Loading...
src/code/bit-bash.lisp Diff Switch to side-by-side view
Loading...
src/code/boot-extensions.lisp Diff Switch to side-by-side view
Loading...
src/code/byte-types.lisp Diff Switch to side-by-side view
Loading...
src/code/debug-info.lisp Diff Switch to side-by-side view
Loading...
src/code/debug-int.lisp Diff Switch to side-by-side view
Loading...
src/code/defstruct.lisp Diff Switch to side-by-side view
Loading...
src/code/early-extensions.lisp Diff Switch to side-by-side view
Loading...
src/code/eval.lisp Diff Switch to side-by-side view
Loading...
src/code/float-trap.lisp Diff Switch to side-by-side view
Loading...
src/code/format-time.lisp Diff Switch to side-by-side view
Loading...
src/code/host-alieneval.lisp Diff Switch to side-by-side view
Loading...
src/code/late-type.lisp Diff Switch to side-by-side view
Loading...
src/code/lisp-stream.lisp Diff Switch to side-by-side view
Loading...
src/code/macros.lisp Diff Switch to side-by-side view
Loading...
src/code/print.lisp Diff Switch to side-by-side view
Loading...
src/code/early-defboot.lisp to src/code/primordial-extensions.lisp
--- a/src/code/early-defboot.lisp
+++ b/src/code/primordial-extensions.lisp
@@ -1,5 +1,5 @@
-;;;; target bootstrapping stuff which needs to be visible on the
-;;;; cross-compilation host too
+;;;; various user-level definitions which need to be done particularly
+;;;; early
 
 ;;;; This software is part of the SBCL system. See the README file for
 ;;;; more information.
@@ -10,31 +10,8 @@
 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
 ;;;; files for more information.
 
-(in-package "SB!EXT")
+(in-package "SB!INT")
 
-;;; helper function for various macros which expect clauses of a given
-;;; length, etc. 
-;;;
-;;; KLUDGE: This implementation will hang on circular list structure. Since
-;;; this is an error-checking utility, i.e. its job is to deal with screwed-up
-;;; input, it'd be good style to fix it so that it can deal with circular list
-;;; structure.
-(eval-when (:compile-toplevel :load-toplevel :execute)
-  ;; Return true if X is a proper list whose length is between MIN and
-  ;; MAX (inclusive).
-  (defun proper-list-of-length-p (x min &optional (max min))
-    (cond ((minusp max)
-	   nil)
-	  ((null x)
-	   (zerop min))
-	  ((consp x)
-	   (and (plusp max)
-		(proper-list-of-length-p (cdr x)
-					 (if (plusp (1- min))
-					   (1- min)
-					   0)
-					 (1- max))))
-	  (t nil))))
 
 ;;;; DO-related stuff which needs to be visible on the cross-compilation host
 
@@ -102,3 +79,93 @@
   the Exit-Forms are evaluated as a PROGN, with the result being the value
   of the DO."
   (do-do-body varlist endlist body 'let 'psetq 'do-anonymous (gensym)))
+
+;;;; miscellany
+
+;;; Concatenate together the names of some strings and symbols,
+;;; producing a symbol in the current package.
+(defun symbolicate (&rest things)
+  (values (intern (apply #'concatenate
+			 'string
+			 (mapcar #'string things)))))
+
+;;; like SYMBOLICATE, but producing keywords
+(defun keywordicate (&rest things)
+  (let ((*package* *keyword-package*))
+    (apply #'symbolicate things)))
+
+;;; Give names to elements of a numeric sequence.
+(defmacro defenum ((&key (prefix "") (suffix "") (start 0) (step 1))
+		   &rest identifiers)
+  (let ((results nil)
+	(index 0)
+ 	(start (eval start))
+	(step (eval step)))
+    (dolist (id identifiers)
+      (when id
+	(multiple-value-bind (root docs)
+	    (if (consp id)
+		(values (car id) (cdr id))
+		(values id nil))
+	  ;; (This could be SYMBOLICATE, except that due to
+	  ;; bogobootstrapping issues SYMBOLICATE isn't defined yet.)
+	  (push `(defconstant ,(symbolicate prefix root suffix)
+		   ,(+ start (* step index))
+		   ,@docs)
+		results)))
+      (incf index))
+    `(progn
+       ,@(nreverse results))))
+
+;;; generalization of DEFCONSTANT to values which are the same not
+;;; under EQL but under e.g. EQUAL or EQUALP
+;;;
+;;; DEFCONSTANT-EQX is to be used instead of DEFCONSTANT for values
+;;; which are appropriately compared using the function given by the
+;;; EQX argument instead of EQL.
+;;;
+;;; Note: Be careful when using this macro, since it's easy to
+;;; unintentionally pessimize your code. A good time to use this macro
+;;; is when the values defined will be fed into optimization
+;;; transforms and never actually appear in the generated code; this
+;;; is especially common when defining BYTE expressions. Unintentional
+;;; pessimization can result when the values defined by this macro are
+;;; actually used in generated code: because of the way that the
+;;; dump/load system works, you'll typically get one copy of consed
+;;; structure for each object file which contains code referring to
+;;; the value, plus perhaps one more copy bound to the SYMBOL-VALUE of
+;;; the constant. If you don't want that to happen, you should
+;;; probably use DEFPARAMETER instead.
+(defmacro defconstant-eqx (symbol expr eqx &optional doc)
+  (let ((expr-tmp (gensym "EXPR-TMP-")))
+    `(progn
+       ;; When we're building the cross-compiler, and in most
+       ;; situations even when we're running the cross-compiler,
+       ;; all we need is a nice portable definition in terms of the
+       ;; ANSI Common Lisp operations.
+       (eval-when (:compile-toplevel :load-toplevel :execute)
+	 (let ((,expr-tmp ,expr))
+	   (unless (and (boundp ',symbol)
+			(constantp ',symbol)
+			(funcall ,eqx (symbol-value ',symbol) ,expr-tmp))
+	     (defconstant ,symbol ,expr ,@(when doc `(,doc))))))
+       ;; The #+SB-XC :COMPILE-TOPLEVEL situation is special, since we
+       ;; want to define the symbol not just in the cross-compilation
+       ;; host Lisp (which was handled above) but also in the
+       ;; cross-compiler (which we will handle now).
+       ;;
+       ;; KLUDGE: It would probably be possible to do this fairly
+       ;; cleanly, in a way parallel to the code above, if we had
+       ;; SB!XC:FOO versions of all the primitives CL:FOO used above
+       ;; (e.g. SB!XC:BOUNDP, SB!XC:SYMBOL-VALUE, and
+       ;; SB!XC:DEFCONSTANT), and took care to call them. But right
+       ;; now we just hack around in the guts of the cross-compiler
+       ;; instead. -- WHN 2000-11-03
+       #+sb-xc
+       (eval-when (:compile-toplevel)
+	 (let ((,expr-tmp ,expr))
+	   (unless (and (eql (info :variable :kind ',symbol) :constant)
+			(funcall ,eqx
+				 (info :variable :constant-value ',symbol)
+				 ,expr-tmp))
+	     (sb!c::%defconstant ',symbol ,expr-tmp ,doc)))))))
1 2 3 > >> (Page 1 of 3)