[Sbcl-commits] CVS: sbcl/src/code defbangconstant.lisp,NONE,1.1 force-delayed-defbangconstants.lisp,

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 454-5900

Update of /cvsroot/sbcl/sbcl/src/code
In directory usw-pr-cvs1:/tmp/cvs-serv21640/src/code

Modified Files:
	char.lisp class.lisp debug-info.lisp defbangtype.lisp 
	early-array.lisp early-extensions.lisp early-fasl.lisp 
	macros.lisp primordial-extensions.lisp random.lisp 
	readtable.lisp 
Added Files:
	defbangconstant.lisp force-delayed-defbangconstants.lisp 
Log Message:
0.7.3.18:
	Merged def!constant patch (CSR sbcl-devel 2002-05-17)
	... cross-compiler now starts knowing about constant values
	src/compiler/assem tweaks
	... declare some things ignorable
	... comment tweaks
	other backend tweaks
	... declare the type for with-adjustable-vector
		[ the fact that I had to do this four times, once for each
		  backend, is not optimal. ] 

--- NEW FILE: defbangconstant.lisp ---
;;;; This software is part of the SBCL system. See the README file for
;;;; more information.
;;;;
;;;; This software is derived from the CMU CL system, which was
;;;; written at Carnegie Mellon University and released into the
;;;; public domain. The software is in the public domain and is
;;;; provided with absolutely no warranty. See the COPYING and CREDITS
;;;; files for more information.

(in-package "SB!KERNEL")

;;;; the DEF!CONSTANT macro

;;; FIXME: This code was created by cut-and-paste from the
;;; corresponding code for DEF!TYPE. DEF!CONSTANT, DEF!TYPE and
;;; DEF!MACRO are currently very parallel, and if we ever manage to
;;; rationalize the use of UNCROSS in the cross-compiler, they should
;;; become completely parallel, at which time they should be merged to
;;; eliminate the duplicate code.

;;; *sigh* -- Even the comments are cut'n'pasted :-/ If I were more
;;; confident in my understanding, I might try to do drastic surgery,
;;; but my head is currently spinning (host? target? both?) so I'll go
;;; for the minimal changeset... -- CSR, 2002-05-11
(defmacro def!constant (&rest rest name value &optional doc)
  `(progn
     #-sb-xc-host
     (defconstant ,@rest)
     #+sb-xc-host
     ,(unless (eql (find-symbol (symbol-name name) :cl) name)
	`(defconstant ,@rest))
     #+sb-xc-host 
     ,(let ((form `(sb!xc:defconstant ,@rest)))
	(if (boundp '*delayed-def!constants*)
	    `(push ',form *delayed-def!constants*)
	    form))))

