anchor.diff:           (option-arg?
             (lambda (arg)
               (or
  -             (zero? (find "--dialect" arg))
  -             (zero? (find "-bd" arg))
  -             (zero? (find "--backup-dir" arg))
  -             (zero? (find "-nb" arg))
  -             (zero? (find "--no-backup" arg))
  -             (zero? (find "-nc" arg))
  -             (zero? (find "--no-compact" arg))
  -             (zero? (find "-no" arg))
  -             (zero? (find "--no-output" arg))
  -             (zero? (find "-nm" arg))
  -             (zero? (find "--no-modify" arg))
  -             (zero? (find "-uni" arg))
  -             (zero? (find "--uniform" arg))
  -             (zero? (find "-ic" arg))
  -             (zero? (find "--indent-comments" arg)))))
  +             (matches-opt? "-dialect" arg)
  +             (matches-opt? "-bd" arg)
  +             (matches-opt? "-backup-dir" arg)
  +             (matches-opt? "-nb" arg)
  +             (matches-opt? "-no-backup" arg)
  +             (matches-opt? "-nc" arg)
  +             (matches-opt? "-no-compact" arg)
  +             (matches-opt? "-no" arg)
  +             (matches-opt? "-no-output" arg)
  +             (matches-opt? "-nm" arg)
  +             (matches-opt? "-no-modify" arg)
  +             (matches-opt? "-uni" arg)
  +             (matches-opt? "-uniform" arg)
  +             (matches-opt? "-ic" arg)
  +             (matches-opt? "-indent-comments" arg))))
            (option-list?
             (lambda (lst)
               (and
  
positive.code:   "Exits if the filename provided does not exist"
    (if (file? filename)
        (read-file filename)
      (warning "--%s-- Exiting. Filename `%s' is not valid"
               ;; Exit if the filename is invalid
               (list (current-time) filename))))
  
  
  (define (current-time)
  
negative.code:              (bool? (lst [warning]))
               (bool? (lst [modify])))))
           (options (list (real-path) 1 "" '() nil nil true true true true nil))
           (matches-opt? (lambda (opt var)
                          (letn ((dashes (find "^-+" opt 0)))
                           (and (if dashes
                                 (or (= (length $0) 2) (= (length $0) 1))
                                 nil) (find opt var)))))
           (arguments
            (if (string? arguments)
                (parse arguments)
  