anchor.diff:  (defmacro define-command (name parms (&rest arg-descripters) &body body)
     (let ((gcmd (gensym (symbol-name name)))
           (command-name (string-downcase name)))
  -    `(progn
  -       (setf (get ',name 'command) ',gcmd)
  -       (setf (get ',gcmd 'name) ,command-name)
  -       (setf (gethash ,command-name *command-table*) (cons ',gcmd ',name))
  -       (defun ,name ,parms ,@body)
  -       ,(define-command-gen-cmd gcmd name parms arg-descripters)
  -       ',name)))
  +    (alexandria:with-unique-names (universal-argument)
  +      `(progn
  +         (setf (get ',name 'command) ',gcmd)
  +         (setf (get ',gcmd 'name) ,command-name)
  +         (setf (gethash ,command-name *command-table*) (cons ',gcmd ',name))
  +         (defun ,name ,parms ,@body)
  +         (defun ,gcmd (,universal-argument)
  +           (declare (ignorable ,universal-argument))
  +           ,(gen-defcommand-body
  +             name
  +             parms
  +             universal-argument
  +             arg-descripters))
  +         ',name))))
  +
   
   (defun all-command-names ()
     (alexandria:hash-table-keys *command-table*))
  
positive.code: (defvar *command-table* (make-hash-table :test 'equal))
  
  (eval-when (:compile-toplevel :load-toplevel)
    (defun define-command-gen-args (garg arg-descripters)
      (cond
        ((string= "p" (car arg-descripters))
         `(list (or ,garg 1)))
        ((string= "P" (car arg-descripters))
         `(list ,garg))
        ((string= "r" (car arg-descripters))
         `(progn
            (check-marked)
  
negative.code:                             (error "Illegal arg-descripter: ~a" arg-descripter))))
                       arg-descripters)))))
  
    (alexandria:with-unique-names (arguments)
      (defun gen-defcommand-body (fn-name
                                          parms
                                          universal-argument
                                          arg-descripters)
        `(block ,fn-name
           ,(if (null arg-descripters)
                (progn
                  (assert (null parms))
                  `(,fn-name))
                `(destructuring-bind (&rest ,arguments)
                     ,(if (stringp (car arg-descripters))
                          (gen-defcommand-arg-parser universal-argument arg-descripters)
                          (car arg-descripters))
                   (apply #',fn-name ,arguments)))))))
  
  (defun find-command (name)
    (car (gethash name *command-table*)))
  