X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Fmacros.lisp;h=f14e8e28bc0481eba5c53aa2e53a1478f68535e8;hb=3d9d3088982414ca5617caf62bd37b4fecac29b6;hp=adceea0222929580e8a68b8a115b2766fe7cf9d4;hpb=8731c1a7c1a585d190151fa881050fb5e14c0616;p=sbcl.git

diff --git a/src/code/macros.lisp b/src/code/macros.lisp
index adceea0..f14e8e2 100644
--- a/src/code/macros.lisp
+++ b/src/code/macros.lisp
@@ -104,15 +104,30 @@
 
 ;;;; DEFINE-COMPILER-MACRO
 
-;;; FIXME: The logic here for handling compiler macros named (SETF
-;;; FOO) was added after the fork from SBCL, is not well tested, and
-;;; may conflict with subtleties of the ANSI standard. E.g. section
-;;; "3.2.2.1 Compiler Macros" says that creating a lexical binding for
-;;; a function name shadows a compiler macro, and it's not clear that
-;;; that works with this version. It should be tested.
 (defmacro-mundanely define-compiler-macro (name lambda-list &body body)
   #!+sb-doc
   "Define a compiler-macro for NAME."
+  (legal-fun-name-or-type-error name)
+  (when (consp name)
+    ;; It's fairly clear that the user intends the compiler macro to
+    ;; expand when he does (SETF (FOO ...) X). And that's even a
+    ;; useful and reasonable thing to want. Unfortunately,
+    ;; (SETF (FOO ...) X) macroexpands into (FUNCALL (SETF FOO) X ...),
+    ;; and it's not at all clear that it's valid to expand a FUNCALL form,
+    ;; and the ANSI standard doesn't seem to say anything else which
+    ;; would justify us expanding the compiler macro the way the user
+    ;; wants. So instead we rely on 3.2.2.1.3 "When Compiler Macros Are
+    ;; Used" which says they never have to be used, so by ignoring such
+    ;; macros we're erring on the safe side. But any user who does
+    ;; (DEFINE-COMPILER-MACRO (SETF FOO) ...) could easily be surprised
+    ;; by this way of complying with a rather screwy aspect of the ANSI
+    ;; spec, so at least we can warn him...
+    (sb!c::compiler-style-warn
+     "defining compiler macro of (SETF ...), which will not be expanded"))
+  (when (and (symbolp name) (special-operator-p name))
+    (error 'simple-program-error
+	   :format-control "cannot define a compiler-macro for a special operator: ~S"
+	   :format-arguments (list name)))
   (let ((whole (gensym "WHOLE-"))
 	(environment (gensym "ENV-")))
     (multiple-value-bind (body local-decs doc)
@@ -121,19 +136,45 @@
       (let ((def `(lambda (,whole ,environment)
 		    ,@local-decs
 		    (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)
-  (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)
-  ;; FIXME: Add support for (SETF FDOCUMENTATION) when object is a list
-  ;; and type is COMPILER-MACRO. (Until then, we have to discard any
-  ;; compiler macro documentation for (SETF FOO).)
-  (unless (listp name)
-    (setf (fdocumentation name 'compiler-macro) doc))
-  name)
+		      ,body)))
+	    (debug-name (debug-namify "DEFINE-COMPILER-MACRO ~S" name)))
+	`(eval-when (:compile-toplevel :load-toplevel :execute)
+	  (sb!c::%define-compiler-macro ',name #',def ',lambda-list ,doc ,debug-name))))))
+
+;;; FIXME: This will look remarkably similar to those who have already
+;;; seen the code for %DEFMACRO in src/code/defmacro.lisp.  Various
+;;; bits of logic should be shared (notably arglist setting).
+(macrolet
+    ((def (times set-p)
+	 `(eval-when (,@times)
+	   (defun sb!c::%define-compiler-macro
+	       (name definition lambda-list doc debug-name)
+	     ,@(unless set-p
+		 '((declare (ignore lambda-list debug-name))))
+	     ;; FIXME: warn about incompatible lambda list with
+	     ;; respect to parent function?
+	     (setf (sb!xc:compiler-macro-function name) definition)
+	     ;; FIXME: Add support for (SETF FDOCUMENTATION) when
+	     ;; object is a list and type is COMPILER-MACRO. (Until
+	     ;; then, we have to discard any compiler macro
+	     ;; documentation for (SETF FOO).)
+	     (unless (listp name)
+	       (setf (fdocumentation name 'compiler-macro) doc))
+	     ,(when set-p
+		    `(case (widetag-of definition)
+                      (#.sb!vm:closure-header-widetag
+                       (setf (%simple-fun-arglist (%closure-fun definition))
+                             lambda-list
+			     (%simple-fun-name (%closure-fun definition))
+			     debug-name))
+                      ((#.sb!vm:simple-fun-header-widetag
+                        #.sb!vm:closure-fun-header-widetag)
+                       (setf (%simple-fun-arglist definition) lambda-list
+			     (%simple-fun-name definition) debug-name))))
+	     name))))
+  (progn
+    (def (:load-toplevel :execute) #-sb-xc-host t #+sb-xc-host nil)
+    (def (:compile-toplevel) nil)))
 
 ;;;; CASE, TYPECASE, and friends
 
@@ -156,16 +197,22 @@
   (let ((keyform-value (gensym))
 	(clauses ())
 	(keys ()))
-    (dolist (case cases)
+    (do* ((cases cases (cdr cases))
+	  (case (car cases) (car cases)))
+	 ((null cases) nil)
       (unless (list-of-length-at-least-p case 1)
 	(error "~S -- bad clause in ~S" case name))
       (destructuring-bind (keyoid &rest forms) case
-	(cond ((memq keyoid '(t otherwise))
+	(cond ((and (memq keyoid '(t otherwise))
+		    (null (cdr cases)))
 	       (if errorp
-		   (error 'simple-program-error
-			  :format-control
-			  "No default clause is allowed in ~S: ~S"
-			  :format-arguments (list name case))
+		   (progn
+		     (style-warn "~@<Treating bare ~A in ~A as introducing a ~
+                                  normal-clause, not an otherwise-clause~@:>"
+				 keyoid name)
+		     (push keyoid keys)
+		     (push `((,test ,keyform-value ',keyoid) nil ,@forms)
+			   clauses))
 		   (push `(t nil ,@forms) clauses)))
 	      ((and multi-p (listp keyoid))
 	       (setf keys (append keyoid keys))