X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fmacros.lisp;h=e51c8eb3f3aa4a65f6e613a0f5102d00e07eccba;hb=683874b497a99cd2c11b6c5d9b47e2785b1ede5f;hp=8591b38f15c46f82dcc18452af18cb850ee83598;hpb=6879a37a9e6cceeab810636c5ef4a4da1444e275;p=sbcl.git

diff --git a/src/compiler/macros.lisp b/src/compiler/macros.lisp
index 8591b38..e51c8eb 100644
--- a/src/compiler/macros.lisp
+++ b/src/compiler/macros.lisp
@@ -100,7 +100,7 @@
 ;;; If the desirability of the transformation depends on the current
 ;;; OPTIMIZE parameters, then the POLICY macro should be used to
 ;;; determine when to pass.
-(defmacro def-source-transform (name lambda-list &body body)
+(defmacro define-source-transform (name lambda-list &body body)
   (let ((fn-name
 	 (if (listp name)
 	     (collect ((pieces))
@@ -124,23 +124,6 @@
 	     ,@decls
 	     ,body))
 	 (setf (info :function :source-transform ',name) #',fn-name)))))
-
-;;; Define a function that converts a use of (%PRIMITIVE NAME ..)
-;;; into Lisp code. LAMBDA-LIST is a DEFMACRO-style lambda list.
-(defmacro def-primitive-translator (name lambda-list &body body)
-  (let ((fn-name (symbolicate "PRIMITIVE-TRANSLATE-" name))
-	(n-form (gensym))
-	(n-env (gensym)))
-    (multiple-value-bind (body decls)
-	(parse-defmacro lambda-list n-form body name "%primitive"
-			:environment n-env
-			:error-fun 'convert-condition-into-compiler-error)
-      `(progn
-	 (defun ,fn-name (,n-form)
-	   (let ((,n-env *lexenv*))
-	     ,@decls
-	     ,body))
-	 (setf (gethash ',name *primitive-translators*) ',fn-name)))))
 
 ;;;; boolean attribute utilities
 ;;;;
@@ -532,9 +515,9 @@
 
 ;;; Create a function which parses combination args according to WHAT
 ;;; and LAMBDA-LIST, where WHAT is either a function name or a list
-;;; (FUNCTION-NAME KIND) and does some KIND of optimization.
+;;; (FUN-NAME KIND) and does some KIND of optimization.
 ;;;
-;;; The FUNCTION-NAME must name a known function. LAMBDA-LIST is used
+;;; The FUN-NAME must name a known function. LAMBDA-LIST is used
 ;;; to parse the arguments to the combination as in DEFTRANSFORM. If
 ;;; the argument syntax is invalid or there are non-constant keys,
 ;;; then we simply return NIL.
@@ -594,7 +577,7 @@
 			(block-next ,block-var)))
 	   ((eq ,block-var ,n-tail) ,result)
 	 ,@body))))
-;;; like Do-Blocks, only iterating over the blocks in reverse order
+;;; like DO-BLOCKS, only iterating over the blocks in reverse order
 (defmacro do-blocks-backwards ((block-var component &optional ends result) &body body)
   (unless (member ends '(nil :head :tail :both))
     (error "losing ENDS value: ~S" ends))
@@ -629,12 +612,12 @@
 			   ,result)
 	  ,@body)))))
 
-;;; Iterate over the nodes in Block, binding Node-Var to the each node
-;;; and Cont-Var to the node's Cont. The only keyword option is
-;;; Restart-P, which causes iteration to be restarted when a node is
+;;; Iterate over the nodes in BLOCK, binding NODE-VAR to the each node
+;;; and CONT-VAR to the node's CONT. The only keyword option is
+;;; RESTART-P, which causes iteration to be restarted when a node is
 ;;; deleted out from under us. (If not supplied, this is an error.)
 ;;;
-;;; In the forward case, we terminate on Last-Cont so that we don't
+;;; In the forward case, we terminate on LAST-CONT so that we don't
 ;;; have to worry about our termination condition being changed when
 ;;; new code is added during the iteration. In the backward case, we
 ;;; do NODE-PREV before evaluating the body so that we can keep going
@@ -736,15 +719,15 @@
 
 (defstruct (event-info (:copier nil))
   ;; The name of this event.
-  (name (required-argument) :type symbol)
+  (name (missing-arg) :type symbol)
   ;; The string rescribing this event.
-  (description (required-argument) :type string)
+  (description (missing-arg) :type string)
   ;; The name of the variable we stash this in.
-  (var (required-argument) :type symbol)
+  (var (missing-arg) :type symbol)
   ;; The number of times this event has happened.
   (count 0 :type fixnum)
   ;; The level of significance of this event.
-  (level (required-argument) :type unsigned-byte)
+  (level (missing-arg) :type unsigned-byte)
   ;; If true, a function that gets called with the node that the event
   ;; happened to.
   (action nil :type (or function null)))