anchor.diff:                           (let ((new-table (make-hash-table :test 'equal)))
                              (setf (gethash k table) new-table)
                              (setf table new-table))))))))
  +
  +(defun parse-key (string)
  +  (labels ((f (string)
  +             (if (and (>= (length string) 2)
  +                      (eql (aref string 0) #\M)
  +                      (eql (aref string 1) #\-))
  +                 (cons (keyname->keychar "escape") (f (subseq string 2)))
  +                 (list (keyname->keychar string)))))
  +    (mapcan #'(lambda (string)
  +                (if (and (< 4 (length string))
  +                         (string= string "C-M-" :end1 4))
  +                    (f (concatenate 'string
  +                                    "M-C-" (subseq string 4)))
  +                    (f string)))
  +            (uiop:split-string string :separator " "))))
   
   (defun kbd-to-string (key)
     (format nil "~{~A~^~}"
  
positive.code:                 collect (cond ((not (cdr c-))"")
                                ((char= c (keyname->keychar "escape")) "-")
                                (t " ")))))
  
  (defun kbd-string-1 (str)
    (if (and (>= (length str) 2)
             (eql (aref str 0) #\M)
             (eql (aref str 1) #\-))
        (cons (keyname->keychar "escape") (kbd-string-1 (subseq str 2)))
        (list (keyname->keychar str))))
  
  (defun kbd-string (str)
    (make-kbd
     (mapcan #'(lambda (str)
                 (if (and (< 4 (length str))
                          (string= str "C-M-" :end1 4))
                     (kbd-string-1 (concatenate 'string
                                                "M-C-" (subseq str 4)))
                     (kbd-string-1 str)))
             (uiop:split-string str :separator " "))))
  
  (defun kbd-keys (keys)
    (make-kbd keys))
  
  (defun kbd (string-or-first-key &rest keys)
    (etypecase string-or-first-key
      (string
       (kbd-string string-or-first-key))
      (character
       (kbd-keys (cons string-or-first-key keys)))))
  
  (defun keymap-find-keybind (keymap key)
    (let ((table (keymap-table keymap)))
  
negative.code:       (get-command cmd))))
  
  (defun abort-key-p (key)
    (and (characterp key)
         (eq 'keyboard-quit (lookup-keybind key))))
  