lisp/progmodes/grep.el

   1 ;;; grep.el --- run `grep' and display the results
   2
   3 ;; Copyright (C) 1985-1987, 1993-1999, 2001-2011
   4 ;;   Free Software Foundation, Inc.
   5
   6 ;; Author: Roland McGrath <roland@gnu.org>
   7 ;; Maintainer: FSF
   8 ;; Keywords: tools, processes
   9
  10 ;; This file is part of GNU Emacs.
  11
  12 ;; GNU Emacs is free software: you can redistribute it and/or modify
  13 ;; it under the terms of the GNU General Public License as published by
  14 ;; the Free Software Foundation, either version 3 of the License, or
  15 ;; (at your option) any later version.
  16
  17 ;; GNU Emacs is distributed in the hope that it will be useful,
  18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ;; GNU General Public License for more details.
  21
  22 ;; You should have received a copy of the GNU General Public License
  23 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  24
  25 ;;; Commentary:
  26
  27 ;; This package provides the grep facilities documented in the Emacs
  28 ;; user's manual.
  29
  30 ;;; Code:
  31
  32 (require 'compile)
  33
  34
  35 (defgroup grep nil
  36   "Run `grep' and display the results."
  37   :group 'tools
  38   :group 'processes)
  39
  40 (defvar grep-host-defaults-alist nil
  41   "Default values depending on target host.
  42 `grep-compute-defaults' returns default values for every local or
  43 remote host `grep' runs.  These values can differ from host to
  44 host.  Once computed, the default values are kept here in order
  45 to avoid computing them again.")
  46
  47 (defun grep-apply-setting (symbol value)
  48   "Set SYMBOL to VALUE, and update `grep-host-defaults-alist'.
  49 SYMBOL should be one of `grep-command', `grep-template',
  50 `grep-use-null-device', `grep-find-command',
  51 `grep-find-template', `grep-find-use-xargs', or
  52 `grep-highlight-matches'."
  53   (when grep-host-defaults-alist
  54     (let* ((host-id
  55             (intern (or (file-remote-p default-directory) "localhost")))
  56            (host-defaults (assq host-id grep-host-defaults-alist))
  57            (defaults (assq nil grep-host-defaults-alist)))
  58       (setcar (cdr (assq symbol host-defaults)) value)
  59       (setcar (cdr (assq symbol defaults)) value)))
  60   (set-default symbol value))
  61
  62 ;;;###autoload
  63 (defcustom grep-window-height nil
  64   "*Number of lines in a grep window.  If nil, use `compilation-window-height'."
  65   :type '(choice (const :tag "Default" nil)
  66                  integer)
  67   :version "22.1"
  68   :group 'grep)
  69
  70 (defcustom grep-highlight-matches 'auto-detect
  71   "Use special markers to highlight grep matches.
  72
  73 Some grep programs are able to surround matches with special
  74 markers in grep output.  Such markers can be used to highlight
  75 matches in grep mode.  This requires `font-lock-mode' to be active
  76 in grep buffers, so if you have globally disabled font-lock-mode,
  77 you will not get highlighting.
  78
  79 This option sets the environment variable GREP_COLORS to specify
  80 markers for highlighting and GREP_OPTIONS to add the --color
  81 option in front of any explicit grep options before starting
  82 the grep.
  83
  84 When this option is `auto', grep uses `--color=auto' to highlight
  85 matches only when it outputs to a terminal (when `grep' is the last
  86 command in the pipe), thus avoiding the use of any potentially-harmful
  87 escape sequences when standard output goes to a file or pipe.
  88
  89 To make grep highlight matches even into a pipe, you need the option
  90 `always' that forces grep to use `--color=always' to unconditionally
  91 output escape sequences.
  92
  93 In interactive usage, the actual value of this variable is set up
  94 by `grep-compute-defaults' when the default value is `auto-detect'.
  95 To change the default value, use Customize or call the function
  96 `grep-apply-setting'."
  97   :type '(choice (const :tag "Do not highlight matches with grep markers" nil)
  98                  (const :tag "Highlight matches with grep markers" t)
  99                  (const :tag "Use --color=always" always)
 100                  (const :tag "Use --color=auto" auto)
 101                  (other :tag "Not Set" auto-detect))
 102   :set 'grep-apply-setting
 103   :version "22.1"
 104   :group 'grep)
 105
 106 (defcustom grep-scroll-output nil
 107   "*Non-nil to scroll the *grep* buffer window as output appears.
 108
 109 Setting it causes the grep commands to put point at the end of their
 110 output window so that the end of the output is always visible rather
 111 than the begining."
 112   :type 'boolean
 113   :version "22.1"
 114   :group 'grep)
 115
 116 ;;;###autoload
 117 (defcustom grep-command nil
 118   "The default grep command for \\[grep].
 119 If the grep program used supports an option to always include file names
 120 in its output (such as the `-H' option to GNU grep), it's a good idea to
 121 include it when specifying `grep-command'.
 122
 123 In interactive usage, the actual value of this variable is set up
 124 by `grep-compute-defaults'; to change the default value, use
 125 Customize or call the function `grep-apply-setting'."
 126   :type '(choice string
 127                  (const :tag "Not Set" nil))
 128   :set 'grep-apply-setting
 129   :group 'grep)
 130
 131 (defcustom grep-template nil
 132   "The default command to run for \\[lgrep].
 133 The following place holders should be present in the string:
 134  <C> - place to put -i if case insensitive grep.
 135  <F> - file names and wildcards to search.
 136  <X> - file names and wildcards to exclude.
 137  <R> - the regular expression searched for.
 138  <N> - place to insert null-device.
 139
 140 In interactive usage, the actual value of this variable is set up
 141 by `grep-compute-defaults'; to change the default value, use
 142 Customize or call the function `grep-apply-setting'."
 143   :type '(choice string
 144                  (const :tag "Not Set" nil))
 145   :set 'grep-apply-setting
 146   :version "22.1"
 147   :group 'grep)
 148
 149 (defcustom grep-use-null-device 'auto-detect
 150   "If t, append the value of `null-device' to `grep' commands.
 151 This is done to ensure that the output of grep includes the filename of
 152 any match in the case where only a single file is searched, and is not
 153 necessary if the grep program used supports the `-H' option.
 154
 155 In interactive usage, the actual value of this variable is set up
 156 by `grep-compute-defaults'; to change the default value, use
 157 Customize or call the function `grep-apply-setting'."
 158   :type '(choice (const :tag "Do Not Append Null Device" nil)
 159                  (const :tag "Append Null Device" t)
 160                  (other :tag "Not Set" auto-detect))
 161   :set 'grep-apply-setting
 162   :group 'grep)
 163
 164 ;;;###autoload
 165 (defcustom grep-find-command nil
 166   "The default find command for \\[grep-find].
 167 In interactive usage, the actual value of this variable is set up
 168 by `grep-compute-defaults'; to change the default value, use
 169 Customize or call the function `grep-apply-setting'."
 170   :type '(choice string
 171                  (const :tag "Not Set" nil))
 172   :set 'grep-apply-setting
 173   :group 'grep)
 174
 175 (defcustom grep-find-template nil
 176   "The default command to run for \\[rgrep].
 177 The following place holders should be present in the string:
 178  <D> - base directory for find
 179  <X> - find options to restrict or expand the directory list
 180  <F> - find options to limit the files matched
 181  <C> - place to put -i if case insensitive grep
 182  <R> - the regular expression searched for.
 183 In interactive usage, the actual value of this variable is set up
 184 by `grep-compute-defaults'; to change the default value, use
 185 Customize or call the function `grep-apply-setting'."
 186   :type '(choice string
 187                  (const :tag "Not Set" nil))
 188   :set 'grep-apply-setting
 189   :version "22.1"
 190   :group 'grep)
 191
 192 (defcustom grep-files-aliases
 193   '(("all" .   "* .*")
 194     ("el" .    "*.el")
 195     ("ch" .    "*.[ch]")
 196     ("c" .     "*.c")
 197     ("cc" .    "*.cc *.cxx *.cpp *.C *.CC *.c++")
 198     ("cchh" .  "*.cc *.[ch]xx *.[ch]pp *.[CHh] *.CC *.HH *.[ch]++")
 199     ("hh" .    "*.hxx *.hpp *.[Hh] *.HH *.h++")
 200     ("h" .     "*.h")
 201     ("l" .     "[Cc]hange[Ll]og*")
 202     ("m" .     "[Mm]akefile*")
 203     ("tex" .   "*.tex")
 204     ("texi" .  "*.texi")
 205     ("asm" .   "*.[sS]"))
 206   "*Alist of aliases for the FILES argument to `lgrep' and `rgrep'."
 207   :type 'alist
 208   :group 'grep)
 209
 210 (defcustom grep-find-ignored-directories
 211   vc-directory-exclusion-list
 212   "*List of names of sub-directories which `rgrep' shall not recurse into.
 213 If an element is a cons cell, the car is called on the search directory
 214 to determine whether cdr should not be recursed into."
 215   :type '(choice (repeat :tag "Ignored directories" string)
 216                  (const :tag "No ignored directories" nil))
 217   :group 'grep)
 218
 219 (defcustom grep-find-ignored-files
 220   (cons ".#*" (delq nil (mapcar (lambda (s)
 221                                   (unless (string-match-p "/\\'" s)
 222                                     (concat "*" s)))
 223                                 completion-ignored-extensions)))
 224   "*List of file names which `rgrep' and `lgrep' shall exclude.
 225 If an element is a cons cell, the car is called on the search directory
 226 to determine whether cdr should not be excluded."
 227   :type '(choice (repeat :tag "Ignored file" string)
 228                  (const :tag "No ignored files" nil))
 229   :group 'grep)
 230
 231 (defcustom grep-error-screen-columns nil
 232   "*If non-nil, column numbers in grep hits are screen columns.
 233 See `compilation-error-screen-columns'"
 234   :type '(choice (const :tag "Default" nil)
 235                  integer)
 236   :version "22.1"
 237   :group 'grep)
 238
 239 ;;;###autoload
 240 (defcustom grep-setup-hook nil
 241   "List of hook functions run by `grep-process-setup' (see `run-hooks')."
 242   :type 'hook
 243   :group 'grep)
 244
 245 (defvar grep-mode-map
 246   (let ((map (make-sparse-keymap)))
 247     (set-keymap-parent map compilation-minor-mode-map)
 248     (define-key map " " 'scroll-up)
 249     (define-key map "\^?" 'scroll-down)
 250     (define-key map "\C-c\C-f" 'next-error-follow-minor-mode)
 251
 252     (define-key map "\r" 'compile-goto-error)  ;; ?
 253     (define-key map "n" 'next-error-no-select)
 254     (define-key map "p" 'previous-error-no-select)
 255     (define-key map "{" 'compilation-previous-file)
 256     (define-key map "}" 'compilation-next-file)
 257     (define-key map "\t" 'compilation-next-error)
 258     (define-key map [backtab] 'compilation-previous-error)
 259
 260     ;; Set up the menu-bar
 261     (define-key map [menu-bar grep]
 262       (cons "Grep" (make-sparse-keymap "Grep")))
 263
 264     (define-key map [menu-bar grep compilation-kill-compilation]
 265       '(menu-item "Kill Grep" kill-compilation
 266                   :help "Kill the currently running grep process"))
 267     (define-key map [menu-bar grep compilation-separator2] '("----"))
 268     (define-key map [menu-bar grep compilation-compile]
 269       '(menu-item "Compile..." compile
 270                   :help "Compile the program including the current buffer.  Default: run `make'"))
 271     (define-key map [menu-bar grep compilation-rgrep]
 272       '(menu-item "Recursive grep..." rgrep
 273                   :help "User-friendly recursive grep in directory tree"))
 274     (define-key map [menu-bar grep compilation-lgrep]
 275       '(menu-item "Local grep..." lgrep
 276                   :help "User-friendly grep in a directory"))
 277     (define-key map [menu-bar grep compilation-grep-find]
 278       '(menu-item "Grep via Find..." grep-find
 279                   :help "Run grep via find, with user-specified args"))
 280     (define-key map [menu-bar grep compilation-grep]
 281       '(menu-item "Another grep..." grep
 282                   :help "Run grep, with user-specified args, and collect output in a buffer."))
 283     (define-key map [menu-bar grep compilation-recompile]
 284       '(menu-item "Repeat grep" recompile
 285                   :help "Run grep again"))
 286     (define-key map [menu-bar grep compilation-separator2] '("----"))
 287     (define-key map [menu-bar grep compilation-first-error]
 288       '(menu-item "First Match" first-error
 289                   :help "Restart at the first match, visit corresponding location"))
 290     (define-key map [menu-bar grep compilation-previous-error]
 291       '(menu-item "Previous Match" previous-error
 292                   :help "Visit the previous match and corresponding location"))
 293     (define-key map [menu-bar grep compilation-next-error]
 294       '(menu-item "Next Match" next-error
 295                   :help "Visit the next match and corresponding location"))
 296     map)
 297   "Keymap for grep buffers.
 298 `compilation-minor-mode-map' is a cdr of this.")
 299
 300 (defvar grep-mode-tool-bar-map
 301   ;; When bootstrapping, tool-bar-map is not properly initialized yet,
 302   ;; so don't do anything.
 303   (when (keymapp (butlast tool-bar-map))
 304     (let ((map (butlast (copy-keymap tool-bar-map)))
 305           (help (last tool-bar-map))) ;; Keep Help last in tool bar
 306       (tool-bar-local-item
 307        "left-arrow" 'previous-error-no-select 'previous-error-no-select map
 308        :rtl "right-arrow"
 309        :help "Goto previous match")
 310       (tool-bar-local-item
 311        "right-arrow" 'next-error-no-select 'next-error-no-select map
 312        :rtl "left-arrow"
 313        :help "Goto next match")
 314       (tool-bar-local-item
 315        "cancel" 'kill-compilation 'kill-compilation map
 316        :enable '(let ((buffer (compilation-find-buffer)))
 317                   (get-buffer-process buffer))
 318        :help "Stop grep")
 319       (tool-bar-local-item
 320        "refresh" 'recompile 'recompile map
 321        :help "Restart grep")
 322       (append map help))))
 323
 324 (defalias 'kill-grep 'kill-compilation)
 325
 326 ;;;; TODO --- refine this!!
 327
 328 ;; (defcustom grep-use-compilation-buffer t
 329 ;;   "When non-nil, grep specific commands update `compilation-last-buffer'.
 330 ;; This means that standard compile commands like \\[next-error] and \\[compile-goto-error]
 331 ;; can be used to navigate between grep matches (the default).
 332 ;; Otherwise, the grep specific commands like \\[grep-next-match] must
 333 ;; be used to navigate between grep matches."
 334 ;;   :type 'boolean
 335 ;;   :group 'grep)
 336
 337 ;; override compilation-last-buffer
 338 (defvar grep-last-buffer nil
 339   "The most recent grep buffer.
 340 A grep buffer becomes most recent when you select Grep mode in it.
 341 Notice that using \\[next-error] or \\[compile-goto-error] modifies
 342 `complation-last-buffer' rather than `grep-last-buffer'.")
 343
 344 ;;;###autoload
 345 (defconst grep-regexp-alist
 346   '(("^\\(.+?\\)\\(:[ \t]*\\)\\([1-9][0-9]*\\)\\2"
 347      1 3)
 348     ;; Rule to match column numbers is commented out since no known grep
 349     ;; produces them
 350     ;; ("^\\(.+?\\)\\(:[ \t]*\\)\\([0-9]+\\)\\2\\(?:\\([0-9]+\\)\\(?:-\\([0-9]+\\)\\)?\\2\\)?"
 351     ;;  1 3 (4 . 5))
 352     ;; Note that we want to use as tight a regexp as we can to try and
 353     ;; handle weird file names (with colons in them) as well as possible.
 354     ;; E.g. we use [1-9][0-9]* rather than [0-9]+ so as to accept ":034:" in
 355     ;; file names.
 356     ("^\\(\\(.+?\\):\\([1-9][0-9]*\\):\\).*?\
 357 \\(\033\\[01;31m\\(?:\033\\[K\\)?\\)\\(.*?\\)\\(\033\\[[0-9]*m\\)"
 358      2 3
 359      ;; Calculate column positions (beg . end) of first grep match on a line
 360      ((lambda ()
 361         (setq compilation-error-screen-columns nil)
 362         (- (match-beginning 4) (match-end 1)))
 363       .
 364       (lambda () (- (match-end 5) (match-end 1)
 365                (- (match-end 4) (match-beginning 4)))))
 366      nil 1)
 367     ("^Binary file \\(.+\\) matches$" 1 nil nil 0 1))
 368   "Regexp used to match grep hits.  See `compilation-error-regexp-alist'.")
 369
 370 (defvar grep-error "grep hit"
 371   "Message to print when no matches are found.")
 372
 373 ;; Reverse the colors because grep hits are not errors (though we jump there
 374 ;; with `next-error'), and unreadable files can't be gone to.
 375 (defvar grep-hit-face   compilation-info-face
 376   "Face name to use for grep hits.")
 377
 378 (defvar grep-error-face 'compilation-error
 379   "Face name to use for grep error messages.")
 380
 381 (defvar grep-match-face 'match
 382   "Face name to use for grep matches.")
 383
 384 (defvar grep-context-face 'shadow
 385   "Face name to use for grep context lines.")
 386
 387 (defvar grep-mode-font-lock-keywords
 388    '(;; Command output lines.
 389      (": \\(.+\\): \\(?:Permission denied\\|No such \\(?:file or directory\\|device or address\\)\\)$"
 390       1 grep-error-face)
 391      ;; remove match from grep-regexp-alist before fontifying
 392      ("^Grep[/a-zA-z]* started.*"
 393       (0 '(face nil compilation-message nil help-echo nil mouse-face nil) t))
 394      ("^Grep[/a-zA-z]* finished \\(?:(\\(matches found\\))\\|with \\(no matches found\\)\\).*"
 395       (0 '(face nil compilation-message nil help-echo nil mouse-face nil) t)
 396       (1 compilation-info-face nil t)
 397       (2 compilation-warning-face nil t))
 398      ("^Grep[/a-zA-z]* \\(exited abnormally\\|interrupt\\|killed\\|terminated\\)\\(?:.*with code \\([0-9]+\\)\\)?.*"
 399       (0 '(face nil compilation-message nil help-echo nil mouse-face nil) t)
 400       (1 grep-error-face)
 401       (2 grep-error-face nil t))
 402      ("^.+?-[0-9]+-.*\n" (0 grep-context-face)))
 403    "Additional things to highlight in grep output.
 404 This gets tacked on the end of the generated expressions.")
 405
 406 ;;;###autoload
 407 (defvar grep-program (purecopy "grep")
 408   "The default grep program for `grep-command' and `grep-find-command'.
 409 This variable's value takes effect when `grep-compute-defaults' is called.")
 410
 411 ;;;###autoload
 412 (defvar find-program (purecopy "find")
 413   "The default find program for `grep-find-command'.
 414 This variable's value takes effect when `grep-compute-defaults' is called.")
 415
 416 ;;;###autoload
 417 (defvar xargs-program (purecopy "xargs")
 418   "The default xargs program for `grep-find-command'.
 419 See `grep-find-use-xargs'.
 420 This variable's value takes effect when `grep-compute-defaults' is called.")
 421
 422 ;;;###autoload
 423 (defvar grep-find-use-xargs nil
 424   "How to invoke find and grep.
 425 If `exec', use `find -exec {} ;'.
 426 If `exec-plus' use `find -exec {} +'.
 427 If `gnu', use `find -print0' and `xargs -0'.
 428 Any other value means to use `find -print' and `xargs'.
 429
 430 This variable's value takes effect when `grep-compute-defaults' is called.")
 431
 432 ;; History of grep commands.
 433 ;;;###autoload
 434 (defvar grep-history nil)
 435 ;;;###autoload
 436 (defvar grep-find-history nil)
 437
 438 ;; History of lgrep and rgrep regexp and files args.
 439 (defvar grep-regexp-history nil)
 440 (defvar grep-files-history nil)
 441
 442 ;;;###autoload
 443 (defun grep-process-setup ()
 444   "Setup compilation variables and buffer for `grep'.
 445 Set up `compilation-exit-message-function' and run `grep-setup-hook'."
 446   (when (eq grep-highlight-matches 'auto-detect)
 447     (grep-compute-defaults))
 448   (unless (or (eq grep-highlight-matches 'auto-detect)
 449               ;; Uses font-lock to parse color escapes.  (Bug#8084)
 450               (null font-lock-mode)
 451               (null grep-highlight-matches))
 452     ;; `setenv' modifies `process-environment' let-bound in `compilation-start'
 453     ;; Any TERM except "dumb" allows GNU grep to use `--color=auto'
 454     (setenv "TERM" "emacs-grep")
 455     (setenv "GREP_OPTIONS"
 456             (concat (getenv "GREP_OPTIONS")
 457                     " --color=" (if (eq grep-highlight-matches 'always)
 458                                     "always" "auto")))
 459     ;; GREP_COLOR is used in GNU grep 2.5.1, but deprecated in later versions
 460     (setenv "GREP_COLOR" "01;31")
 461     ;; GREP_COLORS is used in GNU grep 2.5.2 and later versions
 462     (setenv "GREP_COLORS" "mt=01;31:fn=:ln=:bn=:se=:ml=:cx=:ne"))
 463   (set (make-local-variable 'compilation-exit-message-function)
 464        (lambda (status code msg)
 465          (if (eq status 'exit)
 466              ;; This relies on the fact that `compilation-start'
 467              ;; sets buffer-modified to nil before running the command,
 468              ;; so the buffer is still unmodified if there is no output.
 469              (cond ((and (zerop code) (buffer-modified-p))
 470                     '("finished (matches found)\n" . "matched"))
 471                    ((or (= code 1) (not (buffer-modified-p)))
 472                     '("finished with no matches found\n" . "no match"))
 473                    (t
 474                     (cons msg code)))
 475            (cons msg code))))
 476   (run-hooks 'grep-setup-hook))
 477
 478 (defun grep-filter ()
 479   "Handle match highlighting escape sequences inserted by the grep process.
 480 This function is called from `compilation-filter-hook'."
 481   (save-excursion
 482     (forward-line 0)
 483     (let ((end (point)))
 484       (goto-char compilation-filter-start)
 485       (forward-line 0)
 486       ;; Only operate on whole lines so we don't get caught with part of an
 487       ;; escape sequence in one chunk and the rest in another.
 488       (when (< (point) end)
 489         (setq end (copy-marker end))
 490         ;; Highlight grep matches and delete marking sequences.
 491         (while (re-search-forward "\033\\[01;31m\\(.*?\\)\033\\[[0-9]*m" end 1)
 492           (replace-match (propertize (match-string 1)
 493                                      'face nil 'font-lock-face grep-match-face)
 494                          t t))
 495         ;; Delete all remaining escape sequences
 496         (goto-char compilation-filter-start)
 497         (while (re-search-forward "\033\\[[0-9;]*[mK]" end 1)
 498           (replace-match "" t t))))))
 499
 500 (defun grep-probe (command args &optional func result)
 501   (let (process-file-side-effects)
 502     (equal (condition-case nil
 503                (apply (or func 'process-file) command args)
 504              (error nil))
 505            (or result 0))))
 506
 507 ;;;###autoload
 508 (defun grep-compute-defaults ()
 509   ;; Keep default values.
 510   (unless grep-host-defaults-alist
 511     (add-to-list
 512      'grep-host-defaults-alist
 513      (cons nil
 514            `((grep-command ,grep-command)
 515              (grep-template ,grep-template)
 516              (grep-use-null-device ,grep-use-null-device)
 517              (grep-find-command ,grep-find-command)
 518              (grep-find-template ,grep-find-template)
 519              (grep-find-use-xargs ,grep-find-use-xargs)
 520              (grep-highlight-matches ,grep-highlight-matches)))))
 521   (let* ((host-id
 522           (intern (or (file-remote-p default-directory) "localhost")))
 523          (host-defaults (assq host-id grep-host-defaults-alist))
 524          (defaults (assq nil grep-host-defaults-alist)))
 525     ;; There are different defaults on different hosts.  They must be
 526     ;; computed for every host once.
 527     (dolist (setting '(grep-command grep-template
 528                        grep-use-null-device grep-find-command
 529                        grep-find-template grep-find-use-xargs
 530                        grep-highlight-matches))
 531       (set setting
 532            (cadr (or (assq setting host-defaults)
 533                      (assq setting defaults)))))
 534
 535     (unless (or (not grep-use-null-device) (eq grep-use-null-device t))
 536       (setq grep-use-null-device
 537             (with-temp-buffer
 538               (let ((hello-file (expand-file-name "HELLO" data-directory)))
 539                 (not
 540                  (and (if grep-command
 541                           ;; `grep-command' is already set, so
 542                           ;; use that for testing.
 543                           (grep-probe grep-command
 544                                       `(nil t nil "^English" ,hello-file)
 545                                       #'call-process-shell-command)
 546                         ;; otherwise use `grep-program'
 547                         (grep-probe grep-program
 548                                     `(nil t nil "-nH" "^English" ,hello-file)))
 549                       (progn
 550                         (goto-char (point-min))
 551                         (looking-at
 552                          (concat (regexp-quote hello-file)
 553                                  ":[0-9]+:English")))))))))
 554     (unless (and grep-command grep-find-command
 555                  grep-template grep-find-template)
 556       (let ((grep-options
 557              (concat (if grep-use-null-device "-n" "-nH")
 558                      (if (grep-probe grep-program
 559                                      `(nil nil nil "-e" "foo" ,null-device)
 560                                      nil 1)
 561                          " -e"))))
 562         (unless grep-command
 563           (setq grep-command
 564                 (format "%s %s " grep-program grep-options)))
 565         (unless grep-template
 566           (setq grep-template
 567                 (format "%s <X> <C> %s <R> <F>" grep-program grep-options)))
 568         (unless grep-find-use-xargs
 569           (setq grep-find-use-xargs
 570                 (cond
 571                  ((grep-probe find-program
 572                               `(nil nil nil ,null-device "-exec" "echo"
 573                                     "{}" "+"))
 574                   'exec-plus)
 575                  ((and
 576                    (grep-probe find-program `(nil nil nil ,null-device "-print0"))
 577                    (grep-probe xargs-program `(nil nil nil "-0" "-e" "echo")))
 578                   'gnu)
 579                  (t
 580                   'exec))))
 581         (unless grep-find-command
 582           (setq grep-find-command
 583                 (cond ((eq grep-find-use-xargs 'gnu)
 584                        ;; Windows shells need the program file name
 585                        ;; after the pipe symbol be quoted if they use
 586                        ;; forward slashes as directory separators.
 587                        (format "%s . -type f -print0 | \"%s\" -0 -e %s"
 588                                find-program xargs-program grep-command))
 589                       ((memq grep-find-use-xargs '(exec exec-plus))
 590                        (let ((cmd0 (format "%s . -type f -exec %s"
 591                                            find-program grep-command))
 592                              (null (if grep-use-null-device
 593                                        (format "%s " null-device)
 594                                      "")))
 595                          (cons
 596                           (if (eq grep-find-use-xargs 'exec-plus)
 597                               (format "%s %s{} +" cmd0 null)
 598                             (format "%s {} %s%s" cmd0 null
 599                                     (shell-quote-argument ";")))
 600                           (1+ (length cmd0)))))
 601                       (t
 602                        (format "%s . -type f -print | \"%s\" %s"
 603                                find-program xargs-program grep-command)))))
 604         (unless grep-find-template
 605           (setq grep-find-template
 606                 (let ((gcmd (format "%s <C> %s <R>"
 607                                     grep-program grep-options))
 608                       (null (if grep-use-null-device
 609                                 (format "%s " null-device)
 610                               "")))
 611                   (cond ((eq grep-find-use-xargs 'gnu)
 612                          (format "%s . <X> -type f <F> -print0 | \"%s\" -0 -e %s"
 613                                  find-program xargs-program gcmd))
 614                         ((eq grep-find-use-xargs 'exec)
 615                          (format "%s . <X> -type f <F> -exec %s {} %s%s"
 616                                  find-program gcmd null
 617                                  (shell-quote-argument ";")))
 618                         ((eq grep-find-use-xargs 'exec-plus)
 619                          (format "%s . <X> -type f <F> -exec %s %s{} +"
 620                                  find-program gcmd null))
 621                         (t
 622                          (format "%s . <X> -type f <F> -print | \"%s\" %s"
 623                                  find-program xargs-program gcmd))))))))
 624     (when (eq grep-highlight-matches 'auto-detect)
 625       (setq grep-highlight-matches
 626             (with-temp-buffer
 627               (and (grep-probe grep-program '(nil t nil "--help"))
 628                    (progn
 629                      (goto-char (point-min))
 630                      (search-forward "--color" nil t))
 631                    ;; Windows and DOS pipes fail `isatty' detection in Grep.
 632                    (if (memq system-type '(windows-nt ms-dos))
 633                        'always 'auto)))))
 634
 635     ;; Save defaults for this host.
 636     (setq grep-host-defaults-alist
 637           (delete (assq host-id grep-host-defaults-alist)
 638                   grep-host-defaults-alist))
 639     (add-to-list
 640      'grep-host-defaults-alist
 641      (cons host-id
 642            `((grep-command ,grep-command)
 643              (grep-template ,grep-template)
 644              (grep-use-null-device ,grep-use-null-device)
 645              (grep-find-command ,grep-find-command)
 646              (grep-find-template ,grep-find-template)
 647              (grep-find-use-xargs ,grep-find-use-xargs)
 648              (grep-highlight-matches ,grep-highlight-matches))))))
 649
 650 (defun grep-tag-default ()
 651   (or (and transient-mark-mode mark-active
 652            (/= (point) (mark))
 653            (buffer-substring-no-properties (point) (mark)))
 654       (funcall (or find-tag-default-function
 655                    (get major-mode 'find-tag-default-function)
 656                    'find-tag-default))
 657       ""))
 658
 659 (defun grep-default-command ()
 660   "Compute the default grep command for \\[universal-argument] \\[grep] to offer."
 661   (let ((tag-default (shell-quote-argument (grep-tag-default)))
 662         ;; This a regexp to match single shell arguments.
 663         ;; Could someone please add comments explaining it?
 664         (sh-arg-re "\\(\\(?:\"\\(?:[^\"]\\|\\\\\"\\)+\"\\|'[^']+'\\|[^\"' \t\n]\\)+\\)")
 665         (grep-default (or (car grep-history) grep-command)))
 666     ;; In the default command, find the arg that specifies the pattern.
 667     (when (or (string-match
 668                (concat "[^ ]+\\s +\\(?:-[^ ]+\\s +\\)*"
 669                        sh-arg-re "\\(\\s +\\(\\S +\\)\\)?")
 670                grep-default)
 671               ;; If the string is not yet complete.
 672               (string-match "\\(\\)\\'" grep-default))
 673       ;; Maybe we will replace the pattern with the default tag.
 674       ;; But first, maybe replace the file name pattern.
 675       (condition-case nil
 676           (unless (or (not (stringp buffer-file-name))
 677                       (when (match-beginning 2)
 678                         (save-match-data
 679                           (string-match
 680                            (wildcard-to-regexp
 681                             (file-name-nondirectory
 682                              (match-string 3 grep-default)))
 683                            (file-name-nondirectory buffer-file-name)))))
 684             (setq grep-default (concat (substring grep-default
 685                                                   0 (match-beginning 2))
 686                                        " *."
 687                                        (file-name-extension buffer-file-name))))
 688         ;; In case wildcard-to-regexp gets an error
 689         ;; from invalid data.
 690         (error nil))
 691       ;; Now replace the pattern with the default tag.
 692       (replace-match tag-default t t grep-default 1))))
 693
 694
 695 ;;;###autoload
 696 (define-compilation-mode grep-mode "Grep"
 697   "Sets `grep-last-buffer' and `compilation-window-height'."
 698   (setq grep-last-buffer (current-buffer))
 699   (set (make-local-variable 'tool-bar-map) grep-mode-tool-bar-map)
 700   (set (make-local-variable 'compilation-error-face)
 701        grep-hit-face)
 702   (set (make-local-variable 'compilation-error-regexp-alist)
 703        grep-regexp-alist)
 704   ;; compilation-directory-matcher can't be nil, so we set it to a regexp that
 705   ;; can never match.
 706   (set (make-local-variable 'compilation-directory-matcher) '("\\`a\\`"))
 707   (set (make-local-variable 'compilation-process-setup-function)
 708        'grep-process-setup)
 709   (set (make-local-variable 'compilation-disable-input) t)
 710   (add-hook 'compilation-filter-hook 'grep-filter nil t))
 711
 712
 713 ;;;###autoload
 714 (defun grep (command-args)
 715   "Run grep, with user-specified args, and collect output in a buffer.
 716 While grep runs asynchronously, you can use \\[next-error] (M-x next-error),
 717 or \\<grep-mode-map>\\[compile-goto-error] in the grep \
 718 output buffer, to go to the lines where grep
 719 found matches.
 720
 721 For doing a recursive `grep', see the `rgrep' command.  For running
 722 `grep' in a specific directory, see `lgrep'.
 723
 724 This command uses a special history list for its COMMAND-ARGS, so you
 725 can easily repeat a grep command.
 726
 727 A prefix argument says to default the argument based upon the current
 728 tag the cursor is over, substituting it into the last grep command
 729 in the grep command history (or into `grep-command' if that history
 730 list is empty)."
 731   (interactive
 732    (progn
 733      (grep-compute-defaults)
 734      (let ((default (grep-default-command)))
 735        (list (read-shell-command "Run grep (like this): "
 736                                  (if current-prefix-arg default grep-command)
 737                                  'grep-history
 738                                  (if current-prefix-arg nil default))))))
 739
 740   ;; Setting process-setup-function makes exit-message-function work
 741   ;; even when async processes aren't supported.
 742   (compilation-start (if (and grep-use-null-device null-device)
 743                          (concat command-args " " null-device)
 744                        command-args)
 745                      'grep-mode))
 746
 747
 748 ;;;###autoload
 749 (defun grep-find (command-args)
 750   "Run grep via find, with user-specified args COMMAND-ARGS.
 751 Collect output in a buffer.
 752 While find runs asynchronously, you can use the \\[next-error] command
 753 to find the text that grep hits refer to.
 754
 755 This command uses a special history list for its arguments, so you can
 756 easily repeat a find command."
 757   (interactive
 758    (progn
 759      (grep-compute-defaults)
 760      (if grep-find-command
 761          (list (read-shell-command "Run find (like this): "
 762                                    grep-find-command 'grep-find-history))
 763        ;; No default was set
 764        (read-string
 765         "compile.el: No `grep-find-command' command available. Press RET.")
 766        (list nil))))
 767   (when command-args
 768     (let ((null-device nil))            ; see grep
 769       (grep command-args))))
 770
 771 ;;;###autoload
 772 (defalias 'find-grep 'grep-find)
 773
 774
 775 ;; User-friendly interactive API.
 776
 777 (defconst grep-expand-keywords
 778   '(("<C>" . (and cf (isearch-no-upper-case-p regexp t) "-i"))
 779     ("<D>" . dir)
 780     ("<F>" . files)
 781     ("<N>" . null-device)
 782     ("<X>" . excl)
 783     ("<R>" . (shell-quote-argument (or regexp ""))))
 784   "List of substitutions performed by `grep-expand-template'.
 785 If car of an element matches, the cdr is evalled in to get the
 786 substitution string.  Note dynamic scoping of variables.")
 787
 788 (defun grep-expand-template (template &optional regexp files dir excl)
 789   "Patch grep COMMAND string replacing <C>, <D>, <F>, <R>, and <X>."
 790   (let ((command template)
 791         (cf case-fold-search)
 792         (case-fold-search nil))
 793     (dolist (kw grep-expand-keywords command)
 794       (if (string-match (car kw) command)
 795           (setq command
 796                 (replace-match
 797                  (or (if (symbolp (cdr kw))
 798                          (symbol-value (cdr kw))
 799                        (save-match-data (eval (cdr kw))))
 800                      "")
 801                  t t command))))))
 802
 803 (defun grep-read-regexp ()
 804   "Read regexp arg for interactive grep."
 805   (let ((default (grep-tag-default)))
 806     (read-string
 807      (concat "Search for"
 808              (if (and default (> (length default) 0))
 809                  (format " (default \"%s\"): " default) ": "))
 810      nil 'grep-regexp-history default)))
 811
 812 (defun grep-read-files (regexp)
 813   "Read files arg for interactive grep."
 814   (let* ((bn (or (buffer-file-name)
 815                  (replace-regexp-in-string "<[0-9]+>\\'" "" (buffer-name))))
 816          (fn (and bn
 817                   (stringp bn)
 818                   (file-name-nondirectory bn)))
 819          (default-alias
 820            (and fn
 821                 (let ((aliases (remove (assoc "all" grep-files-aliases)
 822                                        grep-files-aliases))
 823                       alias)
 824                   (while aliases
 825                     (setq alias (car aliases)
 826                           aliases (cdr aliases))
 827                     (if (string-match (mapconcat
 828                                        'wildcard-to-regexp
 829                                        (split-string (cdr alias) nil t)
 830                                        "\\|")
 831                                       fn)
 832                         (setq aliases nil)
 833                       (setq alias nil)))
 834                   (cdr alias))))
 835          (default-extension
 836            (and fn
 837                 (let ((ext (file-name-extension fn)))
 838                   (and ext (concat "*." ext)))))
 839          (default
 840            (or default-alias
 841                default-extension
 842                (car grep-files-history)
 843                (car (car grep-files-aliases))))
 844          (files (completing-read
 845                  (concat "Search for \"" regexp
 846                          "\" in files"
 847                          (if default (concat " (default " default ")"))
 848                          ": ")
 849                  'read-file-name-internal
 850                  nil nil nil 'grep-files-history
 851                  (delete-dups
 852                   (delq nil (append (list default default-alias default-extension)
 853                                     (mapcar 'car grep-files-aliases)))))))
 854     (and files
 855          (or (cdr (assoc files grep-files-aliases))
 856              files))))
 857
 858 ;;;###autoload
 859 (defun lgrep (regexp &optional files dir confirm)
 860   "Run grep, searching for REGEXP in FILES in directory DIR.
 861 The search is limited to file names matching shell pattern FILES.
 862 FILES may use abbreviations defined in `grep-files-aliases', e.g.
 863 entering `ch' is equivalent to `*.[ch]'.
 864
 865 With \\[universal-argument] prefix, you can edit the constructed shell command line
 866 before it is executed.
 867 With two \\[universal-argument] prefixes, directly edit and run `grep-command'.
 868
 869 Collect output in a buffer.  While grep runs asynchronously, you
 870 can use \\[next-error] (M-x next-error), or \\<grep-mode-map>\\[compile-goto-error] \
 871 in the grep output buffer,
 872 to go to the lines where grep found matches.
 873
 874 This command shares argument histories with \\[rgrep] and \\[grep]."
 875   (interactive
 876    (progn
 877      (grep-compute-defaults)
 878      (cond
 879       ((and grep-command (equal current-prefix-arg '(16)))
 880        (list (read-from-minibuffer "Run: " grep-command
 881                                    nil nil 'grep-history)))
 882       ((not grep-template)
 883        (error "grep.el: No `grep-template' available"))
 884       (t (let* ((regexp (grep-read-regexp))
 885                 (files (grep-read-files regexp))
 886                 (dir (read-directory-name "In directory: "
 887                                           nil default-directory t))
 888                 (confirm (equal current-prefix-arg '(4))))
 889            (list regexp files dir confirm))))))
 890   (when (and (stringp regexp) (> (length regexp) 0))
 891     (unless (and dir (file-directory-p dir) (file-readable-p dir))
 892       (setq dir default-directory))
 893     (let ((command regexp))
 894       (if (null files)
 895           (if (string= command grep-command)
 896               (setq command nil))
 897         (setq dir (file-name-as-directory (expand-file-name dir)))
 898         (setq command (grep-expand-template
 899                        grep-template
 900                        regexp
 901                        files
 902                        nil
 903                        (and grep-find-ignored-files
 904                             (concat " --exclude="
 905                                     (mapconcat
 906                                      #'(lambda (ignore)
 907                                          (cond ((stringp ignore)
 908                                                 (shell-quote-argument ignore))
 909                                                ((consp ignore)
 910                                                 (and (funcall (car ignore) dir)
 911                                                      (shell-quote-argument
 912                                                       (cdr ignore))))))
 913                                      grep-find-ignored-files
 914                                      " --exclude=")))))
 915         (when command
 916           (if confirm
 917               (setq command
 918                     (read-from-minibuffer "Confirm: "
 919                                           command nil nil 'grep-history))
 920             (add-to-history 'grep-history command))))
 921       (when command
 922         (let ((default-directory dir))
 923           ;; Setting process-setup-function makes exit-message-function work
 924           ;; even when async processes aren't supported.
 925           (compilation-start (if (and grep-use-null-device null-device)
 926                                  (concat command " " null-device)
 927                                command)
 928                              'grep-mode))
 929         (if (eq next-error-last-buffer (current-buffer))
 930             (setq default-directory dir))))))
 931
 932
 933 (defvar find-name-arg)      ; not autoloaded but defined in find-dired
 934
 935 ;;;###autoload
 936 (defun rgrep (regexp &optional files dir confirm)
 937   "Recursively grep for REGEXP in FILES in directory tree rooted at DIR.
 938 The search is limited to file names matching shell pattern FILES.
 939 FILES may use abbreviations defined in `grep-files-aliases', e.g.
 940 entering `ch' is equivalent to `*.[ch]'.
 941
 942 With \\[universal-argument] prefix, you can edit the constructed shell command line
 943 before it is executed.
 944 With two \\[universal-argument] prefixes, directly edit and run `grep-find-command'.
 945
 946 Collect output in a buffer.  While find runs asynchronously, you
 947 can use \\[next-error] (M-x next-error), or \\<grep-mode-map>\\[compile-goto-error] \
 948 in the grep output buffer,
 949 to go to the lines where grep found matches.
 950
 951 This command shares argument histories with \\[lgrep] and \\[grep-find]."
 952   (interactive
 953    (progn
 954      (grep-compute-defaults)
 955      (cond
 956       ((and grep-find-command (equal current-prefix-arg '(16)))
 957        (list (read-from-minibuffer "Run: " grep-find-command
 958                                    nil nil 'grep-find-history)))
 959       ((not grep-find-template)
 960        (error "grep.el: No `grep-find-template' available"))
 961       (t (let* ((regexp (grep-read-regexp))
 962                 (files (grep-read-files regexp))
 963                 (dir (read-directory-name "Base directory: "
 964                                           nil default-directory t))
 965                 (confirm (equal current-prefix-arg '(4))))
 966            (list regexp files dir confirm))))))
 967   (when (and (stringp regexp) (> (length regexp) 0))
 968     (unless (and dir (file-directory-p dir) (file-readable-p dir))
 969       (setq dir default-directory))
 970     (if (null files)
 971         (if (not (string= regexp (if (consp grep-find-command)
 972                                      (car grep-find-command)
 973                                    grep-find-command)))
 974             (compilation-start regexp 'grep-mode))
 975       (setq dir (file-name-as-directory (expand-file-name dir)))
 976       (require 'find-dired)             ; for `find-name-arg'
 977       (let ((command (grep-expand-template
 978                       grep-find-template
 979                       regexp
 980                       (concat (shell-quote-argument "(")
 981                               " " find-name-arg " "
 982                               (mapconcat #'shell-quote-argument
 983                                          (split-string files)
 984                                          (concat " -o " find-name-arg " "))
 985                               " "
 986                               (shell-quote-argument ")"))
 987                       dir
 988                       (concat
 989                        (and grep-find-ignored-directories
 990                             (concat (shell-quote-argument "(")
 991                                     ;; we should use shell-quote-argument here
 992                                     " -path "
 993                                     (mapconcat
 994                                      #'(lambda (ignore)
 995                                          (cond ((stringp ignore)
 996                                                 (shell-quote-argument
 997                                                  (concat "*/" ignore)))
 998                                                ((consp ignore)
 999                                                 (and (funcall (car ignore) dir)
1000                                                      (shell-quote-argument
1001                                                       (concat "*/"
1002                                                               (cdr ignore)))))))
1003                                      grep-find-ignored-directories
1004                                      " -o -path ")
1005                                     " "
1006                                     (shell-quote-argument ")")
1007                                     " -prune -o "))
1008                        (and grep-find-ignored-files
1009                             (concat (shell-quote-argument "(")
1010                                     ;; we should use shell-quote-argument here
1011                                     " -name "
1012                                     (mapconcat
1013                                      #'(lambda (ignore)
1014                                          (cond ((stringp ignore)
1015                                                 (shell-quote-argument ignore))
1016                                                ((consp ignore)
1017                                                 (and (funcall (car ignore) dir)
1018                                                      (shell-quote-argument
1019                                                       (cdr ignore))))))
1020                                      grep-find-ignored-files
1021                                      " -o -name ")
1022                                     " "
1023                                     (shell-quote-argument ")")
1024                                     " -prune -o "))))))
1025         (when command
1026           (if confirm
1027               (setq command
1028                     (read-from-minibuffer "Confirm: "
1029                                           command nil nil 'grep-find-history))
1030             (add-to-history 'grep-find-history command))
1031           (let ((default-directory dir))
1032             (compilation-start command 'grep-mode))
1033           ;; Set default-directory if we started rgrep in the *grep* buffer.
1034           (if (eq next-error-last-buffer (current-buffer))
1035               (setq default-directory dir)))))))
1036
1037 ;;;###autoload
1038 (defun zrgrep (regexp &optional files dir confirm grep-find-template)
1039   "Recursively grep for REGEXP in gzipped FILES in tree rooted at DIR.
1040 Like `rgrep' but uses `zgrep' for `grep-program', sets the default
1041 file name to `*.gz', and sets `grep-highlight-matches' to `always'."
1042   (interactive
1043    (progn
1044      ;; Compute standard default values.
1045      (grep-compute-defaults)
1046      ;; Compute the default zrgrep command by running `grep-compute-defaults'
1047      ;; for grep program "zgrep", but not changing global values.
1048      (let ((grep-program "zgrep")
1049            ;; Don't change global values for variables computed
1050            ;; by `grep-compute-defaults'.
1051            (grep-find-template nil)
1052            (grep-find-command nil)
1053            (grep-host-defaults-alist nil)
1054            ;; Use for `grep-read-files'
1055            (grep-files-aliases '(("all" . "* .*")
1056                                  ("gz"  . "*.gz"))))
1057        ;; Recompute defaults using let-bound values above.
1058        (grep-compute-defaults)
1059        (cond
1060         ((and grep-find-command (equal current-prefix-arg '(16)))
1061          (list (read-from-minibuffer "Run: " grep-find-command
1062                                      nil nil 'grep-find-history)))
1063         ((not grep-find-template)
1064          (error "grep.el: No `grep-find-template' available"))
1065         (t (let* ((regexp (grep-read-regexp))
1066                   (files (grep-read-files regexp))
1067                   (dir (read-directory-name "Base directory: "
1068                                             nil default-directory t))
1069                   (confirm (equal current-prefix-arg '(4))))
1070              (list regexp files dir confirm grep-find-template)))))))
1071   ;; Set `grep-highlight-matches' to `always'
1072   ;; since `zgrep' puts filters in the grep output.
1073   (let ((grep-highlight-matches 'always))
1074     ;; `rgrep' uses the dynamically bound value `grep-find-template'
1075     ;; from the argument `grep-find-template' whose value is computed
1076     ;; in the `interactive' spec.
1077     (rgrep regexp files dir confirm)))
1078
1079 ;;;###autoload
1080 (defalias 'rzgrep 'zrgrep)
1081
1082 (provide 'grep)
1083
1084 ;;; grep.el ends here