anchor.diff:     (long
       :initarg  :long
       :accessor long
  -    :documentation "NIL or long char - long variant of the option")
  +    :documentation "NIL or string - long variant of the option")
      (arg-parser
       :initarg  :arg-parser
       :accessor arg-parser
  -    :documentation "if not NIL, this options requires an argument, it will
  -be parsed with this function")
  +    :documentation "if not NIL, this option requires an argument, it will be
  +parsed with this function")
      (meta-var
       :initarg  :meta-var
       :accessor meta-var
  
positive.code:   ((name
      :initarg  :name
      :accessor name
      :documentation "keyword that will be included in list returned by GET
  function if this option is given by user")
     (description
      :initarg  :description
      :accessor description
  
negative.code:   #+lispworks system:*line-arguments-list*
    #+sbcl      sb-ext:*posix-argv*)
  
  (defun get-opts (&optional options)
    "Parse command line options. If OPTIONS is given, it should be a list to
  parse. If it's not given, the function will use ARGV function to get list of
  command line arguments. Return two values: list that contains keywords
  associated with command line options with DEFINE-OPTS macro, and list of
  free arguments. If some option requires an argument, you can use GETF to
  test presence of the option and get its argument if the option is present.
  
  The parser may signal various conditions, let's list them all specifying
  which restarts are available for every condition, and what kind of
  information the programmer can extract from the conditions.
  
  UNKNOWN-OPTION is thrown when parser encounters unknown (not previously
  defined with DEFINE-OPTS) option. Use OPTION reader to get name of the
  option (string). Available restarts: USE-VALUE (substitute the option and
  try again), SKIP-OPTION (ignore the option).
  
  MISSING-ARG is thrown when some option wants an argument, but there is no
  such argument given. Use OPTION reader to get name of the
  option (string). Available restarts: USE-VALUE (supplied value will be
  used), SKIP-OPTION (ignore the option).
  
  ARG-PARSER-FAILED is thrown when some option wants an argument, it's given
  but cannot be parsed by argument parser. Use OPTION reader to get name of
  the option (string) and RAW-ARG to get raw string representing the argument
  before parsing. Available restarts: USE-VALUE (supplied value will be used),
  SKIP-OPTION (ignore the option), REPARSE-ARG (supplied string will be parsed
  instead)."
    (flet ((split-short-opts (arg)
             (if (and (> (length arg) 1)
                      (char=  #\- (char arg 0))
                      (char/= #\- (char arg 1)))
                 (mapcar (lambda (c) (format nil "-~c" c))
                         (cdr (coerce arg 'list)))
                 (list arg)))
           (shortp (opt)
             (and (= (length opt) 2)
                  (char=  #\- (char opt 0))))
           (longp (opt)
             (and (> (length opt) 2)
                  (char= #\- (char opt 0))
                  (char= #\- (char opt 1)))))
      (do ((tokens (mapcan #'split-short-opts
                           (or options (cdr (argv))))
                   (cdr tokens))
           pending-arg ; don't forget about --file=blah syntax
           result)
          ((null tokens) (nreverse result))
        (let ((item (car tokens)))
          nil))))
  
  (defun describe (&key prefix suffix (stream *standard-output*))
    "Return string describing options of the program that were defined with
  