X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fearly-c.lisp;h=978284fccaeaeeae89980b0fbde3b4c5ea127cff;hb=c1aa8b6b5b870f21bc8c81da85708e9d71d4eb93;hp=11f7176506034bca93edd8db73cd9d212e000fd9;hpb=bea5b384106a6734a4b280a76e8ebdd4d51b5323;p=sbcl.git

diff --git a/src/compiler/early-c.lisp b/src/compiler/early-c.lisp
index 11f7176..978284f 100644
--- a/src/compiler/early-c.lisp
+++ b/src/compiler/early-c.lisp
@@ -16,16 +16,16 @@
 (in-package "SB!C")
 
 ;;; ANSI limits on compilation
-(def!constant sb!xc:call-arguments-limit most-positive-fixnum
+(def!constant sb!xc:call-arguments-limit sb!xc:most-positive-fixnum
   #!+sb-doc
   "The exclusive upper bound on the number of arguments which may be passed
   to a function, including &REST args.")
-(def!constant sb!xc:lambda-parameters-limit most-positive-fixnum
+(def!constant sb!xc:lambda-parameters-limit sb!xc:most-positive-fixnum
   #!+sb-doc
   "The exclusive upper bound on the number of parameters which may be specifed
   in a given lambda list. This is actually the limit on required and &OPTIONAL
   parameters. With &KEY and &AUX you can get more.")
-(def!constant sb!xc:multiple-values-limit most-positive-fixnum
+(def!constant sb!xc:multiple-values-limit sb!xc:most-positive-fixnum
   #!+sb-doc
   "The exclusive upper bound on the number of multiple VALUES that you can
   return.")
@@ -129,6 +129,9 @@
 (defvar *big-compiler-lock*
   (sb!thread:make-mutex :name "big compiler lock"))
 
+(declaim (type fixnum *compiler-sset-counter*))
+(defvar *compiler-sset-counter* 0)
+
 ;;; unique ID for the next object created (to let us track object
 ;;; identity even across GC, useful for understanding weird compiler
 ;;; bugs where something is supposed to be unique but is instead
@@ -138,7 +141,7 @@
   (defvar *object-id-counter* 0)
   (defun new-object-id ()
     (prog1
-	*object-id-counter*
+        *object-id-counter*
       (incf *object-id-counter*))))
 
 ;;;; miscellaneous utilities
@@ -147,16 +150,16 @@
 ;;; benefit of the compiler, but it's sometimes called from stuff like
 ;;; type-defining code which isn't logically part of the compiler.
 (declaim (ftype (function ((or symbol cons) keyword) (values))
-		note-name-defined))
+                note-name-defined))
 (defun note-name-defined (name kind)
   ;; We do this BOUNDP check because this function can be called when
   ;; not in a compilation unit (as when loading top level forms).
   (when (boundp '*undefined-warnings*)
     (setq *undefined-warnings*
-	  (delete-if (lambda (x)
-		       (and (equal (undefined-warning-name x) name)
-			    (eq (undefined-warning-kind x) kind)))
-		     *undefined-warnings*)))
+          (delete-if (lambda (x)
+                       (and (equal (undefined-warning-name x) name)
+                            (eq (undefined-warning-kind x) kind)))
+                     *undefined-warnings*)))
   (values))
 
 ;;; to be called when a variable is lexically bound
@@ -190,7 +193,7 @@ convention (names like *FOO*) for special variables" symbol))
                    ((or symbol number string)
                     x)
                    (t
-                    (format nil "#<~S>" (type-of x))))
+                    (list 'of-type (type-of x))))
                  "#<...>")))
     ;; FIXME: It might be nice to put markers in the tree instead of
     ;; this #<...> business, so that they would evantually be printed