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              (cond ((zerop code)
 467                     '("finished (matches found)\n" . "matched"))
 468                    ((= code 1)
 469                     '("finished with no matches found\n" . "no match"))
 470                    (t
 471                     (cons msg code)))
 472            (cons msg code))))
 473   (run-hooks 'grep-setup-hook))
 474
 475 (defun grep-filter ()
 476   "Handle match highlighting escape sequences inserted by the grep process.
 477 This function is called from `compilation-filter-hook'."
 478   (save-excursion
 479     (forward-line 0)
 480     (let ((end (point)))
 481       (goto-char compilation-filter-start)
 482       (forward-line 0)
 483       ;; Only operate on whole lines so we don't get caught with part of an
 484       ;; escape sequence in one chunk and the rest in another.
 485       (when (< (point) end)
 486         (setq end (copy-marker end))
 487         ;; Highlight grep matches and delete marking sequences.
 488         (while (re-search-forward "\033\\[01;31m\\(.*?\\)\033\\[[0-9]*m" end 1)
 489           (replace-match (propertize (match-string 1)
 490                                      'face nil 'font-lock-face grep-match-face)
 491                          t t))
 492         ;; Delete all remaining escape sequences
 493         (goto-char compilation-filter-start)
 494         (while (re-search-forward "\033\\[[0-9;]*[mK]" end 1)
 495           (replace-match "" t t))))))
 496
 497 (defun grep-probe (command args &optional func result)
 498   (let (process-file-side-effects)
 499     (equal (condition-case nil
 500                (apply (or func 'process-file) command args)
 501              (error nil))
 502            (or result 0))))
 503
 504 ;;;###autoload
 505 (defun grep-compute-defaults ()
 506   ;; Keep default values.
 507   (unless grep-host-defaults-alist
 508     (add-to-list
 509      'grep-host-defaults-alist
 510      (cons nil
 511            `((grep-command ,grep-command)
 512              (grep-template ,grep-template)
 513              (grep-use-null-device ,grep-use-null-device)
 514              (grep-find-command ,grep-find-command)
 515              (grep-find-template ,grep-find-template)
 516              (grep-find-use-xargs ,grep-find-use-xargs)
 517              (grep-highlight-matches ,grep-highlight-matches)))))
 518   (let* ((host-id
 519           (intern (or (file-remote-p default-directory) "localhost")))
 520          (host-defaults (assq host-id grep-host-defaults-alist))
 521          (defaults (assq nil grep-host-defaults-alist)))
 522     ;; There are different defaults on different hosts.  They must be
 523     ;; computed for every host once.
 524     (dolist (setting '(grep-command grep-template
 525                        grep-use-null-device grep-find-command
 526                        grep-find-template grep-find-use-xargs
 527                        grep-highlight-matches))
 528       (set setting
 529            (cadr (or (assq setting host-defaults)
 530                      (assq setting defaults)))))
 531
 532     (unless (or (not grep-use-null-device) (eq grep-use-null-device t))
 533       (setq grep-use-null-device
 534             (with-temp-buffer
 535               (let ((hello-file (expand-file-name "HELLO" data-directory)))
 536                 (not
 537                  (and (if grep-command
 538                           ;; `grep-command' is already set, so
 539                           ;; use that for testing.
 540                           (grep-probe grep-command
 541                                       `(nil t nil "^English" ,hello-file)
 542                                       #'call-process-shell-command)
 543                         ;; otherwise use `grep-program'
 544                         (grep-probe grep-program
 545                                     `(nil t nil "-nH" "^English" ,hello-file)))
 546                       (progn
 547                         (goto-char (point-min))
 548                         (looking-at
 549                          (concat (regexp-quote hello-file)
 550                                  ":[0-9]+:English")))))))))
 551     (unless (and grep-command grep-find-command
 552                  grep-template grep-find-template)
 553       (let ((grep-options
 554              (concat (if grep-use-null-device "-n" "-nH")
 555                      (if (grep-probe grep-program
 556                                      `(nil nil nil "-e" "foo" ,null-device)
 557                                      nil 1)
 558                          " -e"))))
 559         (unless grep-command
 560           (setq grep-command
 561                 (format "%s %s " grep-program grep-options)))
 562         (unless grep-template
 563           (setq grep-template
 564                 (format "%s <X> <C> %s <R> <F>" grep-program grep-options)))
 565         (unless grep-find-use-xargs
 566           (setq grep-find-use-xargs
 567                 (cond
 568                  ((grep-probe find-program
 569                               `(nil nil nil ,null-device "-exec" "echo"
 570                                     "{}" "+"))
 571                   'exec-plus)
 572                  ((and
 573                    (grep-probe find-program `(nil nil nil ,null-device "-print0"))
 574                    (grep-probe xargs-program `(nil nil nil "-0" "-e" "echo")))
 575                   'gnu)
 576                  (t
 577                   'exec))))
 578         (unless grep-find-command
 579           (setq grep-find-command
 580                 (cond ((eq grep-find-use-xargs 'gnu)
 581                        ;; Windows shells need the program file name
 582                        ;; after the pipe symbol be quoted if they use
 583                        ;; forward slashes as directory separators.
 584                        (format "%s . -type f -print0 | \"%s\" -0 -e %s"
 585                                find-program xargs-program grep-command))
 586                       ((memq grep-find-use-xargs '(exec exec-plus))
 587                        (let ((cmd0 (format "%s . -type f -exec %s"
 588                                            find-program grep-command))
 589                              (null (if grep-use-null-device
 590                                        (format "%s " null-device)
 591                                      "")))
 592                          (cons
 593                           (if (eq grep-find-use-xargs 'exec-plus)
 594                               (format "%s %s{} +" cmd0 null)
 595                             (format "%s {} %s%s" cmd0 null
 596                                     (shell-quote-argument ";")))
 597                           (1+ (length cmd0)))))
 598                       (t
 599                        (format "%s . -type f -print | \"%s\" %s"
 600                                find-program xargs-program grep-command)))))
 601         (unless grep-find-template
 602           (setq grep-find-template
 603                 (let ((gcmd (format "%s <C> %s <R>"
 604                                     grep-program grep-options))
 605                       (null (if grep-use-null-device
 606                                 (format "%s " null-device)
 607                               "")))
 608                   (cond ((eq grep-find-use-xargs 'gnu)
 609                          (format "%s . <X> -type f <F> -print0 | \"%s\" -0 -e %s"
 610                                  find-program xargs-program gcmd))
 611                         ((eq grep-find-use-xargs 'exec)
 612                          (format "%s . <X> -type f <F> -exec %s {} %s%s"
 613                                  find-program gcmd null
 614                                  (shell-quote-argument ";")))
 615                         ((eq grep-find-use-xargs 'exec-plus)
 616                          (format "%s . <X> -type f <F> -exec %s %s{} +"
 617                                  find-program gcmd null))
 618                         (t
 619                          (format "%s . <X> -type f <F> -print | \"%s\" %s"
 620                                  find-program xargs-program gcmd))))))))
 621     (when (eq grep-highlight-matches 'auto-detect)
 622       (setq grep-highlight-matches
 623             (with-temp-buffer
 624               (and (grep-probe grep-program '(nil t nil "--help"))
 625                    (progn
 626                      (goto-char (point-min))
 627                      (search-forward "--color" nil t))
 628                    ;; Windows and DOS pipes fail `isatty' detection in Grep.
 629                    (if (memq system-type '(windows-nt ms-dos))
 630                        'always 'auto)))))
 631
 632     ;; Save defaults for this host.
 633     (setq grep-host-defaults-alist
 634           (delete (assq host-id grep-host-defaults-alist)
 635                   grep-host-defaults-alist))
 636     (add-to-list
 637      'grep-host-defaults-alist
 638      (cons host-id
 639            `((grep-command ,grep-command)
 640              (grep-template ,grep-template)
 641              (grep-use-null-device ,grep-use-null-device)
 642              (grep-find-command ,grep-find-command)
 643              (grep-find-template ,grep-find-template)
 644              (grep-find-use-xargs ,grep-find-use-xargs)
 645              (grep-highlight-matches ,grep-highlight-matches))))))
 646
 647 (defun grep-tag-default ()
 648   (or (and transient-mark-mode mark-active
 649            (/= (point) (mark))
 650            (buffer-substring-no-properties (point) (mark)))
 651       (funcall (or find-tag-default-function
 652                    (get major-mode 'find-tag-default-function)
 653                    'find-tag-default))
 654       ""))
 655
 656 (defun grep-default-command ()
 657   "Compute the default grep command for \\[universal-argument] \\[grep] to offer."
 658   (let ((tag-default (shell-quote-argument (grep-tag-default)))
 659         ;; This a regexp to match single shell arguments.
 660         ;; Could someone please add comments explaining it?
 661         (sh-arg-re "\\(\\(?:\"\\(?:[^\"]\\|\\\\\"\\)+\"\\|'[^']+'\\|[^\"' \t\n]\\)+\\)")
 662         (grep-default (or (car grep-history) grep-command)))
 663     ;; In the default command, find the arg that specifies the pattern.
 664     (when (or (string-match
 665                (concat "[^ ]+\\s +\\(?:-[^ ]+\\s +\\)*"
 666                        sh-arg-re "\\(\\s +\\(\\S +\\)\\)?")
 667                grep-default)
 668               ;; If the string is not yet complete.
 669               (string-match "\\(\\)\\'" grep-default))
 670       ;; Maybe we will replace the pattern with the default tag.
 671       ;; But first, maybe replace the file name pattern.
 672       (condition-case nil
 673           (unless (or (not (stringp buffer-file-name))
 674                       (when (match-beginning 2)
 675                         (save-match-data
 676                           (string-match
 677                            (wildcard-to-regexp
 678                             (file-name-nondirectory
 679                              (match-string 3 grep-default)))
 680                            (file-name-nondirectory buffer-file-name)))))
 681             (setq grep-default (concat (substring grep-default
 682                                                   0 (match-beginning 2))
 683                                        " *."
 684                                        (file-name-extension buffer-file-name))))
 685         ;; In case wildcard-to-regexp gets an error
 686         ;; from invalid data.
 687         (error nil))
 688       ;; Now replace the pattern with the default tag.
 689       (replace-match tag-default t t grep-default 1))))
 690
 691
 692 ;;;###autoload
 693 (define-compilation-mode grep-mode "Grep"
 694   "Sets `grep-last-buffer' and `compilation-window-height'."
 695   (setq grep-last-buffer (current-buffer))
 696   (set (make-local-variable 'tool-bar-map) grep-mode-tool-bar-map)
 697   (set (make-local-variable 'compilation-error-face)
 698        grep-hit-face)
 699   (set (make-local-variable 'compilation-error-regexp-alist)
 700        grep-regexp-alist)
 701   (set (make-local-variable 'compilation-process-setup-function)
 702        'grep-process-setup)
 703   (set (make-local-variable 'compilation-disable-input) t)
 704   (add-hook 'compilation-filter-hook 'grep-filter nil t))
 705
 706
 707 ;;;###autoload
 708 (defun grep (command-args)
 709   "Run grep, with user-specified args, and collect output in a buffer.
 710 While grep runs asynchronously, you can use \\[next-error] (M-x next-error),
 711 or \\<grep-mode-map>\\[compile-goto-error] in the grep \
 712 output buffer, to go to the lines where grep
 713 found matches.
 714
 715 For doing a recursive `grep', see the `rgrep' command.  For running
 716 `grep' in a specific directory, see `lgrep'.
 717
 718 This command uses a special history list for its COMMAND-ARGS, so you
 719 can easily repeat a grep command.
 720
 721 A prefix argument says to default the argument based upon the current
 722 tag the cursor is over, substituting it into the last grep command
 723 in the grep command history (or into `grep-command' if that history
 724 list is empty)."
 725   (interactive
 726    (progn
 727      (grep-compute-defaults)
 728      (let ((default (grep-default-command)))
 729        (list (read-shell-command "Run grep (like this): "
 730                                  (if current-prefix-arg default grep-command)
 731                                  'grep-history
 732                                  (if current-prefix-arg nil default))))))
 733
 734   ;; Setting process-setup-function makes exit-message-function work
 735   ;; even when async processes aren't supported.
 736   (compilation-start (if (and grep-use-null-device null-device)
 737                          (concat command-args " " null-device)
 738                        command-args)
 739                      'grep-mode))
 740
 741
 742 ;;;###autoload
 743 (defun grep-find (command-args)
 744   "Run grep via find, with user-specified args COMMAND-ARGS.
 745 Collect output in a buffer.
 746 While find runs asynchronously, you can use the \\[next-error] command
 747 to find the text that grep hits refer to.
 748
 749 This command uses a special history list for its arguments, so you can
 750 easily repeat a find command."
 751   (interactive
 752    (progn
 753      (grep-compute-defaults)
 754      (if grep-find-command
 755          (list (read-shell-command "Run find (like this): "
 756                                    grep-find-command 'grep-find-history))
 757        ;; No default was set
 758        (read-string
 759         "compile.el: No `grep-find-command' command available. Press RET.")
 760        (list nil))))
 761   (when command-args
 762     (let ((null-device nil))            ; see grep
 763       (grep command-args))))
 764
 765 ;;;###autoload
 766 (defalias 'find-grep 'grep-find)
 767
 768
 769 ;; User-friendly interactive API.
 770
 771 (defconst grep-expand-keywords
 772   '(("<C>" . (and cf (isearch-no-upper-case-p regexp t) "-i"))
 773     ("<D>" . dir)
 774     ("<F>" . files)
 775     ("<N>" . null-device)
 776     ("<X>" . excl)
 777     ("<R>" . (shell-quote-argument (or regexp ""))))
 778   "List of substitutions performed by `grep-expand-template'.
 779 If car of an element matches, the cdr is evalled in to get the
 780 substitution string.  Note dynamic scoping of variables.")
 781
 782 (defun grep-expand-template (template &optional regexp files dir excl)
 783   "Patch grep COMMAND string replacing <C>, <D>, <F>, <R>, and <X>."
 784   (let ((command template)
 785         (cf case-fold-search)
 786         (case-fold-search nil))
 787     (dolist (kw grep-expand-keywords command)
 788       (if (string-match (car kw) command)
 789           (setq command
 790                 (replace-match
 791                  (or (if (symbolp (cdr kw))
 792                          (symbol-value (cdr kw))
 793                        (save-match-data (eval (cdr kw))))
 794                      "")
 795                  t t command))))))
 796
 797 (defun grep-read-regexp ()
 798   "Read regexp arg for interactive grep."
 799   (let ((default (grep-tag-default)))
 800     (read-string
 801      (concat "Search for"
 802              (if (and default (> (length default) 0))
 803                  (format " (default \"%s\"): " default) ": "))
 804      nil 'grep-regexp-history default)))
 805
 806 (defun grep-read-files (regexp)
 807   "Read files arg for interactive grep."
 808   (let* ((bn (or (buffer-file-name)
 809                  (replace-regexp-in-string "<[0-9]+>\\'" "" (buffer-name))))
 810          (fn (and bn
 811                   (stringp bn)
 812                   (file-name-nondirectory bn)))
 813          (default-alias
 814            (and fn
 815                 (let ((aliases (remove (assoc "all" grep-files-aliases)
 816                                        grep-files-aliases))
 817                       alias)
 818                   (while aliases
 819                     (setq alias (car aliases)
 820                           aliases (cdr aliases))
 821                     (if (string-match (mapconcat
 822                                        'wildcard-to-regexp
 823                                        (split-string (cdr alias) nil t)
 824                                        "\\|")
 825                                       fn)
 826                         (setq aliases nil)
 827                       (setq alias nil)))
 828                   (cdr alias))))
 829          (default-extension
 830            (and fn
 831                 (let ((ext (file-name-extension fn)))
 832                   (and ext (concat "*." ext)))))
 833          (default
 834            (or default-alias
 835                default-extension
 836                (car grep-files-history)
 837                (car (car grep-files-aliases))))
 838          (files (completing-read
 839                  (concat "Search for \"" regexp
 840                          "\" in files"
 841                          (if default (concat " (default " default ")"))
 842                          ": ")
 843                  'read-file-name-internal
 844                  nil nil nil 'grep-files-history
 845                  (delete-dups
 846                   (delq nil (append (list default default-alias default-extension)
 847                                     (mapcar 'car grep-files-aliases)))))))
 848     (and files
 849          (or (cdr (assoc files grep-files-aliases))
 850              files))))
 851
 852 ;;;###autoload
 853 (defun lgrep (regexp &optional files dir confirm)
 854   "Run grep, searching for REGEXP in FILES in directory DIR.
 855 The search is limited to file names matching shell pattern FILES.
 856 FILES may use abbreviations defined in `grep-files-aliases', e.g.
 857 entering `ch' is equivalent to `*.[ch]'.
 858
 859 With \\[universal-argument] prefix, you can edit the constructed shell command line
 860 before it is executed.
 861 With two \\[universal-argument] prefixes, directly edit and run `grep-command'.
 862
 863 Collect output in a buffer.  While grep runs asynchronously, you
 864 can use \\[next-error] (M-x next-error), or \\<grep-mode-map>\\[compile-goto-error] \
 865 in the grep output buffer,
 866 to go to the lines where grep found matches.
 867
 868 This command shares argument histories with \\[rgrep] and \\[grep]."
 869   (interactive
 870    (progn
 871      (grep-compute-defaults)
 872      (cond
 873       ((and grep-command (equal current-prefix-arg '(16)))
 874        (list (read-from-minibuffer "Run: " grep-command
 875                                    nil nil 'grep-history)))
 876       ((not grep-template)
 877        (error "grep.el: No `grep-template' available"))
 878       (t (let* ((regexp (grep-read-regexp))
 879                 (files (grep-read-files regexp))
 880                 (dir (read-directory-name "In directory: "
 881                                           nil default-directory t))
 882                 (confirm (equal current-prefix-arg '(4))))
 883            (list regexp files dir confirm))))))
 884   (when (and (stringp regexp) (> (length regexp) 0))
 885     (unless (and dir (file-directory-p dir) (file-readable-p dir))
 886       (setq dir default-directory))
 887     (let ((command regexp))
 888       (if (null files)
 889           (if (string= command grep-command)
 890               (setq command nil))
 891         (setq dir (file-name-as-directory (expand-file-name dir)))
 892         (setq command (grep-expand-template
 893                        grep-template
 894                        regexp
 895                        files
 896                        nil
 897                        (and grep-find-ignored-files
 898                             (concat " --exclude="
 899                                     (mapconcat
 900                                      #'(lambda (ignore)
 901                                          (cond ((stringp ignore)
 902                                                 (shell-quote-argument ignore))
 903                                                ((consp ignore)
 904                                                 (and (funcall (car ignore) dir)
 905                                                      (shell-quote-argument
 906                                                       (cdr ignore))))))
 907                                      grep-find-ignored-files
 908                                      " --exclude=")))))
 909         (when command
 910           (if confirm
 911               (setq command
 912                     (read-from-minibuffer "Confirm: "
 913                                           command nil nil 'grep-history))
 914             (add-to-history 'grep-history command))))
 915       (when command
 916         (let ((default-directory dir))
 917           ;; Setting process-setup-function makes exit-message-function work
 918           ;; even when async processes aren't supported.
 919           (compilation-start (if (and grep-use-null-device null-device)
 920                                  (concat command " " null-device)
 921                                command)
 922                              'grep-mode))
 923         (if (eq next-error-last-buffer (current-buffer))
 924             (setq default-directory dir))))))
 925
 926
 927 (defvar find-name-arg)      ; not autoloaded but defined in find-dired
 928
 929 ;;;###autoload
 930 (defun rgrep (regexp &optional files dir confirm)
 931   "Recursively grep for REGEXP in FILES in directory tree rooted at DIR.
 932 The search is limited to file names matching shell pattern FILES.
 933 FILES may use abbreviations defined in `grep-files-aliases', e.g.
 934 entering `ch' is equivalent to `*.[ch]'.
 935
 936 With \\[universal-argument] prefix, you can edit the constructed shell command line
 937 before it is executed.
 938 With two \\[universal-argument] prefixes, directly edit and run `grep-find-command'.
 939
 940 Collect output in a buffer.  While find runs asynchronously, you
 941 can use \\[next-error] (M-x next-error), or \\<grep-mode-map>\\[compile-goto-error] \
 942 in the grep output buffer,
 943 to go to the lines where grep found matches.
 944
 945 This command shares argument histories with \\[lgrep] and \\[grep-find]."
 946   (interactive
 947    (progn
 948      (grep-compute-defaults)
 949      (cond
 950       ((and grep-find-command (equal current-prefix-arg '(16)))
 951        (list (read-from-minibuffer "Run: " grep-find-command
 952                                    nil nil 'grep-find-history)))
 953       ((not grep-find-template)
 954        (error "grep.el: No `grep-find-template' available"))
 955       (t (let* ((regexp (grep-read-regexp))
 956                 (files (grep-read-files regexp))
 957                 (dir (read-directory-name "Base directory: "
 958                                           nil default-directory t))
 959                 (confirm (equal current-prefix-arg '(4))))
 960            (list regexp files dir confirm))))))
 961   (when (and (stringp regexp) (> (length regexp) 0))
 962     (unless (and dir (file-directory-p dir) (file-readable-p dir))
 963       (setq dir default-directory))
 964     (if (null files)
 965         (if (not (string= regexp grep-find-command))
 966             (compilation-start regexp 'grep-mode))
 967       (setq dir (file-name-as-directory (expand-file-name dir)))
 968       (require 'find-dired)             ; for `find-name-arg'
 969       (let ((command (grep-expand-template
 970                       grep-find-template
 971                       regexp
 972                       (concat (shell-quote-argument "(")
 973                               " " find-name-arg " "
 974                               (mapconcat #'shell-quote-argument
 975                                          (split-string files)
 976                                          (concat " -o " find-name-arg " "))
 977                               " "
 978                               (shell-quote-argument ")"))
 979                       dir
 980                       (concat
 981                        (and grep-find-ignored-directories
 982                             (concat (shell-quote-argument "(")
 983                                     ;; we should use shell-quote-argument here
 984                                     " -path "
 985                                     (mapconcat
 986                                      #'(lambda (ignore)
 987                                          (cond ((stringp ignore)
 988                                                 (shell-quote-argument
 989                                                  (concat "*/" ignore)))
 990                                                ((consp ignore)
 991                                                 (and (funcall (car ignore) dir)
 992                                                      (shell-quote-argument
 993                                                       (concat "*/"
 994                                                               (cdr ignore)))))))
 995                                      grep-find-ignored-directories
 996                                      " -o -path ")
 997                                     " "
 998                                     (shell-quote-argument ")")
 999                                     " -prune -o "))
1000                        (and grep-find-ignored-files
1001                             (concat (shell-quote-argument "(")
1002                                     ;; we should use shell-quote-argument here
1003                                     " -name "
1004                                     (mapconcat
1005                                      #'(lambda (ignore)
1006                                          (cond ((stringp ignore)
1007                                                 (shell-quote-argument ignore))
1008                                                ((consp ignore)
1009                                                 (and (funcall (car ignore) dir)
1010                                                      (shell-quote-argument
1011                                                       (cdr ignore))))))
1012                                      grep-find-ignored-files
1013                                      " -o -name ")
1014                                     " "
1015                                     (shell-quote-argument ")")
1016                                     " -prune -o "))))))
1017         (when command
1018           (if confirm
1019               (setq command
1020                     (read-from-minibuffer "Confirm: "
1021                                           command nil nil 'grep-find-history))
1022             (add-to-history 'grep-find-history command))
1023           (let ((default-directory dir))
1024             (compilation-start command 'grep-mode))
1025           ;; Set default-directory if we started rgrep in the *grep* buffer.
1026           (if (eq next-error-last-buffer (current-buffer))
1027               (setq default-directory dir)))))))
1028
1029 ;;;###autoload
1030 (defun zrgrep (regexp &optional files dir confirm grep-find-template)
1031   "Recursively grep for REGEXP in gzipped FILES in tree rooted at DIR.
1032 Like `rgrep' but uses `zgrep' for `grep-program', sets the default
1033 file name to `*.gz', and sets `grep-highlight-matches' to `always'."
1034   (interactive
1035    (progn
1036      ;; Compute standard default values.
1037      (grep-compute-defaults)
1038      ;; Compute the default zrgrep command by running `grep-compute-defaults'
1039      ;; for grep program "zgrep", but not changing global values.
1040      (let ((grep-program "zgrep")
1041            ;; Don't change global values for variables computed
1042            ;; by `grep-compute-defaults'.
1043            (grep-find-template nil)
1044            (grep-find-command nil)
1045            (grep-host-defaults-alist nil)
1046            ;; Use for `grep-read-files'
1047            (grep-files-aliases '(("all" . "* .*")
1048                                  ("gz"  . "*.gz"))))
1049        ;; Recompute defaults using let-bound values above.
1050        (grep-compute-defaults)
1051        (cond
1052         ((and grep-find-command (equal current-prefix-arg '(16)))
1053          (list (read-from-minibuffer "Run: " grep-find-command
1054                                      nil nil 'grep-find-history)))
1055         ((not grep-find-template)
1056          (error "grep.el: No `grep-find-template' available"))
1057         (t (let* ((regexp (grep-read-regexp))
1058                   (files (grep-read-files regexp))
1059                   (dir (read-directory-name "Base directory: "
1060                                             nil default-directory t))
1061                   (confirm (equal current-prefix-arg '(4))))
1062              (list regexp files dir confirm grep-find-template)))))))
1063   ;; Set `grep-highlight-matches' to `always'
1064   ;; since `zgrep' puts filters in the grep output.
1065   (let ((grep-highlight-matches 'always))
1066     ;; `rgrep' uses the dynamically bound value `grep-find-template'
1067     ;; from the argument `grep-find-template' whose value is computed
1068     ;; in the `interactive' spec.
1069     (rgrep regexp files dir confirm)))
1070
1071 ;;;###autoload
1072 (defalias 'rzgrep 'zrgrep)
1073
1074 (provide 'grep)
1075
1076 ;;; grep.el ends here