anchor.diff:                            (rest body)
                             body)))
       `(progn
  -       (register-option (wrap-option-function ',(cons main-name other-names)
  -                                              ',parameters
  -                                              ',docstring
  -                                              (lambda ,(remove '&rest parameters)
  -                                                ,docstring
  -                                                (block ,lisp-name
  -                                                  ,@body)))
  +       (register-option ,(generate-wrap-option-function 
  +                          (cons main-name other-names)
  +                          parameters
  +                          docstring
  +                          `(lambda ,(remove '&rest parameters)
  +                             ,docstring
  +                             (block ,lisp-name
  +                               ,@body)))
                           t)
          ',lisp-name)))
   
  
positive.code:               ;; linux sysexits:
                ((or arithmetic-error parse-error print-not-readable type-error) (err)
                  (format *error-output* "~%ERROR: ~A~%" err)
                 (parse-options-finish ex-dataerr))
                ((or cell-error control-error package-error program-error) (err)
                  (format *error-output* "~%ERROR: ~A~%" err)
                 (parse-options-finish ex-software))
                (file-error (err)
                  (format *error-output* "~%ERROR: ~A~%" err)
                  (parse-options-finish ex-osfile))
  
negative.code: (defun q&d-parse-parameters (parameters)
    "Parses (mandatory &optional optionals... &rest rest &key key...)"
    (loop
      :with mandatories = '()
      :with optionals   = '()
      :with rest        = nil
      :with keys        = '()
      :with state       = :mandatory
      :with params      = parameters
      :for param = (first params)
      :while params
      :do (ecase state
            ((:mandatory)
             (case param
               ((&optional) (setf state :optional))
               ((&rest)     (setf state :rest))
               ((&key)      (setf state :key))
               (otherwise (push param mandatories)))
             (pop params))
            ((:optional)
             (case param
               ((&optional) (error "&OPTIONAL given more than once in ~S" parameters))
               ((&rest)     (setf state :rest))
               ((&key)      (setf state :key))
               (otherwise (push param optionals)))
             (pop params))
            ((:rest)
             (case param
               ((&optional) (error "&OPTIONAL given after &REST in ~S" parameters))
               ((&rest)     (error "&REST given twice in ~S" parameters))
               ((&key)      (setf state :key))
               (otherwise   (setf state :after-rest
                                  rest param)))
             (pop params))
            ((:after-rest)
             (case param
               ((&optional) (error "&OPTIONAL given after &REST in ~S" parameters))
               ((&rest)     (error "&REST given after &REST in ~S" parameters))
               ((&key)      (setf state :key))
               (otherwise   (error "Several &REST parameters given in ~S" parameters)))
             (pop params))
            ((:key)
             (case param
               ((&optional) (error "&OPTIONAL given after &KEY in ~S" parameters))
               ((&rest)     (error "&REST given after &KEY in ~S" parameters))
               ((&key)      (setf state :key))
               (otherwise   (push param keys)))
             (pop params)))
      :finally (return (values (nreverse mandatories)
                               (nreverse optionals)
                               rest
                               (nreverse keys)))))
  
  
  (defun keywordize (string-designator)
  