X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Fmacros.lisp;h=fe11e84033953ede66d8fe362d70592cacee9a08;hb=aa61c7571b33b86981301f34d3acdb66666f53a3;hp=c55f1b9995fa2adae3511b7f6ae4db2ce0670604;hpb=334af30b26555f0bf706f7157b399bdbd4fad548;p=sbcl.git

diff --git a/src/code/macros.lisp b/src/code/macros.lisp
index c55f1b9..fe11e84 100644
--- a/src/code/macros.lisp
+++ b/src/code/macros.lisp
@@ -56,47 +56,34 @@
 ;;;
 ;;; FIXME: In reality, this restart cruft is needed hardly anywhere in
 ;;; the system. Write NEED and NEED-TYPE to replace ASSERT and
-;;; CHECK-TYPE inside the system.
+;;; CHECK-TYPE inside the system. (CL:CHECK-TYPE must still be
+;;; defined, since it's specified by ANSI and it is sometimes nice for
+;;; whipping up little things. But as far as I can tell it's not
+;;; usually very helpful deep inside the guts of a complex system like
+;;; SBCL.)
 ;;;
 ;;; CHECK-TYPE-ERROR isn't defined until a later file because it uses
 ;;; the macro RESTART-CASE, which isn't defined until a later file.
 (defmacro-mundanely check-type (place type &optional type-string)
   #!+sb-doc
-  "Signals a restartable error of type TYPE-ERROR if the value of PLACE is
+  "Signal a restartable error of type TYPE-ERROR if the value of PLACE is
   not of the specified type. If an error is signalled and the restart is
-  used to return, the
-  return if the
-   STORE-VALUE is invoked. It will store into PLACE and start over."
+  used to return, this can only return if the STORE-VALUE restart is
+  invoked. In that case it will store into PLACE and start over."
   (let ((place-value (gensym)))
-    `(do ((,place-value ,place))
+    `(do ((,place-value ,place ,place))
 	 ((typep ,place-value ',type))
        (setf ,place
 	     (check-type-error ',place ,place-value ',type ,type-string)))))
-
-#!+high-security-support
-(defmacro-mundanely check-type-var (place type-var &optional type-string)
-  #!+sb-doc
-  "Signals an error of type TYPE-ERROR if the contents of PLACE are not of the
-   specified type to which the TYPE-VAR evaluates. If an error is signaled,
-   this can only return if STORE-VALUE is invoked. It will store into PLACE
-   and start over."
-  (let ((place-value (gensym))
-	(type-value (gensym)))
-    `(do ((,place-value ,place)
-	  (,type-value  ,type-var))
-	 ((typep ,place-value ,type-value))
-       (setf ,place
-	     (check-type-error ',place ,place-value ,type-value ,type-string)))))
 
 ;;;; DEFCONSTANT
 
 (defmacro-mundanely defconstant (name value &optional documentation)
   #!+sb-doc
-  "For defining global constants. DEFCONSTANT says 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 init, the code is not portable
-  (undefined behavior). The third argument is an optional documentation
-  string for the variable."
+  "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)))
 
@@ -104,7 +91,11 @@
 (defun sb!c::%defconstant (name value doc)
   (unless (symbolp name)
     (error "The constant name is not a symbol: ~S" name))
-  (about-to-modify 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
@@ -137,7 +128,6 @@
   ;; will be cross-compiled correctly.
   #-sb-xc-host (setf (symbol-value name) value)
   #+sb-xc-host (progn
-		 (/show (symbol-package name))
 		 ;; Redefining our cross-compilation host's CL symbols
 		 ;; would be poor form.
 		 ;;
@@ -186,8 +176,8 @@
 		   ;; 2001-03-24
 		   (eval `(defconstant ,name ',value))))
 
-  (setf (info :variable :kind name) :constant)
-  (setf (info :variable :constant-value name) value)
+  (setf (info :variable :kind name) :constant
+	(info :variable :constant-value name) value)
   name)
 
 ;;;; DEFINE-COMPILER-MACRO
@@ -208,16 +198,11 @@
 			:environment environment)
       (let ((def `(lambda (,whole ,environment)
 		    ,@local-decs
-		    (block ,(function-name-block-name name)
+		    (block ,(fun-name-block-name name)
 		      ,body))))
 	`(sb!c::%define-compiler-macro ',name #',def ',lambda-list ,doc)))))
 (defun sb!c::%define-compiler-macro (name definition lambda-list doc)
-  ;; FIXME: Why does this have to be an interpreted function? Shouldn't
-  ;; it get compiled?
-  (aver (sb!eval:interpreted-function-p definition))
-  (setf (sb!eval:interpreted-function-name definition)
-	(format nil "DEFINE-COMPILER-MACRO ~S" name))
-  (setf (sb!eval:interpreted-function-arglist definition) lambda-list)
+  (declare (ignore lambda-list))
   (sb!c::%%define-compiler-macro name definition doc))
 (defun sb!c::%%define-compiler-macro (name definition doc)
   (setf (sb!xc:compiler-macro-function name) definition)
@@ -428,7 +413,7 @@
 
 (defmacro-mundanely nth-value (n form)
   #!+sb-doc
-  "Evaluates FORM and returns the Nth value (zero based). This involves no
+  "Evaluate FORM and return the Nth value (zero based). This involves no
   consing when N is a trivial constant integer."
   (if (integerp n)
       (let ((dummy-list nil)
@@ -452,29 +437,23 @@
   #!+sb-doc
   "DECLAIM Declaration*
   Do a declaration or declarations for the global environment."
-  #-sb-xc-host
   `(eval-when (:compile-toplevel :load-toplevel :execute)
-     ,@(mapcar #'(lambda (x)
-		   `(sb!xc:proclaim ',x))
-	       specs))
-  ;; KLUDGE: The definition above doesn't work in the cross-compiler,
-  ;; because UNCROSS translates SB!XC:PROCLAIM into CL:PROCLAIM before
-  ;; the form gets executed. Instead, we have to explicitly do the
-  ;; proclamation at macroexpansion time. -- WHN ca. 19990810
-  ;;
-  ;; FIXME: Maybe we don't need this special treatment any more now
-  ;; that we're using DEFMACRO-MUNDANELY instead of DEFMACRO?
-  #+sb-xc-host (progn
-		 (mapcar #'sb!xc:proclaim specs)
-		 `(progn
-		    ,@(mapcar #'(lambda (x)
-				  `(sb!xc:proclaim ',x))
-			      specs))))
+     ,@(mapcar (lambda (spec) `(sb!xc:proclaim ',spec))
+	       specs)))
 
-(defmacro-mundanely print-unreadable-object ((object stream
-					      &key type identity)
+(defmacro-mundanely print-unreadable-object ((object stream &key type identity)
 					     &body body)
+  "Output OBJECT to STREAM with \"#<\" prefix, \">\" suffix, optionally
+  with object-type prefix and object-identity suffix, and executing the
+  code in BODY to provide possible further output."
   `(%print-unreadable-object ,object ,stream ,type ,identity
 			     ,(if body
 				  `#'(lambda () ,@body)
 				  nil)))
+
+(defmacro-mundanely ignore-errors (&rest forms)
+  #!+sb-doc
+  "Execute FORMS handling ERROR conditions, returning the result of the last
+  form, or (VALUES NIL the-ERROR-that-was-caught) if an ERROR was handled."
+  `(handler-case (progn ,@forms)
+     (error (condition) (values nil condition))))