1.0.28.31: remove :PREFIX/:SUFFIX from DEFENUM for MORE GREPPABILITY

Searching for useful things like even-fixnum-lowtag in the source won't
find the actual definition due to cleverness with DEFENUM.  This cleverness
is the source of several FIXMEs throughout the code.  I can personally
remember being baffled at the magic of even-fixnum-lowtag and friends
magically springing into existence when I could not easily grep for their
definitions.  In the interest of clarity, remove the cleverness and update
all relevent DEFENUMs.

In the interest of OAOO, move TRACE-TABLE-* constants to generic code while
we're at it, too.  Doing the same thing for the *-TRAP constants is left
as an exercise for another day.

diff --git a/src/code/primordial-extensions.lisp b/src/code/primordial-extensions.lisp
index 95a7094..e25ed15 100644 (file)
--- a/src/code/primordial-extensions.lisp
+++ b/src/code/primordial-extensions.lisp
@@ -259,7 +259,7 @@
     dfd))
 
 ;;; Give names to elements of a numeric sequence.
-(defmacro defenum ((&key (prefix "") (suffix "") (start 0) (step 1))
+(defmacro defenum ((&key (start 0) (step 1))
                    &rest identifiers)
   (let ((results nil)
         (index 0)
@@ -267,11 +267,11 @@
         (step (eval step)))
     (dolist (id identifiers)
       (when id
-        (multiple-value-bind (root docs)
+        (multiple-value-bind (sym docs)
             (if (consp id)
                 (values (car id) (cdr id))
                 (values id nil))
-          (push `(def!constant ,(symbolicate prefix root suffix)
+          (push `(def!constant ,sym
                    ,(+ start (* step index))
                    ,@docs)
                 results)))

diff --git a/src/compiler/alpha/parms.lisp b/src/compiler/alpha/parms.lisp
index 5254a2b..78b7d0e 100644 (file)
--- a/src/compiler/alpha/parms.lisp
+++ b/src/compiler/alpha/parms.lisp
@@ -143,25 +143,19 @@
 \f
 ;;;; other miscellaneous constants
 
-(defenum (:suffix -trap :start 8)
-  halt
-  pending-interrupt
-  error
-  cerror
-  breakpoint
-  fun-end-breakpoint
-  single-step-breakpoint
+(defenum (:start 8)
+  halt-trap
+  pending-interrupt-trap
+  error-trap
+  cerror-trap
+  breakpoint-trap
+  fun-end-breakpoint-trap
+  single-step-breakpoint-trap
   ;; Stepper actually not implemented on Alpha, but these constants
   ;; are still needed to avoid undefined variable warnings during sbcl
   ;; build.
-  single-step-around
-  single-step-before)
-
-(defenum (:prefix trace-table-)
-  normal
-  call-site
-  fun-prologue
-  fun-epilogue)
+  single-step-around-trap
+  single-step-before-trap)
 \f
 ;;;; static symbols
 

diff --git a/src/compiler/generic/early-objdef.lisp b/src/compiler/generic/early-objdef.lisp
index b90d8a8..550a515 100644 (file)
--- a/src/compiler/generic/early-objdef.lisp
+++ b/src/compiler/generic/early-objdef.lisp
@@ -11,14 +11,6 @@
 
 (in-package "SB!VM")
 
-;;; FIXME: It's clever using :SUFFIX -LOWTAG for these things, but
-;;; it's a pain for people just learning to find their way around the
-;;; code who want to use lexical search to figure out where things
-;;; like EVEN-FIXNUM-LOWTAG are defined. Remove the :SUFFIXes and just
-;;; expand out the full names. Or even define them in DEF
-;;; EVEN-FIXNUM-LOWTAG style so searches like
-;;; 'def.*even-fixnum-lowtag' can find them.
-
 ;;; Tags for the main low-level types are stored in the low n (usually three)
 ;;; bits to identify the type of a machine word.  Certain constraints
 ;;; apply:
@@ -46,29 +38,32 @@
   ;; second DEFENUM uses the value of OTHER-IMMEDIATE-0-LOWTAG, which is
   ;; defined in the first DEFENUM. -- AL 20000216
   #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
-  (defenum (:suffix -lowtag)
-    even-fixnum
-    instance-pointer
-    other-immediate-0
-    pad0 pad1 pad2
-    other-immediate-1
-    list-pointer
-    odd-fixnum
-    fun-pointer
-    other-immediate-2
-    pad3 pad4 pad5
-    other-immediate-3
-    other-pointer)
+  (defenum ()
+    even-fixnum-lowtag
+    instance-pointer-lowtag
+    other-immediate-0-lowtag
+    pad0-lowtag
+    pad1-lowtag pad2-lowtag
+    other-immediate-1-lowtag
+    list-pointer-lowtag
+    odd-fixnum-lowtag
+    fun-pointer-lowtag
+    other-immediate-2-lowtag
+    pad3-lowtag
+    pad4-lowtag
+    pad5-lowtag
+    other-immediate-3-lowtag
+    other-pointer-lowtag)
   #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
-  (defenum (:suffix -lowtag)
-    even-fixnum
-    instance-pointer
-    other-immediate-0
-    list-pointer
-    odd-fixnum
-    fun-pointer
-    other-immediate-1
-    other-pointer))
+  (defenum ()
+    even-fixnum-lowtag
+    instance-pointer-lowtag
+    other-immediate-0-lowtag
+    list-pointer-lowtag
+    odd-fixnum-lowtag
+    fun-pointer-lowtag
+    other-immediate-1-lowtag
+    other-pointer-lowtag))
 
 (def!constant nil-value
     (+ static-space-start n-word-bytes other-pointer-lowtag))
@@ -111,8 +106,7 @@
 ;;;   JNE   tag, label
 ;;;
 ;;; rather than two separate tests and jumps
-(defenum (:suffix -widetag
-          ;; The first widetag must be greater than SB!VM:LOWTAG-LIMIT
+(defenum (;; The first widetag must be greater than SB!VM:LOWTAG-LIMIT
           ;; otherwise code in generic/early-type-vops will suffer
           ;; a long, horrible death.  --njf, 2004-08-09
           :start (+ (ash 1 n-lowtag-bits) other-immediate-0-lowtag)
@@ -121,105 +115,105 @@
   ;; ports; add #b1000 if you want to know the values for 64-bit ports.
   ;; And note that the numbers get a little scrambled further down.
   ;;   --njf, 2004-08-09
-  bignum                            ; 00001010
-  ratio                             ; 00001110
-  single-float                      ; 00010010
-  double-float                      ; 00010110
-  complex                           ; 00011010
-  complex-single-float              ; 00011110
-  complex-double-float              ; 00100010
+  bignum-widetag                            ; 00001010
+  ratio-widetag                             ; 00001110
+  single-float-widetag                      ; 00010010
+  double-float-widetag                      ; 00010110
+  complex-widetag                           ; 00011010
+  complex-single-float-widetag              ; 00011110
+  complex-double-float-widetag              ; 00100010
 
-  code-header                       ; 00100110
+  code-header-widetag                       ; 00100110
 
-  simple-fun-header                 ; 00101010
-  closure-header                    ; 00101110
-  funcallable-instance-header       ; 00110010
+  simple-fun-header-widetag                 ; 00101010
+  closure-header-widetag                    ; 00101110
+  funcallable-instance-header-widetag       ; 00110010
 
-  return-pc-header                  ; 00110110
-  value-cell-header                 ; 00111010
-  symbol-header                     ; 00111110
-  character                         ; 01000010
-  sap                               ; 01000110
-  unbound-marker                    ; 01001010
-  weak-pointer                      ; 01001110
-  instance-header                   ; 01010010
-  fdefn                             ; 01010110
+  return-pc-header-widetag                  ; 00110110
+  value-cell-header-widetag                 ; 00111010
+  symbol-header-widetag                     ; 00111110
+  character-widetag                         ; 01000010
+  sap-widetag                               ; 01000110
+  unbound-marker-widetag                    ; 01001010
+  weak-pointer-widetag                      ; 01001110
+  instance-header-widetag                   ; 01010010
+  fdefn-widetag                             ; 01010110
 
-  no-tls-value-marker               ; 01011010
+  no-tls-value-marker-widetag               ; 01011010
   #!-(and sb-lutex sb-thread)
-  unused01
+  unused01-widetag
   #!+(and sb-lutex sb-thread)
-  lutex                             ; 01011110
-  unused02                          ; 01100010
-  unused03                          ; 01100110
-  unused04                          ; 01101010
-  unused05                          ; 01101110
-  unused06                          ; 01110010
-  unused07                          ; 01110110
+  lutex-widetag                             ; 01011110
+  unused02-widetag                          ; 01100010
+  unused03-widetag                          ; 01100110
+  unused04-widetag                          ; 01101010
+  unused05-widetag                          ; 01101110
+  unused06-widetag                          ; 01110010
+  unused07-widetag                          ; 01110110
   #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
-  unused08                          ; 01111010
+  unused08-widetag                          ; 01111010
   #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
-  unused09                          ; 01111110
+  unused09-widetag                          ; 01111110
 
   #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
-  unused10                          ; 10000010
+  unused10-widetag                          ; 10000010
   #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
-  unused11                          ; 10000110
+  unused11-widetag                          ; 10000110
 
-  simple-array-unsigned-byte-2      ; 10001010
-  simple-array-unsigned-byte-4      ; 10001110
-  simple-array-unsigned-byte-7      ; 10010010
-  simple-array-unsigned-byte-8      ; 10010110
-  simple-array-unsigned-byte-15     ; 10011010
-  simple-array-unsigned-byte-16     ; 10011110
-  simple-array-nil                  ; 10100010
-  simple-base-string                ; 10100110
-  #!+sb-unicode simple-character-string
-  simple-bit-vector                 ; 10101010
-  simple-vector                     ; 10101110
+  simple-array-unsigned-byte-2-widetag      ; 10001010
+  simple-array-unsigned-byte-4-widetag      ; 10001110
+  simple-array-unsigned-byte-7-widetag      ; 10010010
+  simple-array-unsigned-byte-8-widetag      ; 10010110
+  simple-array-unsigned-byte-15-widetag     ; 10011010
+  simple-array-unsigned-byte-16-widetag     ; 10011110
+  simple-array-nil-widetag                  ; 10100010
+  simple-base-string-widetag                ; 10100110
+  #!+sb-unicode simple-character-string-widetag
+  simple-bit-vector-widetag                 ; 10101010
+  simple-vector-widetag                     ; 10101110
   #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
-  simple-array-unsigned-byte-29     ; 10110010
-  simple-array-unsigned-byte-31     ; 10110110
-  simple-array-unsigned-byte-32     ; 10111010
+  simple-array-unsigned-byte-29-widetag     ; 10110010
+  simple-array-unsigned-byte-31-widetag     ; 10110110
+  simple-array-unsigned-byte-32-widetag     ; 10111010
   #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
-  simple-array-unsigned-byte-60
+  simple-array-unsigned-byte-60-widetag
   #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
-  simple-array-unsigned-byte-63
+  simple-array-unsigned-byte-63-widetag
   #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
-  simple-array-unsigned-byte-64
-  simple-array-signed-byte-8        ; 10111110
-  simple-array-signed-byte-16       ; 11000010
+  simple-array-unsigned-byte-64-widetag
+  simple-array-signed-byte-8-widetag        ; 10111110
+  simple-array-signed-byte-16-widetag       ; 11000010
   #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
-  simple-array-signed-byte-30       ; 11000110
-  simple-array-signed-byte-32       ; 11001010
+  simple-array-signed-byte-30-widetag       ; 11000110
+  simple-array-signed-byte-32-widetag       ; 11001010
   #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
-  simple-array-signed-byte-61
+  simple-array-signed-byte-61-widetag
   #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
-  simple-array-signed-byte-64
-  simple-array-single-float         ; 11001110
-  simple-array-double-float         ; 11010010
-  simple-array-complex-single-float ; 11010110
-  simple-array-complex-double-float ; 11011010
-  simple-array                      ; 11011110
-  complex-vector-nil                ; 11100010
-  complex-base-string               ; 11100110
-  #!+sb-unicode complex-character-string
-  complex-bit-vector                ; 11101010
-  complex-vector                    ; 11101110
-  complex-array                     ; 11110010
+  simple-array-signed-byte-64-widetag
+  simple-array-single-float-widetag         ; 11001110
+  simple-array-double-float-widetag         ; 11010010
+  simple-array-complex-single-float-widetag ; 11010110
+  simple-array-complex-double-float-widetag ; 11011010
+  simple-array-widetag                      ; 11011110
+  complex-vector-nil-widetag                ; 11100010
+  complex-base-string-widetag               ; 11100110
+  #!+sb-unicode complex-character-string-widetag
+  complex-bit-vector-widetag                ; 11101010
+  complex-vector-widetag                    ; 11101110
+  complex-array-widetag                     ; 11110010
 
   #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
-  unused12                          ; 11110110
+  unused12-widetag                          ; 11110110
   #!+(and #.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
           (not sb-unicode))
-  unused13                          ; 11111010
+  unused13-widetag                          ; 11111010
   #!+(and #.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
           (not sb-unicode))
-  unused14                          ; 11111110
+  unused14-widetag                          ; 11111110
 )
 
 ;;; the different vector subtypes
-(defenum (:prefix vector- :suffix -subtype)
-  normal
-  unused
-  valid-hashing)
+(defenum ()
+  vector-normal-subtype
+  vector-unused-subtype
+  vector-valid-hashing-subtype)

diff --git a/src/compiler/generic/parms.lisp b/src/compiler/generic/parms.lisp
index 9b9a3a6..6bb0e77 100644 (file)
--- a/src/compiler/generic/parms.lisp
+++ b/src/compiler/generic/parms.lisp
@@ -80,3 +80,9 @@
 ;;; Number of entries in the thread local storage. Limits the number
 ;;; of symbols with thread local bindings.
 (def!constant tls-size 4096)
+
+(defenum ()
+  trace-table-normal
+  trace-table-call-site
+  trace-table-fun-prologue
+  trace-table-fun-epilogue)

diff --git a/src/compiler/hppa/parms.lisp b/src/compiler/hppa/parms.lisp
index 8cec2ba..61d6e71 100644 (file)
--- a/src/compiler/hppa/parms.lisp
+++ b/src/compiler/hppa/parms.lisp
@@ -87,29 +87,21 @@
 \f
 ;;;; Other random constants.
 
-(defenum (:suffix -flag)
-  atomic
-  interrupted)
-
-(defenum (:suffix -trap :start 8)
-  halt
-  pending-interrupt
-  error
-  cerror
-  breakpoint
-  fun-end-breakpoint
-  single-step-breakpoint
-  single-step-around
-  single-step-before
-  single-step-after)
-
-(defenum (:prefix trace-table-)
-  normal
-  call-site
-  fun-prologue
-  fun-epilogue)
-
-
+(defenum ()
+  atomic-flag
+  interrupted-flag)
+
+(defenum (:start 8)
+  halt-trap
+  pending-interrupt-trap
+  error-trap
+  cerror-trap
+  breakpoint-trap
+  fun-end-breakpoint-trap
+  single-step-breakpoint-trap
+  single-step-around-trap
+  single-step-before-trap
+  single-step-after-trap)
 \f
 ;;;; Static symbols.
 

diff --git a/src/compiler/mips/parms.lisp b/src/compiler/mips/parms.lisp
index 5d6f495..703d887 100644 (file)
--- a/src/compiler/mips/parms.lisp
+++ b/src/compiler/mips/parms.lisp
@@ -113,30 +113,24 @@
 \f
 ;;;; Other non-type constants.
 
-(defenum (:suffix -flag)
-  atomic
-  interrupted)
-
-(defenum (:suffix -trap :start 8)
-  halt
-  pending-interrupt
-  error
-  cerror
-  breakpoint
-  fun-end-breakpoint
-  after-breakpoint
-  unused
-  pseudo-atomic
-  object-not-list
-  object-not-instance
-  single-step-around
-  single-step-before)
-
-(defenum (:prefix trace-table-)
-  normal
-  call-site
-  fun-prologue
-  fun-epilogue)
+(defenum ()
+  atomic-flag
+  interrupted-flag)
+
+(defenum (:start 8)
+  halt-trap
+  pending-interrupt-trap
+  error-trap
+  cerror-trap
+  breakpoint-trap
+  fun-end-breakpoint-trap
+  after-breakpoint-trap
+  unused-trap
+  pseudo-atomic-trap
+  object-not-list-trap
+  object-not-instance-trap
+  single-step-around-trap
+  single-step-before-trap)
 \f
 ;;;; Static symbols.
 

diff --git a/src/compiler/ppc/parms.lisp b/src/compiler/ppc/parms.lisp
index c644978..1e443b4 100644 (file)
--- a/src/compiler/ppc/parms.lisp
+++ b/src/compiler/ppc/parms.lisp
@@ -153,28 +153,21 @@
 \f
 ;;;; Other miscellaneous constants.
 
-(defenum (:suffix -trap :start 8)
-  halt
-  pending-interrupt
-  error
-  cerror
-  breakpoint
-  fun-end-breakpoint
-  after-breakpoint
-  fixnum-additive-overflow
-  single-step-around
-  single-step-before)
-
-(defenum (:prefix object-not- :suffix -trap :start 24)
-  list
-  instance)
-
-(defenum (:prefix trace-table-)
-  normal
-  call-site
-  fun-prologue
-  fun-epilogue)
-
+(defenum (:start 8)
+  halt-trap
+  pending-interrupt-trap
+  error-trap
+  cerror-trap
+  breakpoint-trap
+  fun-end-breakpoint-trap
+  after-breakpoint-trap
+  fixnum-additive-overflow-trap
+  single-step-around-trap
+  single-step-before-trap)
+
+(defenum (:start 24)
+  object-not-list-trap
+  object-not-instance-trap)
 \f
 ;;;; Static symbols.
 

diff --git a/src/compiler/sparc/parms.lisp b/src/compiler/sparc/parms.lisp
index 4ddb3cd..402db7c 100644 (file)
--- a/src/compiler/sparc/parms.lisp
+++ b/src/compiler/sparc/parms.lisp
@@ -148,26 +148,20 @@
 \f
 ;;;; other random constants.
 
-(defenum (:suffix -trap :start 8)
-  halt
-  pending-interrupt
-  error
-  cerror
-  breakpoint
-  fun-end-breakpoint
-  after-breakpoint
-  single-step-around
-  single-step-before)
-
-(defenum (:prefix object-not- :suffix -trap :start 24)
-  list
-  instance)
-
-(defenum (:prefix trace-table-)
-  normal
-  call-site
-  fun-prologue
-  fun-epilogue)
+(defenum (:start 8)
+  halt-trap
+  pending-interrupt-trap
+  error-trap
+  cerror-trap
+  breakpoint-trap
+  fun-end-breakpoint-trap
+  after-breakpoint-trap
+  single-step-around-trap
+  single-step-before-trap)
+
+(defenum (:start 24)
+  object-not-list-trap
+  object-not-instance-trap)
 \f
 ;;;; static symbols.
 

diff --git a/src/compiler/x86-64/parms.lisp b/src/compiler/x86-64/parms.lisp
index 648a7fa..9a02977 100644 (file)
--- a/src/compiler/x86-64/parms.lisp
+++ b/src/compiler/x86-64/parms.lisp
@@ -126,32 +126,19 @@
 \f
 ;;;; other miscellaneous constants
 
-(defenum (:suffix -trap :start 8)
-  halt
-  pending-interrupt
-  error
-  cerror
-  breakpoint
-  fun-end-breakpoint
-  single-step-around
-  single-step-before)
-;;; 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)
-;;;     ..)
-;;; for the benefit of anyone doing a lexical search for definitions
-;;; of these symbols.
-
-(defenum (:prefix object-not- :suffix -trap :start 24)
-  list
-  instance)
-
-(defenum (:prefix trace-table-)
-  normal
-  call-site
-  fun-prologue
-  fun-epilogue)
+(defenum (:start 8)
+  halt-trap
+  pending-interrupt-trap
+  error-trap
+  cerror-trap
+  breakpoint-trap
+  fun-end-breakpoint-trap
+  single-step-around-trap
+  single-step-before-trap)
+
+(defenum (:start 24)
+  object-not-list-trap
+  object-not-instance-trap)
 \f
 ;;;; static symbols
 

diff --git a/src/compiler/x86/parms.lisp b/src/compiler/x86/parms.lisp
index 8e0623c..b3aadec 100644 (file)
--- a/src/compiler/x86/parms.lisp
+++ b/src/compiler/x86/parms.lisp
@@ -277,32 +277,19 @@
 \f
 ;;;; other miscellaneous constants
 
-(defenum (:suffix -trap :start 8)
-  halt
-  pending-interrupt
-  error
-  cerror
-  breakpoint
-  fun-end-breakpoint
-  single-step-around
-  single-step-before)
-;;; 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)
-;;;     ..)
-;;; for the benefit of anyone doing a lexical search for definitions
-;;; of these symbols.
-
-(defenum (:prefix object-not- :suffix -trap :start 24)
-  list
-  instance)
-
-(defenum (:prefix trace-table-)
-  normal
-  call-site
-  fun-prologue
-  fun-epilogue)
+(defenum (:start 8)
+  halt-trap
+  pending-interrupt-trap
+  error-trap
+  cerror-trap
+  breakpoint-trap
+  fun-end-breakpoint-trap
+  single-step-around-trap
+  single-step-before-trap)
+
+(defenum (:start 24)
+  object-not-list-trap
+  object-not-instance-trap)
 \f
 ;;;; static symbols
 

diff --git a/version.lisp-expr b/version.lisp-expr
index 4876374..cf2aa32 100644 (file)
--- a/version.lisp-expr
+++ b/version.lisp-expr
@@ -17,4 +17,4 @@
 ;;; checkins which aren't released. (And occasionally for internal
 ;;; versions, especially for internal versions off the main CVS
 ;;; branch, it gets hairier, e.g. "0.pre7.14.flaky4.13".)
-"1.0.28.30"
+"1.0.28.31"