;;; machinery to implement DEF!CONSTANT delays
#+sb-xc-host
(progn
  (/show "binding *DELAYED-DEF!CONSTANTS*")
  (defvar *delayed-def!constants* nil)
  (/show "done binding *DELAYED-DEF!CONSTANTS*")
  (defun force-delayed-def!constants ()
    (if (boundp '*delayed-def!constants*)
	(progn
	  (mapc #'eval *delayed-def!constants*)
	  (makunbound '*delayed-def!constants*))
	;; This condition is probably harmless if it comes up when
	;; interactively experimenting with the system by loading a
	;; source file into it more than once. But it's worth warning
	;; about it because it definitely shouldn't come up in an
	;; ordinary build process.
	(warn "*DELAYED-DEF!CONSTANTS* is already unbound."))))

--- NEW FILE: force-delayed-defbangconstants.lisp ---
;;;; Now that all the cross-compiler INFO machinery has been set up, we
;;;; can feed the stored DEF!CONSTANTS argument lists to it.
;;;;
;;;; KLUDGE: There's no real reason for this to be in its own file, except
;;;; perhaps the parallelism with FORCE-DELAYED-DEF!STRUCTS (which does have a
;;;; good reason).

;;;; This software is part of the SBCL system. See the README file for
;;;; more information.
;;;;
;;;; This software is derived from the CMU CL system, which was
;;;; written at Carnegie Mellon University and released into the
;;;; public domain. The software is in the public domain and is
;;;; provided with absolutely no warranty. See the COPYING and CREDITS
;;;; files for more information.

(in-package "SB!KERNEL")

#+sb-xc-host (force-delayed-def!constants)

Index: char.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/code/char.lisp,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** char.lisp	26 Mar 2001 20:55:56 -0000	1.3
--- char.lisp	19 May 2002 13:55:31 -0000	1.4
***************
*** 13,17 ****
  (in-package "SB!IMPL")

! (defconstant sb!xc:char-code-limit 256
    #!+sb-doc
    "the upper exclusive bound on values produced by CHAR-CODE")
--- 13,17 ----
  (in-package "SB!IMPL")

! (def!constant sb!xc:char-code-limit 256
    #!+sb-doc
    "the upper exclusive bound on values produced by CHAR-CODE")

Index: class.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/code/class.lisp,v
retrieving revision 1.30
retrieving revision 1.31
diff -C2 -d -r1.30 -r1.31
*** class.lisp	7 Mar 2002 01:00:12 -0000	1.30
--- class.lisp	19 May 2002 13:55:31 -0000	1.31
***************
*** 97,101 ****
  ;;; in order to guarantee that several hash values can be added without
  ;;; overflowing into a bignum.
! (defconstant layout-clos-hash-max (ash most-positive-fixnum -3)
    #!+sb-doc
    "the inclusive upper bound on LAYOUT-CLOS-HASH values")
--- 97,101 ----
  ;;; in order to guarantee that several hash values can be added without
  ;;; overflowing into a bignum.
! (def!constant layout-clos-hash-max (ash most-positive-fixnum -3)
    #!+sb-doc
    "the inclusive upper bound on LAYOUT-CLOS-HASH values")
***************
*** 234,238 ****
  ;;;; support for the hash values used by CLOS when working with LAYOUTs

! (defconstant layout-clos-hash-length 8)
  #!-sb-fluid (declaim (inline layout-clos-hash))
  (defun layout-clos-hash (layout i)
--- 234,238 ----
  ;;;; support for the hash values used by CLOS when working with LAYOUTs

! (def!constant layout-clos-hash-length 8)
  #!-sb-fluid (declaim (inline layout-clos-hash))
  (defun layout-clos-hash (layout i)

Index: debug-info.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/code/debug-info.lisp,v
retrieving revision 1.14
retrieving revision 1.15
diff -C2 -d -r1.14 -r1.15
*** debug-info.lisp	15 Jan 2002 01:06:09 -0000	1.14
--- debug-info.lisp	19 May 2002 13:55:31 -0000	1.15
***************
*** 52,60 ****
  ;;;(defconstant compiled-debug-var-uninterned		#b00000001)
  ;;;(defconstant compiled-debug-var-packaged		#b00000010)
! (defconstant compiled-debug-var-environment-live	#b00000100)
! (defconstant compiled-debug-var-save-loc-p		#b00001000)
! (defconstant compiled-debug-var-id-p			#b00010000)
! (defconstant compiled-debug-var-minimal-p		#b00100000)
! (defconstant compiled-debug-var-deleted-p		#b01000000)

  ;;;; compiled debug blocks
--- 52,60 ----
  ;;;(defconstant compiled-debug-var-uninterned		#b00000001)
  ;;;(defconstant compiled-debug-var-packaged		#b00000010)
! (def!constant compiled-debug-var-environment-live	#b00000100)
! (def!constant compiled-debug-var-save-loc-p		#b00001000)
! (def!constant compiled-debug-var-id-p			#b00010000)
! (def!constant compiled-debug-var-minimal-p		#b00100000)
! (def!constant compiled-debug-var-deleted-p		#b01000000)

  ;;;; compiled debug blocks
***************
*** 75,79 ****

  (defconstant-eqx compiled-debug-block-nsucc-byte (byte 2 0) #'equalp)
! (defconstant compiled-debug-block-elsewhere-p #b00000100)

  (defconstant-eqx compiled-code-location-kind-byte (byte 3 0) #'equalp)
--- 75,79 ----

  (defconstant-eqx compiled-debug-block-nsucc-byte (byte 2 0) #'equalp)
! (def!constant compiled-debug-block-elsewhere-p #b00000100)

  (defconstant-eqx compiled-code-location-kind-byte (byte 3 0) #'equalp)

Index: defbangtype.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/code/defbangtype.lisp,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** defbangtype.lisp	20 Oct 2000 23:30:33 -0000	1.2
--- defbangtype.lisp	19 May 2002 13:55:31 -0000	1.3
***************
*** 12,16 ****
  ;;;; the DEF!TYPE macro

! ;;; DEF!MACRO = cold DEFTYPE, a version of DEFTYPE which at
  ;;; build-the-cross-compiler time defines its macro both in the
  ;;; cross-compilation host Lisp and in the target Lisp. Basically,
--- 12,16 ----
  ;;;; the DEF!TYPE macro

! ;;; DEF!TYPE = cold DEFTYPE, a version of DEFTYPE which at
  ;;; build-the-cross-compiler time defines its macro both in the
  ;;; cross-compilation host Lisp and in the target Lisp. Basically,

Index: early-array.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/code/early-array.lisp,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** early-array.lisp	7 Mar 2002 01:00:12 -0000	1.3
--- early-array.lisp	19 May 2002 13:55:31 -0000	1.4
***************
*** 10,22 ****
  (in-package "SB!IMPL")

! (defconstant sb!xc:array-rank-limit 65529
    #!+sb-doc
    "the exclusive upper bound on the rank of an array")

! (defconstant sb!xc:array-dimension-limit sb!xc:most-positive-fixnum
    #!+sb-doc
    "the exclusive upper bound on any given dimension of an array")

! (defconstant sb!xc:array-total-size-limit sb!xc:most-positive-fixnum
    #!+sb-doc
    "the exclusive upper bound on the total number of elements in an array")
--- 10,22 ----
  (in-package "SB!IMPL")

! (def!constant sb!xc:array-rank-limit 65529
    #!+sb-doc
    "the exclusive upper bound on the rank of an array")

! (def!constant sb!xc:array-dimension-limit sb!xc:most-positive-fixnum
    #!+sb-doc
    "the exclusive upper bound on any given dimension of an array")

! (def!constant sb!xc:array-total-size-limit sb!xc:most-positive-fixnum
    #!+sb-doc
    "the exclusive upper bound on the total number of elements in an array")

Index: early-extensions.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/code/early-extensions.lisp,v
retrieving revision 1.43
retrieving revision 1.44
diff -C2 -d -r1.43 -r1.44
*** early-extensions.lisp	25 Apr 2002 19:26:54 -0000	1.43
--- early-extensions.lisp	19 May 2002 13:55:31 -0000	1.44
***************
*** 54,58 ****
    ;; how to represent and dump non-STANDARD-CHARs like #\NULL)
    (defparameter *default-init-char-form* '(code-char 0)))
- (defconstant default-init-char #.*default-init-char-form*)

  ;;; CHAR-CODE values for ASCII characters which we care about but
--- 54,57 ----
***************
*** 67,78 ****
  ;;; (or just find a nicer way of expressing characters portably?) --
  ;;; WHN 19990713
! (defconstant bell-char-code 7)
! (defconstant backspace-char-code 8)
! (defconstant tab-char-code 9)
! (defconstant line-feed-char-code 10)
! (defconstant form-feed-char-code 12)
! (defconstant return-char-code 13)
! (defconstant escape-char-code 27)
! (defconstant rubout-char-code 127)

  ;;;; type-ish predicates
--- 66,77 ----
  ;;; (or just find a nicer way of expressing characters portably?) --
  ;;; WHN 19990713
! (def!constant bell-char-code 7)
! (def!constant backspace-char-code 8)
! (def!constant tab-char-code 9)
! (def!constant line-feed-char-code 10)
! (def!constant form-feed-char-code 12)
! (def!constant return-char-code 13)
! (def!constant escape-char-code 27)
! (def!constant rubout-char-code 127)

  ;;;; type-ish predicates

Index: early-fasl.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/code/early-fasl.lisp,v
retrieving revision 1.21
retrieving revision 1.22
diff -C2 -d -r1.21 -r1.22
*** early-fasl.lisp	8 May 2002 19:57:23 -0000	1.21
--- early-fasl.lisp	19 May 2002 13:55:31 -0000	1.22
***************
*** 35,39 ****

  ;;; the code for a character which terminates a fasl file header
! (defconstant +fasl-header-string-stop-char-code+ 255)

  ;;; This value should be incremented when the system changes in such a
--- 35,39 ----

  ;;; the code for a character which terminates a fasl file header
! (def!constant +fasl-header-string-stop-char-code+ 255)

  ;;; This value should be incremented when the system changes in such a
***************
*** 43,47 ****
  ;;; be incremented for release versions which break binary
  ;;; compatibility.
! (defconstant +fasl-file-version+ 28)
  ;;; (record of versions before 0.7.0 deleted in 0.7.1.41)
  ;;; 23 = sbcl-0.7.0.1 deleted no-longer-used EVAL-STACK stuff,
--- 43,47 ----
  ;;; be incremented for release versions which break binary
  ;;; compatibility.
! (def!constant +fasl-file-version+ 28)
  ;;; (record of versions before 0.7.0 deleted in 0.7.1.41)
  ;;; 23 = sbcl-0.7.0.1 deleted no-longer-used EVAL-STACK stuff,

Index: macros.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/code/macros.lisp,v
retrieving revision 1.25
retrieving revision 1.26
diff -C2 -d -r1.25 -r1.26
*** macros.lisp	1 Apr 2002 14:52:23 -0000	1.25
--- macros.lisp	19 May 2002 13:55:31 -0000	1.26
***************
*** 77,184 ****
  	     (check-type-error ',place ,place-value ',type ,type-string)))))

- ;;;; DEFCONSTANT
- 
- (defmacro-mundanely defconstant (name value &optional documentation)
-   #!+sb-doc
-   "Define a global constant, saying that the value is constant and may be
-   compiled into code. If the variable already has a value, and this is not
-   EQL to the new value, the code is not portable (undefined behavior). The
-   third argument is an optional documentation string for the variable."
-   `(eval-when (:compile-toplevel :load-toplevel :execute)
-      (sb!c::%defconstant ',name ,value ',documentation)))
- 
- ;;; the guts of DEFCONSTANT
- (defun sb!c::%defconstant (name value doc)
-   (unless (symbolp name)
-     (error "The constant name is not a symbol: ~S" name))
-   (about-to-modify-symbol-value name)
-   (when (looks-like-name-of-special-var-p name)
-     (style-warn "defining ~S as a constant, even though the name follows~@
- the usual naming convention (names like *FOO*) for special variables"
- 		name))
-   (let ((kind (info :variable :kind name)))
-     (case kind
-       (:constant
-        ;; Note: This behavior (discouraging any non-EQL modification)
-        ;; is unpopular, but it is specified by ANSI (i.e. ANSI says a
-        ;; non-EQL change has undefined consequences). If people really
-        ;; want bindings which are constant in some sense other than
-        ;; EQL, I suggest either just using DEFVAR (which is usually
-        ;; appropriate, despite the un-mnemonic name), or defining
-        ;; something like the DEFCONSTANT-EQX macro used in SBCL (which
-        ;; is occasionally more appropriate). -- WHN 2001-12-21
-        (unless (eql value
- 		    (info :variable :constant-value name))
- 	 (cerror "Go ahead and change the value."
- 		 "The constant ~S is being redefined."
- 		 name)))
-       (:global
-        ;; (This is OK -- undefined variables are of this kind. So we
-        ;; don't warn or error or anything, just fall through.)
-        )
-       (t (warn "redefining ~(~A~) ~S to be a constant" kind name))))
-   (when doc
-     (setf (fdocumentation name 'variable) doc))
- 
-   ;; We want to set the cross-compilation host's symbol value, not just
-   ;; the cross-compiler's (INFO :VARIABLE :CONSTANT-VALUE NAME), so
-   ;; that code like
-   ;;   (defconstant max-entries 61)
-   ;;   (deftype entry-index () `(mod ,max-entries))
-   ;; will be cross-compiled correctly.
-   #-sb-xc-host (setf (symbol-value name) value)
-   #+sb-xc-host (progn
- 		 ;; Redefining our cross-compilation host's CL symbols
- 		 ;; would be poor form.
- 		 ;;
- 		 ;; FIXME: Having to check this and then not treat it
- 		 ;; as a fatal error seems like a symptom of things
- 		 ;; being pretty broken. It's also a problem in and of
- 		 ;; itself, since it makes it too easy for cases of
- 		 ;; using the cross-compilation host Lisp's CL
- 		 ;; constant values in the target Lisp to slip by. I
- 		 ;; got backed into this because the cross-compiler
- 		 ;; translates DEFCONSTANT SB!XC:FOO into DEFCONSTANT
- 		 ;; CL:FOO. It would be good to unscrew the
- 		 ;; cross-compilation package hacks so that that
- 		 ;; translation doesn't happen. Perhaps:
- 		 ;;   * Replace SB-XC with SB-CL. SB-CL exports all the 
- 		 ;;     symbols which ANSI requires to be exported from CL.
- 		 ;;   * Make a nickname SB!CL which behaves like SB!XC.
- 		 ;;   * Go through the loaded-on-the-host code making
- 		 ;;     every target definition be in SB-CL. E.g.
- 		 ;;     DEFMACRO-MUNDANELY DEFCONSTANT becomes
- 		 ;;     DEFMACRO-MUNDANELY SB!CL:DEFCONSTANT.
- 		 ;;   * Make IN-TARGET-COMPILATION-MODE do 
- 		 ;;     UNUSE-PACKAGE CL and USE-PACKAGE SB-CL in each
- 		 ;;     of the target packages (then undo it on exit).
- 		 ;;   * Make the cross-compiler's implementation of
- 		 ;;     EVAL-WHEN (:COMPILE-TOPLEVEL) do UNCROSS.
- 		 ;;     (This may not require any change.)
- 		 ;;   * Hack GENESIS as necessary so that it outputs
- 		 ;;     SB-CL stuff as COMMON-LISP stuff.
- 		 ;;   * Now the code here can assert that the symbol
- 		 ;;     being defined isn't in the cross-compilation
- 		 ;;     host's CL package.
- 		 (unless (eql (find-symbol (symbol-name name) :cl) name)
- 		   ;; KLUDGE: In the cross-compiler, we use the
- 		   ;; cross-compilation host's DEFCONSTANT macro
- 		   ;; instead of just (SETF SYMBOL-VALUE), in order to
- 		   ;; get whatever blessing the cross-compilation host
- 		   ;; may expect for a global (SETF SYMBOL-VALUE).
- 		   ;; (CMU CL, at least around 2.4.19, generated full
- 		   ;; WARNINGs for code -- e.g. DEFTYPE expanders --
- 		   ;; which referred to symbols which had been set by
- 		   ;; (SETF SYMBOL-VALUE). I doubt such warnings are
- 		   ;; ANSI-compliant, but I'm not sure, so I've
- 		   ;; written this in a way that CMU CL will tolerate
- 		   ;; and which ought to work elsewhere too.) -- WHN
- 		   ;; 2001-03-24
- 		   (eval `(defconstant ,name ',value))))
- 
-   (setf (info :variable :kind name) :constant
- 	(info :variable :constant-value name) value)
-   name)
- 
  ;;;; DEFINE-SYMBOL-MACRO

--- 77,80 ----

Index: primordial-extensions.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/code/primordial-extensions.lisp,v
retrieving revision 1.19
retrieving revision 1.20
diff -C2 -d -r1.19 -r1.20
*** primordial-extensions.lisp	25 Apr 2002 19:26:55 -0000	1.19
--- primordial-extensions.lisp	19 May 2002 13:55:31 -0000	1.20
***************
*** 47,51 ****
  ;;; interpreter to go away, which is waiting for sbcl-0.7.x..
  (eval-when (:compile-toplevel :load-toplevel :execute)
!   (defconstant +empty-ht-slot+ '%empty-ht-slot%))
  ;;; We shouldn't need this mess now that EVAL-WHEN works.
  #+nil (defconstant +empty-ht-slot+ '#.+empty-ht-slot+) ; egads.. See FIXME above.
--- 47,51 ----
  ;;; interpreter to go away, which is waiting for sbcl-0.7.x..
  (eval-when (:compile-toplevel :load-toplevel :execute)
!   (def!constant +empty-ht-slot+ '%empty-ht-slot%))
  ;;; We shouldn't need this mess now that EVAL-WHEN works.
  #+nil (defconstant +empty-ht-slot+ '#.+empty-ht-slot+) ; egads.. See FIXME above.
***************
*** 225,229 ****
  		(values (car id) (cdr id))
  		(values id nil))
! 	  (push `(defconstant ,(symbolicate prefix root suffix)
  		   ,(+ start (* step index))
  		   ,@docs)
--- 225,229 ----
  		(values (car id) (cdr id))
  		(values id nil))
! 	  (push `(def!constant ,(symbolicate prefix root suffix)
  		   ,(+ start (* step index))
  		   ,@docs)
***************
*** 255,259 ****
  ;;; able to do something with LOAD-TIME-VALUE or MAKE-LOAD-FORM.
  (defmacro defconstant-eqx (symbol expr eqx &optional doc)
!   `(defconstant ,symbol
       (%defconstant-eqx-value ',symbol ,expr ,eqx)
       ,@(when doc (list doc))))
--- 255,259 ----
  ;;; able to do something with LOAD-TIME-VALUE or MAKE-LOAD-FORM.
  (defmacro defconstant-eqx (symbol expr eqx &optional doc)
!   `(def!constant ,symbol
       (%defconstant-eqx-value ',symbol ,expr ,eqx)
       ,@(when doc (list doc))))

Index: random.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/code/random.lisp,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** random.lisp	3 Mar 2001 18:25:30 -0000	1.3
--- random.lisp	19 May 2002 13:55:32 -0000	1.4
***************
*** 11,26 ****

  ;;; the size of the chunks returned by RANDOM-CHUNK
! (defconstant random-chunk-length 32)

  ;;; the amount that we overlap chunks by when building a large integer
  ;;; to make up for the loss of randomness in the low bits
! (defconstant random-integer-overlap 3)

  ;;; extra bits of randomness that we generate before taking the value MOD the
  ;;; limit, to avoid loss of randomness near the limit
! (defconstant random-integer-extra-bits 10)

  ;;; the largest fixnum we can compute from one chunk of bits
! (defconstant random-fixnum-max
    (1- (ash 1 (- random-chunk-length random-integer-extra-bits))))

--- 11,26 ----

  ;;; the size of the chunks returned by RANDOM-CHUNK
! (def!constant random-chunk-length 32)

  ;;; the amount that we overlap chunks by when building a large integer
  ;;; to make up for the loss of randomness in the low bits
! (def!constant random-integer-overlap 3)

  ;;; extra bits of randomness that we generate before taking the value MOD the
  ;;; limit, to avoid loss of randomness near the limit
! (def!constant random-integer-extra-bits 10)

  ;;; the largest fixnum we can compute from one chunk of bits
! (def!constant random-fixnum-max
    (1- (ash 1 (- random-chunk-length random-integer-extra-bits))))

Index: readtable.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/code/readtable.lisp,v
retrieving revision 1.6
retrieving revision 1.7
diff -C2 -d -r1.6 -r1.7
*** readtable.lisp	26 Mar 2001 20:55:56 -0000	1.6
--- readtable.lisp	19 May 2002 13:55:32 -0000	1.7
***************
*** 17,33 ****
  ;;; constants for readtable character attributes. These are all as in
  ;;; the manual.
! (defconstant +char-attr-whitespace+ 0)
! (defconstant +char-attr-terminating-macro+ 1)
! (defconstant +char-attr-escape+ 2)
! (defconstant +char-attr-constituent+ 3)
! (defconstant +char-attr-constituent-dot+ 4)
! (defconstant +char-attr-constituent-expt+ 5)
! (defconstant +char-attr-constituent-slash+ 6)
! (defconstant +char-attr-constituent-digit+ 7)
! (defconstant +char-attr-constituent-sign+ 8)
  ;; the "9" entry intentionally left blank for some reason -- WHN 19990806
! (defconstant +char-attr-multiple-escape+ 10)
! (defconstant +char-attr-package-delimiter+ 11)
! (defconstant +char-attr-delimiter+ 12) ; (a fake for READ-UNQUALIFIED-TOKEN)

  (sb!xc:defstruct (readtable (:conc-name nil)
--- 17,33 ----
  ;;; constants for readtable character attributes. These are all as in
  ;;; the manual.
! (def!constant +char-attr-whitespace+ 0)
! (def!constant +char-attr-terminating-macro+ 1)
! (def!constant +char-attr-escape+ 2)
! (def!constant +char-attr-constituent+ 3)
! (def!constant +char-attr-constituent-dot+ 4)
! (def!constant +char-attr-constituent-expt+ 5)
! (def!constant +char-attr-constituent-slash+ 6)
! (def!constant +char-attr-constituent-digit+ 7)
! (def!constant +char-attr-constituent-sign+ 8)
  ;; the "9" entry intentionally left blank for some reason -- WHN 19990806
! (def!constant +char-attr-multiple-escape+ 10)
! (def!constant +char-attr-package-delimiter+ 11)
! (def!constant +char-attr-delimiter+ 12) ; (a fake for READ-UNQUALIFIED-TOKEN)

  (sb!xc:defstruct (readtable (:conc-name nil)

[Sbcl-commits] CVS: sbcl/src/code defbangconstant.lisp,NONE,1.1 force-delayed-defbangconstants.lisp,

Common Lisp compiler and runtime