anchor.diff:  (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)))))
  +    :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)
  
positive.code:                           (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)))
                          t)
         ',lisp-name)))
  
  
negative.code: "
    (let ((verror  (gensym))
          (voutput (gensym)))
      `(let* ((,verror  nil)
              (,voutput (with-output-to-string (stream)
                          (let ((*standard-output* stream)
                                (*error-output*    stream)
                                (*trace-output*    stream))
                            (handler-case (progn ,@body)
                              (error (err) (setf ,verror err)))))))
         (when ,verror
           (terpri *error-output*)
           (princ ,voutput *error-output*)
           (terpri *error-output*)
           (princ ,verror *error-output*)
           (terpri *error-output*)
           (terpri *error-output*)
           #-testing-script (parse-options-finish ex-software)))))
  
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  