anchor.diff:                        ;; No characters after the equal sign (no directory specified)
                         (setq (options [backup-dir]) (backup-dir-pair 1))
                       (setq (options [backup-dir]) (join (rest lst) "=")))))
  -              (case curr
  -                ("-nc" (setq (options [compact]) nil))
  -                ("--no-compact" (setq (options [compact]) nil))
  -                ("-nb" (setq (options [backup]) nil))
  -                ("--no-backup" (setq (options [backup]) nil))
  -                ("-nm" (setq (options [modify]) nil))
  -                ("--no-modify" (setq (options [modify]) nil))
  -                ("-uni" (setq (options [uniform]) true))
  -                ("--uniform" (setq (options [uniform]) true))
  -                ("-ic" (setq (options [indent-comments]) true))
  -                ("--indent-commens" (setq (options [indent-comments]) true))
  -                ("--no-warning" (setq (options [warning]) nil))
  -                ("--nw" (setq (options [warning]) nil))
  -                ("--help" (print-help))
  -                ("--h" (print-help))
  -                ("-h" (print-help)))
  +              (cond
  +                ((matches-opt? "-nc" curr) (setq (options [compact]) nil))
  +                ((matches-opt? "-no-compact" curr) (setq (options [compact]) nil))
  +                ((matches-opt? "-nb" curr) (setq (options [backup]) nil))
  +                ((matches-opt? "-no-backup" curr) (setq (options [backup]) nil))
  +                ((matches-opt? "-nm" curr) (setq (options [modify]) nil))
  +                ((matches-opt? "-no-modify" curr) (setq (options [modify]) nil))
  +                ((matches-opt? "-uni" curr) (setq (options [uniform]) true))
  +                ((matches-opt? "-uniform" curr) (setq (options [uniform]) true))
  +                ((matches-opt? "-ic" curr) (setq (options [indent-comments]) true))
  +                ((matches-opt? "-indent-commens" curr) (setq (options [indent-comments]) true))
  +                ((matches-opt? "-no-warning" curr) (setq (options [warning]) nil))
  +                ((matches-opt? "-nw" curr) (setq (options [warning]) nil))
  +                ((matches-opt? "-help" curr) (print-help))
  +                ((matches-opt? "-h" curr) (print-help)))
                 )))
         options))))
   
  
positive.code:               (unless (empty? curr)
                  (push curr (options [files])))
              (let ((indent-pair
                     (if (or (and (null? (find "--default-indent" prev))
                                  (zero? (find "--default-indent" curr)))
                             (and (null? (find "-di" prev))
                                  (zero? (find "-di" curr))))
                         ;; The "--backup-dir" string is at the end of the arg list
                         (list curr "")
                       (if (or (zero? (find "--di" prev))
                               (zero? (find "--default-indent" prev)))
                           (list prev curr)
                         (list "" ""))))
                    (backup-dir-pair
                     (if (or (and (null? (find "--backup-dir" prev))
                                  (zero? (find "--backup-dir" curr)))
                             (and (null? (find "-bd" prev))
                                  (zero? (find "-bd" curr))))
                         ;; The "--backup-dir" string is at the end of the arg list
                         (list curr "")
                       (if (or (zero? (find "-bd" prev))
                               (zero? (find "--backup-dir" prev)))
                           (list prev curr)
                         (list "" ""))))
                    (dialect-pair
  
negative.code:              (bool? (lst [warning]))
               (bool? (lst [modify])))))
           (options (list (real-path) 1 "" '() nil nil true true true true nil))
           (zero-or-one? (lambda (num) (or (zero? num) (= num 1))))
           (matches-opt? (lambda (opt var) (zero-or-one? (find opt var))))
           (arguments
            (if (string? arguments)
                (parse arguments)
  