anchor.diff:  (defmacro define-command (name parms (&rest arg-descripters) &body body)
     (let ((gcmd (gensym (symbol-name name))))
       `(progn
  -       (pushnew ,(string-downcase (symbol-name name)) *command-names*)
  -       (setf (get ',name 'command) ',gcmd)
  +       (setf (gethash ,(string-downcase (symbol-name name))
  +                      *command-table*)
  +             ',gcmd)
          (defun ,name ,parms ,@body)
          ,(define-command-gen-cmd gcmd parms arg-descripters body))))
   
   (defun cmd-call (cmd arg)
  -  (funcall (get cmd 'command) arg))
  +  (funcall (gethash (string-downcase (symbol-name cmd))
  +                    *command-table*)
  +           arg))
   
   (defun command-completion (str)
  -  (completion str *command-names*))
  +  (let ((names))
  +    (maphash #'(lambda (name cmd)
  +                 (declare (ignore cmd))
  +                 (push name names))
  +             *command-table*)
  +    (completion str (nreverse names))))
   
   (defun exist-command-p (str)
  -  (find str *command-names* :test 'equal))
  +  (if (gethash str *command-table*) t nil))
   
   (define-key *global-keymap* (kbd "M-x") 'execute-command)
   (define-command execute-command (name)
  
positive.code:           execute-command
            apropos-command))
  
  (defvar *command-names* nil)
  
  (eval-when (:compile-toplevel :load-toplevel)
    (let ((garg (gensym "ARG")))
  
negative.code:           ""
            'command-completion
            'exist-command-p)))
    (let ((cmd (gethash name *command-table*)))
      (funcall cmd *universal-argument*)))
  
  (define-command apropos-command (str) ("sApropos: ")
    (info-popup (get-buffer-create "*Apropos*")
                #'(lambda (out)
                    (maphash #'(lambda (name cmd)
                                 (declare (ignore cmd))
                                 (when (search str name)
                                   (loop
                                     for (kbd keymap-name)
                                     in (search-keybind-all name)
                                     do
                                     (fresh-line out)
                                     (princ (format nil "~a~a~a~a~a"
                                                    name
                                                    #\tab
                                                    (kbd-to-string kbd)
                                                    #\tab
                                                    keymap-name)
                                            out))))
                             *command-table*))))
  