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