lisp/dired-x.el

   1 ;;; dired-x.el --- Sebastian Kremer's Extra DIRED hacked up for GNU Emacs19
   2
   3 ;; Author: Sebastian Kremer <sk@thp.uni-koeln.de>
   4 ;;      Lawrence R. Dodd <dodd@roebling.poly.edu>
   5 ;; Maintainer: Lawrence R. Dodd <dodd@roebling.poly.edu>
   6 ;; Version: 2.37+
   7 ;; Date: 1994/08/18 19:27:42
   8 ;; Keywords: dired extensions
   9
  10 ;; Copyright (C) 1993, 1994 Free Software Foundation
  11
  12 ;; This file is part of GNU Emacs.
  13
  14 ;; GNU Emacs is free software; you can redistribute it and/or modify
  15 ;; it under the terms of the GNU General Public License as published by
  16 ;; the Free Software Foundation; either version 2, or (at your option)
  17 ;; any later version.
  18
  19 ;; GNU Emacs is distributed in the hope that it will be useful,
  20 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 ;; GNU General Public License for more details.
  23
  24 ;; You should have received a copy of the GNU General Public License
  25 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  26 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  27 ;; Boston, MA 02111-1307, USA.
  28
  29 ;;; Commentary:
  30
  31 ;; This is Sebastian Kremer's excellent dired-x.el (Dired Extra), version
  32 ;; 1.191, hacked up for GNU Emacs 19.  Redundant or conflicting material
  33 ;; has been removed or renamed in order to work properly with dired of
  34 ;; GNU Emacs 19.  All suggestions or comments are most welcomed.
  35
  36 ;;
  37 ;; Please, PLEASE, *PLEASE* see the info pages.
  38 ;;
  39
  40 ;; BUGS: Type M-x dired-x-submit-report and a report will be generated.
  41
  42 ;; INSTALLATION: In your ~/.emacs,
  43 ;;
  44 ;; (add-hook 'dired-load-hook
  45 ;;           (function (lambda ()
  46 ;;                       (load "dired-x")
  47 ;;                       ;; Set global variables here.  For example:
  48 ;;                       ;; (setq dired-guess-shell-gnutar "gtar")
  49 ;;                       )))
  50 ;; (add-hook 'dired-mode-hook
  51 ;;           (function (lambda ()
  52 ;;                       ;; Set buffer-local variables here.  For example:
  53 ;;                       ;; (setq dired-omit-files-p t)
  54 ;;                       )))
  55 ;;
  56 ;; At load time dired-x.el will install itself, redefine some functions, and
  57 ;; bind some dired keys.  *Please* see the info pages for more details.
  58
  59 ;; CAUTION: If you are using a version of GNU Emacs earlier than 19.20 than
  60 ;; you may have to edit dired.el.  The copy of dired.el in GNU Emacs versions
  61 ;; earlier than 19.20 incorrectly had the call to run-hooks *before* the call
  62 ;; to provide.  In such a case, it is possible that byte-compiling and/or
  63 ;; loading dired can cause an infinite loop.  To prevent this, make sure the
  64 ;; line of code
  65 ;;
  66 ;;         (run-hooks 'dired-load-hook)
  67 ;;
  68 ;; is the *last* executable line in the file dired.el.  That is, make sure it
  69 ;; comes *after* the line
  70 ;;
  71 ;;         (provide 'dired)
  72 ;;
  73 ;; *Please* see the info pages for more details.
  74
  75 ;; User defined variables:
  76 ;;
  77 ;;      dired-bind-vm
  78 ;;      dired-vm-read-only-folders
  79 ;;      dired-bind-jump
  80 ;;      dired-bind-info
  81 ;;      dired-bind-man
  82 ;;      dired-x-hands-off-my-keys
  83 ;;      dired-find-subdir
  84 ;;      dired-enable-local-variables
  85 ;;      dired-local-variables-file
  86 ;;      dired-guess-shell-gnutar
  87 ;;      dired-guess-shell-gzip-quiet
  88 ;;      dired-guess-shell-znew-switches
  89 ;;      dired-guess-shell-alist-user
  90 ;;      dired-clean-up-buffers-too
  91 ;;      dired-omit-files-p
  92 ;;      dired-omit-files
  93 ;;      dired-omit-extensions
  94 ;;      dired-omit-size-limit
  95 ;;
  96 ;; To find out more about these variables, load this file, put your cursor at
  97 ;; the end of any of the variable names, and hit C-h v [RET].  *Please* see
  98 ;; the info pages for more details.
  99
 100 ;; When loaded this code redefines the following functions of GNU Emacs
 101 ;;
 102 ;;   Function                         Found in this file of GNU Emacs
 103 ;;   --------                         -------------------------------
 104 ;;   dired-clean-up-after-deletion    ../lisp/dired.el
 105 ;;   dired-find-buffer-nocreate       ../lisp/dired.el
 106 ;;   dired-initial-position           ../lisp/dired.el
 107 ;;
 108 ;;   dired-add-entry                  ../lisp/dired-aux.el
 109 ;;   dired-read-shell-command         ../lisp/dired-aux.el
 110 ;;
 111 ;; One drawback is that dired-x.el will load dired-aux.el as soon as dired is
 112 ;; loaded.  Thus, the advantage of separating out non-essential dired stuff
 113 ;; into dired-aux.el and only loading when necessary will be lost.  Please
 114 ;; note also that some of the comments in dired.el and dired-aux.el are
 115 ;; Kremer's that referred to the old dired-x.el.  This now should be referring
 116 ;; to this program.  (This is also a good reason to call this dired-x.el
 117 ;; instead of dired-x19.el.)
 118
 119 \f
 120 ;;; Code:
 121
 122 ;; LOAD.
 123
 124 ;; This is a no-op if dired-x is being loaded via `dired-load-hook'.  It is
 125 ;; here in case the user has autoloaded dired-x via the dired-jump key binding
 126 ;; (instead of autoloading to dired as is suggested in the info-pages).
 127
 128 (require 'dired)
 129
 130 ;; We will redefine some functions and also need some macros so we need to
 131 ;; load dired stuff of GNU Emacs.
 132
 133 (require 'dired-aux)
 134
 135 ;;; User-defined variables.
 136
 137 (defvar dired-bind-vm nil
 138   "*t says \"V\" in dired-mode will `dired-vm', otherwise \"V\" is `dired-rmail'.
 139 Also, RMAIL files contain -*- rmail -*- at the top so \"f\",
 140 `dired-advertised-find-file', will run rmail.")
 141
 142 (defvar dired-bind-jump t
 143   "*t says bind `dired-jump' to C-x C-j, otherwise do not.")
 144
 145 (defvar dired-bind-man t
 146   "*t says bind `dired-man' to \"N\" in dired-mode, otherwise do not.")
 147
 148 (defvar dired-bind-info t
 149   "*t says bind `dired-info' to \"I\" in dired-mode, otherwise do not.")
 150
 151 (defvar dired-vm-read-only-folders nil
 152   "*If t, \\[dired-vm] will visit all folders read-only.
 153 If neither nil nor t, e.g. the symbol `if-file-read-only', only
 154 files not writable by you are visited read-only.
 155
 156 Read-only folders only work in VM 5, not in VM 4.")
 157
 158 (defvar dired-omit-files-p nil
 159   "*If non-nil, \"uninteresting\" files are not listed (buffer-local).
 160 Use \\[dired-omit-toggle] to toggle its value.
 161 Uninteresting files are those whose filenames match regexp `dired-omit-files',
 162 plus those ending with extensions in `dired-omit-extensions'.")
 163 (make-variable-buffer-local 'dired-omit-files-p)
 164
 165 (defvar dired-omit-files "^#\\|^\\.$\\|^\\.\\.$"
 166   "*Filenames matching this regexp will not be displayed.
 167 This only has effect when `dired-omit-files-p' is t.  See interactive function
 168 `dired-omit-toggle' \(\\[dired-omit-toggle]\) and variable
 169 `dired-omit-extensions'.  The default is to omit  `.', `..', and auto-save
 170 files.")
 171
 172 (defvar dired-omit-size-limit 20000
 173   "*If a dired buffer listing contains more than this many characters,
 174 do not do omitting.  If nil, always do omitting.")
 175
 176 (defvar dired-find-subdir nil           ; t is pretty near to DWIM...
 177   "*If non-nil, Dired always finds a directory in a buffer of its own.
 178 If nil, Dired finds the directory as a subdirectory in some other buffer
 179 if it is present as one.
 180
 181 If there are several Dired buffers for a directory, the most recently
 182 used is chosen.
 183
 184 Dired avoids switching to the current buffer, so that if you have
 185 a normal and a wildcard buffer for the same directory, C-x d RET will
 186 toggle between those two.")
 187
 188 (defvar dired-enable-local-variables t
 189   "*Control use of local-variables lists in dired.
 190 The value can be t, nil or something else.
 191 A value of t means local-variables lists are obeyed;
 192 nil means they are ignored; anything else means query.
 193
 194 This temporarily overrides the value of `enable-local-variables' when listing
 195 a directory.  See also `dired-local-variables-file'.")
 196
 197 (defvar dired-guess-shell-gnutar nil
 198   "*If non-nil, name of GNU tar executable (e.g., \"tar\" or \"gtar\") and `z'
 199 switch will be used for compressed or gzip'ed tar files.  If no GNU tar, set
 200 to nil: a pipe using `zcat' or `gunzip -c' will be used.")
 201
 202 (defvar dired-guess-shell-gzip-quiet t
 203   "*non-nil says pass -q to gzip overriding verbose GZIP environment.")
 204
 205 (defvar dired-guess-shell-znew-switches nil
 206   "*If non-nil, then string of switches passed to `znew', example: \"-K\"")
 207
 208 (defvar dired-clean-up-buffers-too t
 209   "*t says offer to kill buffers visiting files and dirs deleted in dired.")
 210
 211 ;;; KEY BINDINGS.
 212
 213 (define-key dired-mode-map "\M-o" 'dired-omit-toggle)
 214 (define-key dired-mode-map "\M-(" 'dired-mark-sexp)
 215 (define-key dired-mode-map "*(" 'dired-mark-sexp)
 216 (define-key dired-mode-map "*." 'dired-mark-extension)
 217 (define-key dired-mode-map "\M-!" 'dired-smart-shell-command)
 218 (define-key dired-mode-map "T" 'dired-do-toggle)
 219 (define-key dired-mode-map "*t" 'dired-do-toggle)
 220 (define-key dired-mode-map "w" 'dired-copy-filename-as-kill)
 221 (define-key dired-mode-map "\M-g" 'dired-goto-file)
 222 (define-key dired-mode-map "\M-G" 'dired-goto-subdir)
 223 (define-key dired-mode-map "F" 'dired-do-find-marked-files)
 224 (define-key dired-mode-map "Y"  'dired-do-relsymlink)
 225 (define-key dired-mode-map "%Y" 'dired-do-relsymlink-regexp)
 226 (define-key dired-mode-map "V" 'dired-do-run-mail)
 227
 228 (if dired-bind-man
 229     (define-key dired-mode-map "N" 'dired-man))
 230
 231 (if dired-bind-info
 232     (define-key dired-mode-map "I" 'dired-info))
 233
 234 ;;; GLOBAL BINDING.
 235 (if dired-bind-jump
 236     (progn
 237       (define-key global-map "\C-x\C-j" 'dired-jump)
 238       (define-key global-map "\C-x4\C-j" 'dired-jump-other-window)))
 239
 240 \f
 241 ;;; Install into appropriate hooks.
 242
 243 (add-hook 'dired-mode-hook 'dired-extra-startup)
 244 (add-hook 'dired-after-readin-hook 'dired-omit-expunge)
 245
 246 (defun dired-extra-startup ()
 247   "Automatically put on dired-mode-hook to get extra dired features:
 248 \\<dired-mode-map>
 249
 250   \\[dired-do-run-mail]\t-- run mail on folder (see `dired-bind-vm')
 251   \\[dired-info]\t-- run info on file
 252   \\[dired-man]\t-- run man on file
 253   \\[dired-do-find-marked-files]\t-- visit all marked files simultaneously
 254   \\[dired-omit-toggle]\t-- toggle omitting of files
 255   \\[dired-do-toggle]\t-- toggle marks
 256   \\[dired-mark-sexp]\t-- mark by lisp expression
 257   \\[dired-copy-filename-as-kill]\t-- copy the file or subdir names into the kill ring.
 258   \t   You can feed it to other commands using \\[yank].
 259
 260 For more features, see variables
 261
 262   dired-bind-vm
 263   dired-bind-jump
 264   dired-bind-info
 265   dired-bind-man
 266   dired-vm-read-only-folders
 267   dired-omit-files-p
 268   dired-omit-files
 269   dired-omit-extensions
 270   dired-omit-size-limit
 271   dired-find-subdir
 272   dired-enable-local-variables
 273   dired-local-variables-file
 274   dired-guess-shell-gnutar
 275   dired-guess-shell-gzip-quiet
 276   dired-guess-shell-znew-switches
 277   dired-guess-shell-alist-user
 278   dired-clean-up-buffers-too
 279
 280 See also functions
 281
 282   dired-flag-extension
 283   dired-virtual
 284   dired-jump
 285   dired-man
 286   dired-vm
 287   dired-rmail
 288   dired-info
 289   dired-do-find-marked-files
 290 "
 291   (interactive)
 292
 293   ;; These must be done in each new dired buffer.
 294   (dired-hack-local-variables)
 295   (dired-omit-startup))
 296
 297 \f
 298 ;;; BUFFER CLEANING.
 299
 300 ;; REDEFINE.
 301 (defun dired-clean-up-after-deletion (fn)
 302
 303   ;; Clean up after a deleted file or directory FN.
 304   ;; Remove expanded subdir of deleted dir, if any.
 305   (save-excursion (and (cdr dired-subdir-alist)
 306                        (dired-goto-subdir fn)
 307                        (dired-kill-subdir)))
 308
 309   ;; Offer to kill buffer of deleted file FN.
 310   (if dired-clean-up-buffers-too
 311       (progn
 312         (let ((buf (get-file-buffer fn)))
 313           (and buf
 314                (funcall (function y-or-n-p)
 315                         (format "Kill buffer of %s, too? "
 316                                 (file-name-nondirectory fn)))
 317                (save-excursion ; you never know where kill-buffer leaves you
 318                  (kill-buffer buf))))
 319         (let ((buf-list (dired-buffers-for-dir (expand-file-name fn)))
 320               (buf nil))
 321           (and buf-list
 322                (y-or-n-p (format "Kill dired buffer%s of %s, too? "
 323                                  (dired-plural-s (length buf-list))
 324                                  (file-name-nondirectory fn)))
 325                (while buf-list
 326                  (save-excursion (kill-buffer (car buf-list)))
 327                  (setq buf-list (cdr buf-list)))))))
 328   ;; Anything else?
 329   )
 330
 331 \f
 332 ;;; EXTENSION MARKING FUNCTIONS.
 333
 334 ;;; Mark files with some extension.
 335 (defun dired-mark-extension (extension &optional marker-char)
 336   "Mark all files with a certain extension for use in later commands.
 337 A `.' is not automatically prepended to the string entered."
 338   ;; EXTENSION may also be a list of extensions instead of a single one.
 339   ;; Optional MARKER-CHAR is marker to use.
 340   (interactive "sMarking extension: \nP")
 341   (or (listp extension)
 342       (setq extension (list extension)))
 343   (dired-mark-files-regexp
 344    (concat ".";; don't match names with nothing but an extension
 345            "\\("
 346            (mapconcat 'regexp-quote extension "\\|")
 347            "\\)$")
 348    marker-char))
 349
 350 (defun dired-flag-extension (extension)
 351   "In dired, flag all files with a certain extension for deletion.
 352 A `.' is *not* automatically prepended to the string entered."
 353   (interactive "sFlagging extension: ")
 354   (dired-mark-extension extension dired-del-marker))
 355
 356 ;;; Define some unpopular file extensions.  Used for cleaning and omitting.
 357
 358 (defvar dired-patch-unclean-extensions
 359   '(".rej" ".orig")
 360   "List of extensions of dispensable files created by the `patch' program.")
 361
 362 (defvar dired-tex-unclean-extensions
 363   '(".toc" ".log" ".aux");; these are already in completion-ignored-extensions
 364   "List of extensions of dispensable files created by TeX.")
 365
 366 (defvar dired-latex-unclean-extensions
 367   '(".idx" ".lof" ".lot" ".glo")
 368   "List of extensions of dispensable files created by LaTeX.")
 369
 370 (defvar dired-bibtex-unclean-extensions
 371   '(".blg" ".bbl")
 372   "List of extensions of dispensable files created by BibTeX.")
 373
 374 (defvar dired-texinfo-unclean-extensions
 375   '(".cp" ".cps" ".fn" ".fns" ".ky" ".kys" ".pg" ".pgs"
 376     ".tp" ".tps" ".vr" ".vrs")
 377   "List of extensions of dispensable files created by texinfo.")
 378
 379 (defun dired-clean-patch ()
 380   "Flag dispensable files created by patch for deletion.
 381 See variable `dired-patch-unclean-extensions'."
 382   (interactive)
 383   (dired-flag-extension dired-patch-unclean-extensions))
 384
 385 (defun dired-clean-tex ()
 386   "Flag dispensable files created by [La]TeX etc. for deletion.
 387 See variables `dired-texinfo-unclean-extensions',
 388 `dired-latex-unclean-extensions', `dired-bibtex-unclean-extensions' and
 389 `dired-texinfo-unclean-extensions'."
 390   (interactive)
 391   (dired-flag-extension (append dired-texinfo-unclean-extensions
 392                                 dired-latex-unclean-extensions
 393                                 dired-bibtex-unclean-extensions
 394                                 dired-tex-unclean-extensions)))
 395
 396 (defun dired-very-clean-tex ()
 397   "Flag dispensable files created by [La]TeX *and* \".dvi\" for deletion.
 398 See variables `dired-texinfo-unclean-extensions',
 399 `dired-latex-unclean-extensions', `dired-bibtex-unclean-extensions' and
 400 `dired-texinfo-unclean-extensions'."
 401   (interactive)
 402   (dired-flag-extension (append dired-texinfo-unclean-extensions
 403                                 dired-latex-unclean-extensions
 404                                 dired-bibtex-unclean-extensions
 405                                 dired-tex-unclean-extensions
 406                                 (list ".dvi"))))
 407 \f
 408 ;;; JUMP.
 409
 410 ;;;###autoload
 411 (defun dired-jump (&optional other-window)
 412   "Jump to dired buffer corresponding to current buffer.
 413 If in a file, dired the current directory and move to file's line.
 414 If in dired already, pop up a level and goto old directory's line.
 415 In case the proper dired file line cannot be found, refresh the dired
 416 buffer and try again."
 417   (interactive "P")
 418   (let* ((file buffer-file-name)
 419          (dir (if file (file-name-directory file) default-directory)))
 420     (if (eq major-mode 'dired-mode)
 421         (progn
 422           (setq dir (dired-current-directory))
 423           (dired-up-directory other-window)
 424           (or (dired-goto-file dir)
 425               ;; refresh and try again
 426               (progn
 427                 (dired-insert-subdir (file-name-directory dir))
 428                 (dired-goto-file dir))))
 429       (if other-window
 430           (dired-other-window dir)
 431         (dired dir))
 432       (if file
 433           (or (dired-goto-file file)
 434               ;; refresh and try again
 435               (progn
 436                 (dired-insert-subdir (file-name-directory file))
 437                 (dired-goto-file file))
 438               ;; Toggle omitting, if it is on, and try again.
 439               (if dired-omit-files-p
 440                   (progn
 441                     (dired-omit-toggle)
 442                     (dired-goto-file file))))))))
 443
 444 (defun dired-jump-other-window ()
 445   "Like \\[dired-jump] (dired-jump) but in other window."
 446   (interactive)
 447   (dired-jump t))
 448 \f
 449 ;;; TOGGLE.
 450 ;;; Toggle marked files with unmarked files.
 451
 452 (defun dired-do-toggle ()
 453   "Toggle marks.
 454 That is, currently marked files become unmarked and vice versa.
 455 Files marked with other flags (such as `D') are not affected.
 456 `.' and `..' are never toggled.
 457 As always, hidden subdirs are not affected."
 458   (interactive)
 459   (save-excursion
 460     (goto-char (point-min))
 461     (let (buffer-read-only)
 462       (while (not (eobp))
 463         (or (dired-between-files)
 464             (looking-at dired-re-dot)
 465             ;; use subst instead of insdel because it does not move
 466             ;; the gap and thus should be faster and because
 467             ;; other characters are left alone automatically
 468             (apply 'subst-char-in-region
 469                    (point) (1+ (point))
 470                    (if (eq ?\040 (following-char)) ; SPC
 471                        (list ?\040 dired-marker-char)
 472                      (list dired-marker-char ?\040))))
 473         (forward-line 1)))))
 474
 475 \f
 476 ;;; COPY NAMES OF MARKED FILES INTO KILL-RING.
 477
 478 (defun dired-copy-filename-as-kill (&optional arg)
 479   "Copy names of marked (or next ARG) files into the kill ring.
 480 The names are separated by a space.
 481 With a zero prefix arg, use the complete pathname of each marked file.
 482 With \\[universal-argument], use the relative pathname of each marked file.
 483
 484 If on a subdir headerline, use subdirname instead; prefix arg is ignored
 485 in this case.
 486
 487 You can then feed the file name(s) to other commands with \\[yank]."
 488   (interactive "P")
 489   (let ((string
 490          (or (dired-get-subdir)
 491              (mapconcat (function identity)
 492                         (if arg
 493                             (cond ((zerop (prefix-numeric-value arg))
 494                                    (dired-get-marked-files))
 495                                   ((integerp arg)
 496                                    (dired-get-marked-files 'no-dir arg))
 497                                   (t    ; else a raw arg
 498                                    (dired-get-marked-files t)))
 499                           (dired-get-marked-files 'no-dir))
 500                         " "))))
 501     (kill-new string)
 502     (message "%s" string)))
 503
 504 \f
 505 ;;; OMITTING.
 506
 507 ;;; Enhanced omitting of lines from directory listings.
 508 ;;; Marked files are never omitted.
 509
 510 ;; should probably get rid of this and always use 'no-dir.
 511 ;; sk 28-Aug-1991 09:37
 512 (defvar dired-omit-localp 'no-dir
 513   "The LOCALP argument dired-omit-expunge passes to dired-get-filename.
 514 If it is 'no-dir, omitting is much faster, but you can only match
 515 against the basename of the file.  Set it to nil if you need to match the
 516 whole pathname.")
 517
 518 ;; \017=^O for Omit - other packages can chose other control characters.
 519 (defvar dired-omit-marker-char ?\017
 520   "Temporary marker used by by dired-omit.
 521 Should never be used as marker by the user or other packages.")
 522
 523 (defun dired-omit-startup ()
 524   (or (assq 'dired-omit-files-p minor-mode-alist)
 525       (setq minor-mode-alist
 526             (append '((dired-omit-files-p " Omit")) minor-mode-alist))))
 527
 528 (defun dired-omit-toggle (&optional flag)
 529   "Toggle omitting files matching `dired-omit-files' and `dired-omit-extensions'.
 530 With an arg, and if omitting was off, don't toggle and just mark the
 531   files but don't actually omit them.
 532 With an arg, and if omitting was on, turn it off but don't refresh the buffer."
 533   (interactive "P")
 534   (if flag
 535       (if dired-omit-files-p
 536           (setq dired-omit-files-p (not dired-omit-files-p))
 537         (dired-mark-unmarked-files (dired-omit-regexp) nil nil
 538                                    dired-omit-localp))
 539     ;; no FLAG
 540     (setq dired-omit-files-p (not dired-omit-files-p))
 541     (if (not dired-omit-files-p)
 542         (revert-buffer)
 543       ;; this will mention how many were omitted:
 544       (let ((dired-omit-size-limit nil))
 545         (dired-omit-expunge)))))
 546
 547 (defvar dired-omit-extensions
 548   (append completion-ignored-extensions
 549           dired-latex-unclean-extensions
 550           dired-bibtex-unclean-extensions
 551           dired-texinfo-unclean-extensions)
 552   "If non-nil, a list of extensions \(strings\) to omit from Dired listings.
 553 Defaults to elements of `completion-ignored-extensions',
 554 `dired-latex-unclean-extensions', `dired-bibtex-unclean-extensions', and
 555 `dired-texinfo-unclean-extensions'.
 556
 557 See interactive function `dired-omit-toggle' \(\\[dired-omit-toggle]\) and
 558 variables `dired-omit-files-p' and `dired-omit-files'.")
 559
 560 (defun dired-omit-expunge (&optional regexp)
 561   "Erases all unmarked files matching REGEXP.
 562 Does nothing if global variable `dired-omit-files-p' is nil, or if called
 563   non-interactively and buffer is bigger than `dired-omit-size-limit'.
 564 If REGEXP is nil or not specified, uses `dired-omit-files', and also omits
 565   filenames ending in `dired-omit-extensions'.
 566 If REGEXP is the empty string, this function is a no-op.
 567
 568 This functions works by temporarily binding `dired-marker-char' to
 569 `dired-omit-marker-char' and calling `dired-do-kill-lines'."
 570   (interactive "sOmit files (regexp): ")
 571   (if (and dired-omit-files-p
 572            (or (interactive-p)
 573                (not dired-omit-size-limit)
 574                (< (buffer-size) dired-omit-size-limit)))
 575       (let ((omit-re (or regexp (dired-omit-regexp)))
 576             (old-modified-p (buffer-modified-p))
 577             count)
 578         (or (string= omit-re "")
 579             (let ((dired-marker-char dired-omit-marker-char))
 580               (message "Omitting...")
 581               (if (dired-mark-unmarked-files omit-re nil nil dired-omit-localp)
 582                   (progn
 583                     (setq count (dired-do-kill-lines nil "Omitted %d line%s."))
 584                     (force-mode-line-update))
 585                 (message "(Nothing to omit)"))))
 586         ;; Try to preserve modified state of buffer.  So `%*' doesn't appear
 587         ;; in mode-line of omitted buffers.
 588         (set-buffer-modified-p (and old-modified-p
 589                                     (save-excursion
 590                                       (goto-char (point-min))
 591                                       (re-search-forward dired-re-mark nil t))))
 592         count)))
 593
 594 (defun dired-omit-regexp ()
 595   (concat (if dired-omit-files (concat "\\(" dired-omit-files "\\)") "")
 596           (if (and dired-omit-files dired-omit-extensions) "\\|" "")
 597           (if dired-omit-extensions
 598               (concat ".";; a non-extension part should exist
 599                       "\\("
 600                       (mapconcat 'regexp-quote dired-omit-extensions "\\|")
 601                       "\\)$")
 602             "")))
 603
 604 ;; Returns t if any work was done, nil otherwise.
 605 (defun dired-mark-unmarked-files (regexp msg &optional unflag-p localp)
 606   "Marks unmarked files matching REGEXP, displaying MSG.
 607 REGEXP is matched against the complete pathname.
 608 Does not re-mark files which already have a mark.
 609 With prefix argument, unflag all those files.
 610 Second optional argument LOCALP is as in `dired-get-filename'."
 611   (interactive "P")
 612   (let ((dired-marker-char (if unflag-p ?\  dired-marker-char)))
 613     (dired-mark-if
 614      (and
 615       ;; not already marked
 616       (looking-at " ")
 617       ;; uninteresting
 618       (let ((fn (dired-get-filename localp t)))
 619         (and fn (string-match regexp fn))))
 620      msg)))
 621
 622 ;;; REDEFINE.
 623 (defun dired-omit-new-add-entry (filename &optional marker-char)
 624   ;; This redefines dired-aux.el's dired-add-entry to avoid calling ls for
 625   ;; files that are going to be omitted anyway.
 626   (if dired-omit-files-p
 627       ;; perhaps return t without calling ls
 628       (let ((omit-re (dired-omit-regexp)))
 629         (if (or (string= omit-re "")
 630                 (not
 631                  (string-match omit-re
 632                                (cond
 633                                 ((eq 'no-dir dired-omit-localp)
 634                                  filename)
 635                                 ((eq t dired-omit-localp)
 636                                  (dired-make-relative filename))
 637                                 (t
 638                                  (dired-make-absolute
 639                                   filename
 640                                   (file-name-directory filename)))))))
 641             ;; if it didn't match, go ahead and add the entry
 642             (dired-omit-old-add-entry filename marker-char)
 643           ;; dired-add-entry returns t for success, perhaps we should
 644           ;; return file-exists-p
 645           t))
 646     ;; omitting is not turned on at all
 647     (dired-omit-old-add-entry filename marker-char)))
 648
 649 ;;; REDEFINE.
 650 ;;; Redefine dired-aux.el's version of `dired-add-entry'
 651 ;;; Save old defun if not already done:
 652 (or (fboundp 'dired-omit-old-add-entry)
 653     (fset 'dired-omit-old-add-entry (symbol-function 'dired-add-entry)))
 654 ;; Redefine it.
 655 (fset 'dired-add-entry 'dired-omit-new-add-entry)
 656
 657 \f
 658 ;;; VIRTUAL DIRED MODE.
 659
 660 ;;; For browsing `ls -lR' listings in a dired-like fashion.
 661
 662 (fset 'virtual-dired 'dired-virtual)
 663 (defun dired-virtual (dirname &optional switches)
 664   "Put this buffer into Virtual Dired mode.
 665
 666 In Virtual Dired mode, all commands that do not actually consult the
 667 filesystem will work.
 668
 669 This is useful if you want to peruse and move around in an ls -lR
 670 output file, for example one you got from an ftp server.  With
 671 ange-ftp, you can even dired a directory containing an ls-lR file,
 672 visit that file and turn on virtual dired mode.  But don't try to save
 673 this file, as dired-virtual indents the listing and thus changes the
 674 buffer.
 675
 676 If you have save a Dired buffer in a file you can use \\[dired-virtual] to
 677 resume it in a later session.
 678
 679 Type \\<dired-mode-map>\\[revert-buffer] in the
 680 Virtual Dired buffer and answer `y' to convert the virtual to a real
 681 dired buffer again.  You don't have to do this, though: you can relist
 682 single subdirs using \\[dired-do-redisplay].
 683 "
 684
 685   ;; DIRNAME is the top level directory of the buffer.  It will become
 686   ;; its `default-directory'.  If nil, the old value of
 687   ;; default-directory is used.
 688
 689   ;; Optional SWITCHES are the ls switches to use.
 690
 691   ;; Shell wildcards will be used if there already is a `wildcard'
 692   ;; line in the buffer (thus it is a saved Dired buffer), but there
 693   ;; is no other way to get wildcards.  Insert a `wildcard' line by
 694   ;; hand if you want them.
 695
 696   (interactive
 697    (list (read-string "Virtual Dired directory: " (dired-virtual-guess-dir))))
 698   (goto-char (point-min))
 699   (or (looking-at "  ")
 700       ;; if not already indented, do it now:
 701       (indent-region (point-min) (point-max) 2))
 702   (or dirname (setq dirname default-directory))
 703   (setq dirname (expand-file-name (file-name-as-directory dirname)))
 704   (setq default-directory dirname)      ; contains no wildcards
 705   (let ((wildcard (save-excursion
 706                     (goto-char (point-min))
 707                     (forward-line 1)
 708                     (and (looking-at "^  wildcard ")
 709                          (buffer-substring (match-end 0)
 710                                            (progn (end-of-line) (point)))))))
 711   (if wildcard
 712         (setq dirname (expand-file-name wildcard default-directory))))
 713   ;; If raw ls listing (not a saved old dired buffer), give it a
 714   ;; decent subdir headerline:
 715   (goto-char (point-min))
 716   (or (looking-at dired-subdir-regexp)
 717       (dired-insert-headerline default-directory))
 718   (dired-mode dirname (or switches dired-listing-switches))
 719   (setq mode-name "Virtual Dired"
 720         revert-buffer-function 'dired-virtual-revert)
 721   (set (make-local-variable 'dired-subdir-alist) nil)
 722   (dired-build-subdir-alist)
 723   (goto-char (point-min))
 724   (dired-initial-position dirname))
 725
 726 (defun dired-virtual-guess-dir ()
 727
 728   ;; Guess and return appropriate working directory of this buffer,
 729   ;; assumed to be in Dired or ls -lR format.
 730   ;; The guess is based upon buffer contents.
 731   ;; If nothing could be guessed, returns nil.
 732
 733   (let ((regexp "^\\(  \\)?\\([^ \n\r]*\\)\\(:\\)[\n\r]")
 734         (subexpr 2))
 735     (goto-char (point-min))
 736     (cond ((looking-at regexp)
 737            ;; If a saved dired buffer, look to which dir and
 738            ;; perhaps wildcard it belongs:
 739            (let ((dir (buffer-substring (match-beginning subexpr)
 740                                         (match-end subexpr))))
 741              (file-name-as-directory dir)))
 742           ;; Else no match for headerline found.  It's a raw ls listing.
 743           ;; In raw ls listings the directory does not have a headerline
 744           ;; try parent of first subdir, if any
 745           ((re-search-forward regexp nil t)
 746            (file-name-directory
 747             (directory-file-name
 748              (file-name-as-directory
 749               (buffer-substring (match-beginning subexpr)
 750                                 (match-end subexpr))))))
 751           (t                            ; if all else fails
 752            nil))))
 753
 754
 755 (defun dired-virtual-revert (&optional arg noconfirm)
 756   (if (not
 757        (y-or-n-p "Cannot revert a Virtual Dired buffer - switch to Real Dired mode? "))
 758       (error "Cannot revert a Virtual Dired buffer.")
 759     (setq mode-name "Dired"
 760           revert-buffer-function 'dired-revert)
 761     (revert-buffer)))
 762
 763 ;; A zero-arg version of dired-virtual.
 764 ;; You need my modified version of set-auto-mode for the
 765 ;; `buffer-contents-mode-alist'.
 766 ;; Or you use infer-mode.el and infer-mode-alist, same syntax.
 767 (defun dired-virtual-mode ()
 768   "Put current buffer into virtual dired mode (see `dired-virtual').
 769 Useful on `buffer-contents-mode-alist' (which see) with the regexp
 770
 771     \"^  \\(/[^ /]+\\)/?+:$\"
 772
 773 to put saved dired buffers automatically into virtual dired mode.
 774
 775 Also useful for `auto-mode-alist' (which see) like this:
 776
 777   \(setq auto-mode-alist (cons '(\"[^/]\\.dired\\'\" . dired-virtual-mode)
 778                               auto-mode-alist)\)"
 779   (interactive)
 780   (dired-virtual (dired-virtual-guess-dir)))
 781
 782 \f
 783 ;;; SMART SHELL.
 784
 785 ;;; An Emacs buffer can have but one working directory, stored in the
 786 ;;; buffer-local variable `default-directory'.  A Dired buffer may have
 787 ;;; several subdirectories inserted, but still has but one working directory:
 788 ;;; that of the top level Dired directory in that buffer.  For some commands
 789 ;;; it is appropriate that they use the current Dired directory instead of
 790 ;;; `default-directory', e.g., `find-file' and `compile'.  This is a general
 791 ;;; mechanism is provided for special handling of the working directory in
 792 ;;; special major modes.
 793
 794 ;; It's easier to add to this alist than redefine function
 795 ;; default-directory while keeping the old information.
 796 (defconst default-directory-alist
 797   '((dired-mode . (if (fboundp 'dired-current-directory)
 798                       (dired-current-directory)
 799                     default-directory)))
 800   "Alist of major modes and their opinion on default-directory, as a
 801 lisp expression to evaluate.  A resulting value of nil is ignored in
 802 favor of default-directory.")
 803
 804 (defun default-directory ()
 805   "Usage like variable `default-directory', but knows about the special
 806 cases in variable `default-directory-alist' (which see)."
 807   (or (eval (cdr (assq major-mode default-directory-alist)))
 808       default-directory))
 809
 810 (defun dired-smart-shell-command (cmd &optional insert)
 811   "Like function `shell-command', but in the current Tree Dired directory."
 812   (interactive "sShell command: \nP")
 813   (let ((default-directory (default-directory)))
 814     (shell-command cmd insert)))
 815
 816 \f
 817 ;;; LOCAL VARIABLES FOR DIRED BUFFERS.
 818
 819 ;;; Brief Description:
 820 ;;;
 821 ;;; * `dired-extra-startup' is part of the `dired-mode-hook'.
 822 ;;;
 823 ;;; * `dired-extra-startup' calls `dired-hack-local-variables'
 824 ;;;
 825 ;;; * `dired-hack-local-variables' checks the value of
 826 ;;;   `dired-local-variables-file'
 827 ;;;
 828 ;;; * Check if `dired-local-variables-file' is a non-nil string and is a
 829 ;;;   filename found in the directory of the Dired Buffer being created.
 830 ;;;
 831 ;;; * If `dired-local-variables-file' satisfies the above, then temporarily
 832 ;;;   include it in the Dired Buffer at the bottom.
 833 ;;;
 834 ;;; * Set `enable-local-variables' temporarily to the user variable
 835 ;;;   `dired-enable-local-variables' and run `hack-local-variables' on the
 836 ;;;   Dired Buffer.
 837
 838 (defvar dired-local-variables-file (convert-standard-filename ".dired")
 839   "Filename, as string, containing local dired buffer variables to be hacked.
 840 If this file found in current directory, then it will be inserted into dired
 841 buffer and `hack-local-variables' will be run.  See Emacs Info pages for more
 842 information on local variables.  See also `dired-enable-local-variables'.")
 843
 844 (defun dired-hack-local-variables ()
 845   "Evaluate local variables in `dired-local-variables-file' for dired buffer."
 846   (if (and dired-local-variables-file
 847            (stringp dired-local-variables-file)
 848            (file-exists-p dired-local-variables-file))
 849       (let ((opoint (point-max))
 850             buffer-read-only
 851             ;; In case user has `enable-local-variables' set to nil we
 852             ;; override it locally with dired's variable.
 853             (enable-local-variables dired-enable-local-variables))
 854         ;; Insert 'em.
 855         (save-excursion
 856           (goto-char opoint)
 857           (insert "\^L\n")
 858           (insert-file-contents dired-local-variables-file))
 859         ;; Hack 'em.
 860         (let ((buffer-file-name dired-local-variables-file))
 861           (hack-local-variables))
 862         ;; Make sure that the modeline shows the proper information.
 863         (dired-sort-set-modeline)
 864         ;; Delete this stuff: `eobp' is used to find last subdir by dired.el.
 865         (delete-region opoint (point-max)))))
 866
 867 (defun dired-omit-here-always ()
 868   "Creates `dired-local-variables-file' for omitting and reverts directory.
 869 Sets dired-omit-file-p to t in a local variables file that is readable by
 870 dired."
 871   (interactive)
 872   (if (file-exists-p dired-local-variables-file)
 873       (message "File `./%s' already exists." dired-local-variables-file)
 874
 875     ;; Create `dired-local-variables-file'.
 876     (save-excursion
 877       (set-buffer (get-buffer-create " *dot-dired*"))
 878       (erase-buffer)
 879       (insert "Local Variables:\ndired-omit-files-p: t\nEnd:\n")
 880       (write-file dired-local-variables-file)
 881       (kill-buffer (current-buffer)))
 882
 883     ;; Run extra-hooks and revert directory.
 884     (dired-extra-startup)
 885     (dired-revert)))
 886
 887 \f
 888 ;;; GUESS SHELL COMMAND.
 889
 890 ;;; Brief Description:
 891 ;;;
 892 ;;; `dired-do-shell-command' is bound to `!' by dired.el.
 893 ;;;
 894 ;;; * Redefine `dired-do-shell-command' so it calls
 895 ;;;   `dired-guess-shell-command'.
 896 ;;;
 897 ;;; * `dired-guess-shell-command' calls `dired-guess-default' with list of
 898 ;;;    marked files.
 899 ;;;
 900 ;;; * Parse `dired-guess-shell-alist-user' and
 901 ;;;   `dired-guess-shell-alist-default' (in that order) for the first REGEXP
 902 ;;;   that matches the first file in the file list.
 903 ;;;
 904 ;;; * If the REGEXP matches all the entries of the file list then evaluate
 905 ;;;   COMMAND, which is either a string or a Lisp expression returning a
 906 ;;;   string.  COMMAND may be a list of commands.
 907 ;;;
 908 ;;; * Return this command to `dired-guess-shell-command' which prompts user
 909 ;;;   with it.  The list of commands is temporarily put into the history list.
 910 ;;;   If a command is used successfully then it is stored permanently in
 911 ;;;   `dired-shell-command-history'.
 912
 913 ;;; Guess what shell command to apply to a file.
 914 (defvar dired-shell-command-history nil
 915   "History list for commands that read dired-shell commands.")
 916
 917 ;;; Default list of shell commands.
 918
 919 ;;; NOTE: Use `gunzip -c' instead of `zcat' on `.gz' files.  Some do not
 920 ;;; install GNU zip's version of zcat.
 921
 922 (defvar dired-guess-shell-alist-default
 923   (list
 924    (list "\\.tar$" '(if dired-guess-shell-gnutar
 925                         (concat dired-guess-shell-gnutar " xvf")
 926                       "tar xvf"))
 927
 928    ;; REGEXPS for compressed archives must come before the .Z rule to
 929    ;; be recognized:
 930    (list "\\.tar\\.Z$"
 931          ;; Untar it.
 932          '(if dired-guess-shell-gnutar
 933               (concat dired-guess-shell-gnutar " zxvf")
 934             (concat "zcat * | tar xvf -"))
 935          ;; Optional conversion to gzip format.
 936          '(concat "znew" (if dired-guess-shell-gzip-quiet " -q")
 937                   " " dired-guess-shell-znew-switches))
 938
 939    ;; gzip'ed archives
 940    (list "\\.tar\\.g?z$"
 941          '(if dired-guess-shell-gnutar
 942               (concat dired-guess-shell-gnutar " zxvf")
 943             (concat "gunzip -qc * | tar xvf -"))
 944          ;; Optional decompression.
 945          '(concat "gunzip" (if dired-guess-shell-gzip-quiet " -q" "")))
 946
 947    '("\\.shar.Z$" "zcat * | unshar")
 948    '("\\.shar.g?z$" "gunzip -qc * | unshar")
 949
 950    '("\\.ps$" "ghostview" "xv" "lpr")
 951    (list "\\.ps.g?z$" "gunzip -qc * | ghostview -"
 952          ;; Optional decompression.
 953          '(concat "gunzip" (if dired-guess-shell-gzip-quiet " -q")))
 954    (list "\\.ps.Z$" "zcat * | ghostview -"
 955          ;; Optional conversion to gzip format.
 956          '(concat "znew" (if dired-guess-shell-gzip-quiet " -q")
 957                   " " dired-guess-shell-znew-switches))
 958    '("\\.patch$" "cat * | patch")
 959    '("\\.patch.g?z$" "gunzip -qc * | patch")
 960    (list "\\.patch.Z$" "zcat * | patch"
 961          ;; Optional conversion to gzip format.
 962          '(concat "znew" (if dired-guess-shell-gzip-quiet " -q")
 963                   " " dired-guess-shell-znew-switches))
 964
 965    '("\\.dvi$" "xdvi" "dvips")          ; preview and printing
 966    '("\\.au$" "play")                   ; play Sun audiofiles
 967    '("\\.mpg$" "mpeg_play")
 968    '("\\.uu$" "uudecode")               ; for uudecoded files
 969    '("\\.hqx$" "mcvert")
 970    '("\\.sh$" "sh")                     ; execute shell scripts
 971    '("\\.xbm$" "bitmap")                ; view X11 bitmaps
 972    '("\\.gp$" "gnuplot")
 973    '("\\.p[bgpn]m$" "xv")
 974    '("\\.gif$" "xv")                    ; view gif pictures
 975    '("\\.tif$" "xv")
 976    '("\\.jpg$" "xv")
 977    '("\\.fig$" "xfig")                  ; edit fig pictures
 978    '("\\.out$" "xgraph")                ; for plotting purposes.
 979    '("\\.tex$" "latex" "tex")
 980    '("\\.texi\\(nfo\\)?$" "makeinfo" "texi2dvi")
 981
 982    ;; Some other popular archivers.
 983    '("\\.zoo$" "zoo x//")
 984    '("\\.zip$" "unzip")
 985    '("\\.lzh$" "lharc x")
 986    '("\\.arc$" "arc x")
 987    '("\\.shar$" "unshar")
 988
 989    ;; Compression.
 990    (list "\\.g?z$" '(concat "gunzip" (if dired-guess-shell-gzip-quiet " -q")))
 991    (list "\\.Z$" "uncompress"
 992          ;; Optional conversion to gzip format.
 993          '(concat "znew" (if dired-guess-shell-gzip-quiet " -q")
 994                   " " dired-guess-shell-znew-switches))
 995    )
 996
 997   "Default alist used for shell command guessing.
 998 See `dired-guess-shell-alist-user'")
 999
1000 (defvar dired-guess-shell-alist-user nil
1001   "User-defined alist of rules for suggested commands. These rules take
1002 precedence over the predefined rules in the variable
1003 `dired-guess-shell-alist-default' (to which they are prepended).
1004
1005 Each element of this list looks like
1006
1007     \(REGEXP COMMAND...\)
1008
1009 where each COMMAND can either be a string or a lisp expression that evaluates
1010 to a string.  If several COMMANDs are given, the first one will be the default
1011 and the rest will be added temporarily to the history and can be retrieved
1012 with \\[previous-history-element] (M-p) .
1013
1014 You can set this variable in your ~/.emacs.  For example, to add rules for
1015 `.foo' and `.bar' files, write
1016
1017  \(setq dired-guess-shell-alist-user
1018        (list (list \"\\\\.foo$\" \"FOO-COMMAND\");; fixed rule
1019               ;; possibly more rules ...
1020               (list \"\\\\.bar$\";; rule with condition test
1021                     '(if condition
1022                           \"BAR-COMMAND-1\"
1023                         \"BAR-COMMAND-2\")))\)
1024 ")
1025
1026 (defun dired-guess-default (files)
1027
1028   ;; Guess a shell commands for FILES.  Return command or list of commands.
1029   ;; See `dired-guess-shell-alist-user'.
1030
1031   (let* ((case-fold-search nil) ; case-sensitive matching
1032          ;; Prepend the user's alist to the default alist.
1033          (alist (append dired-guess-shell-alist-user
1034                         dired-guess-shell-alist-default))
1035          (file (car files))
1036          (flist (cdr files))
1037          elt regexp cmds)
1038
1039     ;; Find the first match in the alist for first file in FILES.
1040     (while alist
1041       (setq elt (car alist)
1042             regexp (car elt)
1043             alist (cdr alist))
1044       (if (string-match regexp file)
1045           (setq cmds (cdr elt)
1046                 alist nil)))
1047
1048     ;; If more than one file, see if all of FILES match regular expression.
1049     (while (and flist
1050                 (string-match regexp (car flist)))
1051       (setq flist (cdr flist)))
1052
1053     ;; If flist is still non-nil, then do not guess since this means that not
1054     ;; all the files in FILES were matched by the regexp.
1055     (setq cmds (and (not flist) cmds))
1056
1057     ;; Return commands or nil if flist is still non-nil.
1058     ;; Evaluate the commands in order that any logical testing will be done.
1059     (cond ((not (cdr cmds))
1060            (eval (car cmds))) ; single command
1061           (t
1062            (mapcar (function eval) cmds)))))
1063
1064 (defun dired-guess-shell-command (prompt files)
1065
1066   ;; Ask user with PROMPT for a shell command, guessing a default from FILES.
1067
1068   (let ((default (dired-guess-default files))
1069         default-list old-history val (failed t))
1070
1071     (if (null default)
1072         ;; Nothing to guess
1073         (read-from-minibuffer prompt nil nil nil 'dired-shell-command-history)
1074
1075       ;; Save current history list
1076       (setq old-history dired-shell-command-history)
1077
1078       (if (listp default)
1079
1080           ;; More than one guess
1081           (setq default-list default
1082                 default (car default)
1083                 prompt (concat
1084                         prompt
1085                         (format "{%d guesses} " (length default-list))))
1086
1087         ;; Just one guess
1088         (setq default-list (list default)))
1089
1090       ;; Push all guesses onto history so that they can be retrieved with M-p
1091       ;; and put the first guess in the prompt but not in the initial value.
1092       (setq dired-shell-command-history
1093             (append default-list dired-shell-command-history)
1094             prompt (concat prompt (format "[%s] " default)))
1095
1096       ;; The unwind-protect returns VAL, and we too.
1097       (unwind-protect
1098           ;; BODYFORM
1099           (progn
1100             (setq val (read-from-minibuffer prompt nil nil nil
1101                                             'dired-shell-command-history)
1102                   failed nil)
1103             ;; If we got a return, then use default.
1104             (if (equal val "")
1105                 (setq val default))
1106             val)
1107
1108         ;; UNWINDFORMS
1109         ;; Undo pushing onto the history list so that an aborted
1110         ;; command doesn't get the default in the next command.
1111         (setq dired-shell-command-history old-history)
1112         (if (not failed)
1113             (or (equal val (car-safe dired-shell-command-history))
1114                 (setq dired-shell-command-history
1115                       (cons val dired-shell-command-history))))))))
1116
1117
1118 ;;; REDEFINE.
1119 ;;; Redefine dired-aux.el's version:
1120 (defun dired-read-shell-command (prompt arg files)
1121 ;;  "Read a dired shell command prompting with PROMPT (using read-string).
1122 ;;ARG is the prefix arg and may be used to indicate in the prompt which
1123 ;;  files are affected.
1124 ;;This is an extra function so that you can redefine it, e.g., to use gmhist."
1125   (dired-mark-pop-up
1126    nil 'shell files
1127    'dired-guess-shell-command
1128    (format prompt (dired-mark-prompt arg files)) ; PROMPT
1129    files))                                       ; FILES
1130
1131 \f
1132 ;;; RELATIVE SYMBOLIC LINKS.
1133
1134 (defvar dired-keep-marker-relsymlink ?S
1135   "See variable `dired-keep-marker-move'.")
1136
1137 (defun dired-make-relative-symlink (file1 file2 &optional ok-if-already-exists)
1138   "Three arguments: FILE1 FILE2 &optional OK-IF-ALREADY-EXISTS
1139 Make a symbolic link (pointing to FILE1) in FILE2.
1140 The link is relative (if possible), for example
1141
1142     \"/vol/tex/bin/foo\" \"/vol/local/bin/foo\"
1143
1144 results in
1145
1146     \"../../tex/bin/foo\" \"/vol/local/bin/foo\"
1147 "
1148   (interactive "FRelSymLink: \nFRelSymLink %s: \np")
1149   (let (name1 name2 len1 len2 (index 0) sub)
1150     (setq file1 (expand-file-name file1)
1151           file2 (expand-file-name file2)
1152           len1 (length file1)
1153           len2 (length file2))
1154     ;; Find common initial pathname components:
1155     (let (next)
1156       (while (and (setq next (string-match "/" file1 index))
1157                   (setq next (1+ next))
1158                   (< next (min len1 len2))
1159                   ;; For the comparison, both substrings must end in
1160                   ;; `/', so NEXT is *one plus* the result of the
1161                   ;; string-match.
1162                   ;; E.g., consider the case of linking "/tmp/a/abc"
1163                   ;; to "/tmp/abc" erroneously giving "/tmp/a" instead
1164                   ;; of "/tmp/" as common initial component
1165                   (string-equal (substring file1 0 next)
1166                                 (substring file2 0 next)))
1167         (setq index next))
1168       (setq name2 file2
1169             sub (substring file1 0 index)
1170             name1 (substring file1 index)))
1171     (if (string-equal sub "/")
1172         ;; No common initial pathname found
1173         (setq name1 file1)
1174       ;; Else they have a common parent directory
1175       (let ((tem (substring file2 index))
1176             (start 0)
1177             (count 0))
1178         ;; Count number of slashes we must compensate for ...
1179         (while (setq start (string-match "/" tem start))
1180           (setq count (1+ count)
1181                 start (1+ start)))
1182         ;; ... and prepend a "../" for each slash found:
1183         (while (> count 0)
1184           (setq count (1- count)
1185                 name1 (concat "../" name1)))))
1186     (make-symbolic-link
1187      (directory-file-name name1)        ; must not link to foo/
1188                                         ; (trailing slash!)
1189      name2 ok-if-already-exists)))
1190
1191 (defun dired-do-relsymlink (&optional arg)
1192    "Relative symlink all marked (or next ARG) files into a directory,
1193 or make a relative symbolic link to the current file.
1194 This creates relative symbolic links like
1195
1196     foo -> ../bar/foo
1197
1198 not absolute ones like
1199
1200     foo -> /ugly/path/that/may/change/any/day/bar/foo"
1201   (interactive "P")
1202   (dired-do-create-files 'relsymlink (function dired-make-relative-symlink)
1203                            "RelSymLink" arg dired-keep-marker-relsymlink))
1204
1205 (defun dired-do-relsymlink-regexp (regexp newname &optional whole-path)
1206   "RelSymlink all marked files containing REGEXP to NEWNAME.
1207 See functions `dired-do-rename-regexp' and `dired-do-relsymlink'
1208 for more info."
1209   (interactive (dired-mark-read-regexp "RelSymLink"))
1210   (dired-do-create-files-regexp
1211    (function dired-make-relative-symlink)
1212    "RelSymLink" nil regexp newname whole-path dired-keep-marker-relsymlink))
1213
1214 \f
1215 ;;; VISIT ALL MARKED FILES SIMULTANEOUSLY.
1216
1217 ;;; Brief Description:
1218 ;;;
1219 ;;; `dired-do-find-marked-files' is bound to `F' by dired-x.el.
1220 ;;;
1221 ;;; * Use `dired-get-marked-files' to collect the marked files in the current
1222 ;;;   Dired Buffer into a list of filenames `FILE-LIST'.
1223 ;;;
1224 ;;; * Pass FILE-LIST to `dired-simultaneous-find-file' all with
1225 ;;;   `dired-do-find-marked-files''s prefix argument NOSELECT.
1226 ;;;
1227 ;;; * `dired-simultaneous-find-file' runs through FILE-LIST decrementing the
1228 ;;;   list each time.
1229 ;;;
1230 ;;; * If NOSELECT is non-nil then just run `find-file-noselect'  on each
1231 ;;;   element of FILE-LIST.
1232 ;;;
1233 ;;; * If NOSELECT is nil then calculate the `size' of the window for each file
1234 ;;;   by dividing the `window-height' by length of FILE-LIST.  Thus, `size' is
1235 ;;;   cognizant of the window-configuration.
1236 ;;;
1237 ;;; * If `size' is too small abort, otherwise run `find-file' on each element
1238 ;;;   of FILE-LIST giving each a window of height `size'.
1239
1240 (defun dired-do-find-marked-files (&optional noselect)
1241   "Find all marked files displaying all of them simultaneously.
1242 With optional NOSELECT just find files but do not select them.
1243
1244 The current window is split across all files marked, as evenly as possible.
1245 Remaining lines go to bottom-most window.  The number of files that can be
1246 displayed this way is restricted by the height of the current window and
1247 `window-min-height'.
1248
1249 To keep dired buffer displayed, type \\[split-window-vertically] first.
1250 To display just marked files, type \\[delete-other-windows] first."
1251
1252   (interactive "P")
1253   (dired-simultaneous-find-file (dired-get-marked-files) noselect))
1254
1255 (defun dired-simultaneous-find-file (file-list noselect)
1256
1257   ;; Visit all files in FILE-LIST and display them simultaneously.  The
1258   ;; current window is split across all files in FILE-LIST, as evenly as
1259   ;; possible.  Remaining lines go to the bottom-most window.  The number of
1260   ;; files that can be displayed this way is restricted by the height of the
1261   ;; current window and the variable `window-min-height'.  With non-nil
1262   ;; NOSELECT the files are merely found but not selected.
1263
1264   ;; We don't make this function interactive because it is usually too clumsy
1265   ;; to specify FILE-LIST interactively unless via dired.
1266
1267   (let (size)
1268
1269     (if noselect
1270         ;; Do not select the buffer.
1271         (find-file-noselect (car file-list))
1272
1273       ;; We will have to select the buffer.  Calculate and check window size.
1274       (setq size (/ (window-height) (length file-list)))
1275       (or (<= window-min-height size)
1276           (error "Too many files to visit simultaneously.  Try C-u prefix."))
1277       (find-file (car file-list)))
1278
1279     ;; Decrement.
1280     (setq file-list (cdr file-list))
1281
1282     (while file-list
1283
1284       (if noselect
1285           ;; Do not select the buffer.
1286           (find-file-noselect (car file-list))
1287
1288         ;; Vertically split off a window of desired size.  Upper window will
1289         ;; have SIZE lines.  Select lower (larger) window.  We split it again.
1290         (select-window (split-window nil size))
1291         (find-file (car file-list)))
1292
1293       ;; Decrement.
1294       (setq file-list (cdr file-list)))))
1295
1296 \f
1297 ;;; MISCELLANEOUS COMMANDS.
1298
1299 ;;; Run man on files.
1300
1301 (defun dired-man ()
1302   "Run man on this file.  Display old buffer if buffer name matches filename.
1303 Uses ../lisp/man.el of \\[manual-entry] fame."
1304   (interactive)
1305   (require 'man)
1306   (let ((file (dired-get-filename))
1307         (manual-program "nroff -man -h"))
1308     (Man-getpage-in-background file)))
1309
1310 ;;; Run Info on files.
1311
1312 (defun dired-info ()
1313   "Run info on this file."
1314   (interactive)
1315   (info (dired-get-filename)))
1316
1317 ;;; Run mail on mail folders.
1318
1319 ;;; (and (not (fboundp 'vm-visit-folder))
1320 ;;;      (defun vm-visit-folder (file &optional arg)
1321 ;;;        nil))
1322
1323 (defun dired-vm (&optional read-only)
1324   "Run VM on this file.
1325 With prefix arg, visit folder read-only (this requires at least VM 5).
1326 See also variable `dired-vm-read-only-folders'."
1327   (interactive "P")
1328   (let ((dir (dired-current-directory))
1329         (fil (dired-get-filename)))
1330     ;; take care to supply 2nd arg only if requested - may still run VM 4!
1331     (cond (read-only (vm-visit-folder fil t))
1332           ((eq t dired-vm-read-only-folders) (vm-visit-folder fil t))
1333           ((null dired-vm-read-only-folders) (vm-visit-folder fil))
1334           (t (vm-visit-folder fil (not (file-writable-p fil)))))
1335     ;; so that pressing `v' inside VM does prompt within current directory:
1336     (set (make-local-variable 'vm-folder-directory) dir)))
1337
1338 (defun dired-rmail ()
1339   "Run RMAIL on this file."
1340   (interactive)
1341   (rmail (dired-get-filename)))
1342
1343 (defun dired-do-run-mail ()
1344   "If `dired-bind-vm' is t, then function `dired-vm', otherwise `dired-rmail'."
1345   (interactive)
1346   (if dired-bind-vm
1347       ;; Read mail folder using vm.
1348       (dired-vm)
1349     ;; Read mail folder using rmail.
1350     (dired-rmail)))
1351
1352 \f
1353 ;;; MISCELLANEOUS INTERNAL FUNCTIONS.
1354
1355 (or (fboundp 'dired-old-find-buffer-nocreate)
1356     (fset 'dired-old-find-buffer-nocreate
1357           (symbol-function 'dired-find-buffer-nocreate)))
1358
1359 ;;; REDEFINE.
1360 ;;; Redefines dired.el's version of `dired-find-buffer-nocreate'
1361 (defun dired-find-buffer-nocreate (dirname &optional mode)
1362   (if (and dired-find-subdir
1363            ;; don't try to find a wildcard as a subdirectory
1364            (string-equal dirname (file-name-directory dirname)))
1365       (let* ((cur-buf (current-buffer))
1366              (buffers (nreverse
1367                        (dired-buffers-for-dir (expand-file-name dirname))))
1368              (cur-buf-matches (and (memq cur-buf buffers)
1369                                    ;; wildcards must match, too:
1370                                    (equal dired-directory dirname))))
1371         ;; We don't want to switch to the same buffer---
1372         (setq buffers (delq cur-buf buffers));;need setq with delq
1373         (or (car (sort buffers (function dired-buffer-more-recently-used-p)))
1374             ;; ---unless it's the only possibility:
1375             (and cur-buf-matches cur-buf)))
1376     (dired-old-find-buffer-nocreate dirname mode)))
1377
1378 ;; This should be a builtin
1379 (defun dired-buffer-more-recently-used-p (buffer1 buffer2)
1380   "Return t if BUFFER1 is more recently used than BUFFER2."
1381   (if (equal buffer1 buffer2)
1382       nil
1383     (let ((more-recent nil)
1384           (list (buffer-list)))
1385       (while (and list
1386                   (not (setq more-recent (equal buffer1 (car list))))
1387                   (not (equal buffer2 (car list))))
1388         (setq list (cdr list)))
1389       more-recent)))
1390
1391 ;;; Same thing as `dired-buffers-for-dir' of dired.el? - lrd 11/23/93
1392 ;;; (defun dired-buffers-for-dir-exact (dir)
1393 ;;; ;; Return a list of buffers that dired DIR (a directory or wildcard)
1394 ;;; ;; at top level, or as subdirectory.
1395 ;;; ;; Top level matches must match the wildcard part too, if any.
1396 ;;; ;; The list is in reverse order of buffer creation, most recent last.
1397 ;;; ;; As a side effect, killed dired buffers for DIR are removed from
1398 ;;; ;; dired-buffers.
1399 ;;;   (let ((alist dired-buffers) result elt)
1400 ;;;     (while alist
1401 ;;;       (setq elt (car alist)
1402 ;;;             alist (cdr alist))
1403 ;;;       (let ((buf (cdr elt)))
1404 ;;;         (if (buffer-name buf)
1405 ;;;             ;; Top level must match exactly against dired-directory in
1406 ;;;             ;; case one of them is a wildcard.
1407 ;;;             (if (or (equal dir (save-excursion (set-buffer buf)
1408 ;;;                                                dired-directory))
1409 ;;;                     (assoc dir (save-excursion (set-buffer buf)
1410 ;;;                                                dired-subdir-alist)))
1411 ;;;                 (setq result (cons buf result)))
1412 ;;;           ;; else buffer is killed - clean up:
1413 ;;;           (setq dired-buffers (delq elt dired-buffers)))))
1414 ;;;     result))
1415
1416 ;;; REDEFINE.
1417 ;;; Redefines dired.el's version of `dired-initial-position'
1418 (defun dired-initial-position (dirname)
1419   (end-of-line)
1420   (if dired-find-subdir (dired-goto-subdir dirname)) ; new
1421   (if dired-trivial-filenames (dired-goto-next-nontrivial-file)))
1422
1423 \f
1424 ;; Does anyone use this? - lrd 6/29/93.
1425 (defun dired-mark-sexp (predicate &optional unflag-p)
1426   "Mark files for which PREDICATE returns non-nil.
1427 With a prefix arg, unflag those files instead.
1428
1429 PREDICATE is a lisp expression that can refer to the following symbols:
1430
1431     inode  [integer] the inode of the file (only for ls -i output)
1432     s      [integer] the size of the file for ls -s output
1433                      (usually in blocks or, with -k, in KByte)
1434     mode   [string]  file permission bits, e.g. \"-rw-r--r--\"
1435     nlink  [integer] number of links to file
1436     uid    [string]  owner
1437     gid    [string]  group  (If the gid is not displayed by ls,
1438                      this will still be set (to the same as uid))
1439     size   [integer] file size in bytes
1440     time   [string]  the time that ls displays, e.g. \"Feb 12 14:17\"
1441     name   [string]  the name of the file
1442     sym    [string]  if file is a symbolic link, the linked-to name, else \"\"
1443
1444 For example, use
1445
1446         (equal 0 size)
1447
1448 to mark all zero length files."
1449   ;; Using sym="" instead of nil avoids the trap of
1450   ;; (string-match "foo" sym) into which a user would soon fall.
1451   ;; Give `equal' instead of `=' in the example, as this works on
1452   ;; integers and strings.
1453   (interactive "xMark if (lisp expr): \nP")
1454   (message "%s" predicate)
1455   (let ((dired-marker-char (if unflag-p ?\040 dired-marker-char))
1456         inode s mode nlink uid gid size time name sym)
1457     (dired-mark-if
1458      (save-excursion
1459        (and
1460         ;; Sets vars
1461         ;;                inode s mode nlink uid gid size time name sym
1462
1463         ;; according to current file line.  Returns t for success, nil if
1464         ;; there is no file line.  Upon success, all variables are set, either
1465         ;; to nil or the appropriate value, so they need not be initialized.
1466         ;; Moves point within the current line.
1467         (if (dired-move-to-filename)
1468             (let (pos
1469                   (mode-len 10) ; length of mode string
1470                   ;; like in dired.el, but with subexpressions \1=inode, \2=s:
1471                   (dired-re-inode-size "\\s *\\([0-9]*\\)\\s *\\([0-9]*\\) ?"))
1472               (beginning-of-line)
1473               (forward-char 2)
1474               (if (looking-at dired-re-inode-size)
1475                   (progn
1476                     (goto-char (match-end 0))
1477                     (setq inode (string-to-int (buffer-substring (match-beginning 1)
1478                                                                  (match-end 1)))
1479                           s (string-to-int (buffer-substring (match-beginning 2)
1480                                                              (match-end 2)))))
1481                 (setq inode nil
1482                       s nil))
1483               (setq mode (buffer-substring (point) (+ mode-len (point))))
1484               (forward-char mode-len)
1485               (setq nlink (read (current-buffer)))
1486               (setq uid (buffer-substring (point) (progn (forward-word 1) (point))))
1487               (re-search-forward "\\(Jan\\|Feb\\|Mar\\|Apr\\|May\\|Jun\\|Jul\\|Aug\\|Sep\\|Oct\\|Nov\\|Dec\\)")
1488               (goto-char (match-beginning 1))
1489               (forward-char -1)
1490               (setq size (string-to-int (buffer-substring (save-excursion
1491                                                             (backward-word 1)
1492                                                             (setq pos (point)))
1493                                                           (point))))
1494               (goto-char pos)
1495               (backward-word 1)
1496               ;; if no gid is displayed, gid will be set to uid
1497               ;; but user will then not reference it anyway in PREDICATE.
1498               (setq gid (buffer-substring (save-excursion (forward-word 1) (point))
1499                                           (point))
1500                     time (buffer-substring (match-beginning 1)
1501                                            (1- (dired-move-to-filename)))
1502                     name (buffer-substring (point)
1503                                            (or (dired-move-to-end-of-filename t)
1504                                                (point)))
1505                     sym  (progn
1506                            (if (looking-at " -> ")
1507                                (buffer-substring (progn (forward-char 4) (point))
1508                                                  (progn (end-of-line) (point)))
1509                              "")))
1510               t)
1511           nil)
1512                       (eval predicate)))
1513      (format "'%s file" predicate))))
1514
1515 \f
1516 ;;; FIND FILE AT POINT.
1517
1518 (defvar dired-x-hands-off-my-keys t
1519   "*t means don't bind `dired-x-find-file' over `find-file' on keyboard.
1520 Similarly for `dired-x-find-file-other-window' over `find-file-other-window'.
1521 If you change this variable after dired-x.el is loaded then do
1522 \\[dired-x-bind-find-file].")
1523
1524 ;;; Bind `dired-x-find-file{-other-window}' over wherever
1525 ;;; `find-file{-other-window}' is bound?
1526 (defun dired-x-bind-find-file ()
1527   "Bind `dired-x-find-file' in place of `find-file' \(or reverse\).
1528 Similarly for `dired-x-find-file-other-window' and `find-file-other-window'.
1529 Binding direction based on `dired-x-hands-off-my-keys'.
1530 This function part of `after-init-hook'."
1531   (interactive)
1532   (if (interactive-p)
1533       (setq dired-x-hands-off-my-keys
1534             (not (y-or-n-p "Bind dired-x-find-file over find-file? "))))
1535   (cond ((not dired-x-hands-off-my-keys)
1536          (substitute-key-definition 'find-file
1537                                     'dired-x-find-file
1538                                     (current-global-map))
1539          (substitute-key-definition 'find-file-other-window
1540                                     'dired-x-find-file-other-window
1541                                     (current-global-map)))
1542         (t
1543          (substitute-key-definition 'dired-x-find-file
1544                                     'find-file
1545                                     (current-global-map))
1546          (substitute-key-definition 'dired-x-find-file-other-window
1547                                     'find-file-other-window
1548                                     (current-global-map))))
1549   ;; Clear mini-buffer.
1550   (message nil))
1551
1552 ;;; Now call it so binding is correct and put on `after-init-hook' in case
1553 ;;; user changes binding.
1554 (dired-x-bind-find-file)
1555 (add-hook 'after-init-hook 'dired-x-bind-find-file)
1556
1557 (defun dired-x-find-file (filename)
1558   "Edit file FILENAME.
1559 May create a new window, or reuse an existing one.
1560 See the function `display-buffer'.
1561
1562 Identical to `find-file' except when called interactively, with a prefix arg
1563 \(e.g., \\[universal-argument]\), in which case it guesses filename near
1564 point.  Useful for editing file mentioned in buffer you are viewing, or to
1565 test if that file exists.  Use minibuffer after snatching filename."
1566   (interactive (list (read-filename-at-point "Find file: ")))
1567   (find-file (expand-file-name filename)))
1568
1569 (defun dired-x-find-file-other-window (filename)
1570   "Edit file FILENAME, in another window.
1571 May create a new window, or reuse an existing one.
1572 See the function `display-buffer'.
1573
1574 Identical to `find-file-other-window' except when called interactively, with a
1575 prefix arg \(e.g., \\[universal-argument]\), in which case it guesses filename
1576 near point.  Useful for editing file mentioned in buffer you are viewing, or
1577 to test if that file exists.  Use minibuffer after snatching filename."
1578   (interactive (list (read-filename-at-point "Find file: ")))
1579   (find-file-other-window (expand-file-name filename)))
1580
1581 ;;; Internal functions.
1582 (defun dired-filename-at-point ()
1583
1584   ;; Get the filename closest to point, but do not change position.  Has a
1585   ;; preference for looking backward when not directly on a symbol.  Not
1586   ;; perfect - point must be in middle of or end of filename.
1587
1588   (let ((filename-chars ".a-zA-Z0-9---_/:$+")
1589         (bol (save-excursion (beginning-of-line) (point)))
1590         (eol (save-excursion (end-of-line) (point)))
1591         start end filename)
1592
1593     (save-excursion
1594       ;; First see if just past a filename.
1595       (if (not (eobp))
1596           (if (looking-at "[] \t\n[{}()]") ; whitespace or some parens
1597               (progn
1598                 (skip-chars-backward " \n\t\r({[]})")
1599                 (if (not (bobp))
1600                     (backward-char 1)))))
1601
1602       (if (string-match (concat "[" filename-chars "]")
1603                         (char-to-string (following-char)))
1604           (progn
1605             (skip-chars-backward filename-chars)
1606             (setq start (point))
1607             (if (string-match "[/~]" (char-to-string (preceding-char)))
1608                 (setq start (1- start)))
1609             (skip-chars-forward filename-chars))
1610
1611         (error "No file found around point!"))
1612
1613       ;; Return string.
1614       (expand-file-name (buffer-substring start (point))))))
1615
1616 (defun read-filename-at-point (prompt)
1617   ;;; Returns filename prompting with PROMPT with completion.  If
1618   ;;; `current-prefix-arg' is non-nil, uses name at point as guess.
1619   (if current-prefix-arg
1620       (let ((guess (dired-filename-at-point)))
1621         (read-file-name prompt
1622                         (file-name-directory guess)
1623                         guess
1624                         nil (file-name-nondirectory guess)))
1625     (read-file-name prompt default-directory)))
1626
1627 \f
1628 ;;; BUG REPORTS
1629
1630 ;;; This section is provided for reports.  It uses Barry A. Warsaw's
1631 ;;; reporter.el which is bundled with GNU Emacs v19.
1632
1633 (defconst dired-x-version "2.37"
1634   "Revision number of dired-x.el -- dired extra for GNU Emacs v19.
1635 Type \\[dired-x-submit-report] to send a bug report.  Available via anonymous
1636 ftp in
1637
1638    /roebling.poly.edu:/pub/packages/dired-x.tar.gz")
1639
1640 (defconst dired-x-help-address "dodd@roebling.poly.edu"
1641   "Address(es) accepting submission of reports on dired-x.el.")
1642
1643 (defconst dired-x-maintainer "Larry"
1644   "First name(s) of people accepting submission of reports on dired-x.el.")
1645
1646 (defconst dired-x-file "dired-x.el"
1647   "Name of file containing emacs lisp code.")
1648
1649 (defconst dired-x-variable-list
1650   (list
1651    'dired-bind-vm
1652    'dired-vm-read-only-folders
1653    'dired-bind-jump
1654    'dired-bind-info
1655    'dired-bind-man
1656    'dired-find-subdir
1657    'dired-enable-local-variables
1658    'dired-local-variables-file
1659    'dired-guess-shell-gnutar
1660    'dired-guess-shell-gzip-quiet
1661    'dired-guess-shell-znew-switches
1662    'dired-guess-shell-alist-user
1663    'dired-clean-up-buffers-too
1664    'dired-omit-files-p
1665    'dired-omit-files
1666    'dired-omit-extensions
1667    )
1668   "List of variables to be appended to reports sent by `dired-x-submit-report.'")
1669
1670 (defun dired-x-submit-report ()
1671   "Submit via reporter.el a bug report on program.  Send report on `dired-x-file'
1672 version `dired-x-version,' to `dired-x-maintainer' at address `dired-x-help-address'
1673 listing variables `dired-x-variable-list' in the message."
1674   (interactive)
1675
1676   ;; In case we can't find reporter...
1677   (condition-case err
1678       (progn
1679         ;; Get it if we can.
1680         (require 'reporter)
1681
1682         (reporter-submit-bug-report
1683          dired-x-help-address                           ; address
1684          (concat dired-x-file " (" dired-x-version ")") ; pkgname
1685          dired-x-variable-list                          ; varlist
1686          nil nil                                        ; pre-/post-hooks
1687          (concat dired-x-maintainer ",")))              ; salutation
1688
1689     ;; ...fail gracefully.
1690     (error
1691      (beep)
1692      (message "Sorry, reporter.el not found."))))
1693
1694 \f
1695 ;; As Barry Warsaw would say: "This might be useful..."
1696 (provide 'dired-x)
1697
1698 ;;; dired-x.el ends here