|
17517
|
1 ;;; locate.el --- interface to the locate command
|
|
16781
|
2
|
|
39184
|
3 ;; Copyright (C) 1996, 1998, 2001 Free Software Foundation, Inc.
|
|
16781
|
4
|
|
21184
|
5 ;; Author: Peter Breton <pbreton@cs.umb.edu>
|
|
29156
|
6 ;; Keywords: unix files
|
|
16781
|
7
|
|
|
8 ;; This file is part of GNU Emacs.
|
|
|
9
|
|
|
10 ;; GNU Emacs is free software; you can redistribute it and/or modify
|
|
|
11 ;; it under the terms of the GNU General Public License as published by
|
|
|
12 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
13 ;; any later version.
|
|
|
14
|
|
|
15 ;; GNU Emacs is distributed in the hope that it will be useful,
|
|
|
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
18 ;; GNU General Public License for more details.
|
|
|
19
|
|
|
20 ;; You should have received a copy of the GNU General Public License
|
|
|
21 ;; along with GNU Emacs; see the file COPYING. If not, write to the
|
|
|
22 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
23 ;; Boston, MA 02111-1307, USA.
|
|
|
24
|
|
|
25 ;;; Commentary:
|
|
|
26
|
|
|
27 ;; Search a database of files and use dired commands on
|
|
26043
|
28 ;; the result.
|
|
16781
|
29 ;;
|
|
|
30
|
|
|
31 ;;;;; Building a database of files ;;;;;;;;;
|
|
26043
|
32 ;;
|
|
16781
|
33 ;; You can create a simple files database with a port of the Unix find command
|
|
|
34 ;; and one of the various Windows NT various scheduling utilities,
|
|
|
35 ;; for example the AT command from the NT Resource Kit, WinCron which is
|
|
|
36 ;; included with Microsoft FrontPage, or the shareware NTCron program.
|
|
|
37 ;;
|
|
|
38 ;; To set up a function which searches the files database, do something
|
|
|
39 ;; like this:
|
|
26043
|
40 ;;
|
|
21056
|
41 ;; (defvar locate-fcodes-file "c:/users/peter/fcodes")
|
|
16781
|
42 ;; (defvar locate-make-command-line 'nt-locate-make-command-line)
|
|
26043
|
43 ;;
|
|
16781
|
44 ;; (defun nt-locate-make-command-line (arg)
|
|
21056
|
45 ;; (list "grep" "-i" arg locate-fcodes-file))
|
|
16781
|
46 ;;
|
|
|
47 ;;;;;;;; ADVICE For dired-make-relative: ;;;;;;;;;
|
|
26043
|
48 ;;
|
|
16781
|
49 ;; For certain dired commands to work right, you should also include the
|
|
|
50 ;; following in your _emacs/.emacs:
|
|
26043
|
51 ;;
|
|
16781
|
52 ;; (defadvice dired-make-relative (before set-no-error activate)
|
|
|
53 ;; "For locate mode and Windows, don't return errors"
|
|
|
54 ;; (if (and (eq major-mode 'locate-mode)
|
|
|
55 ;; (memq system-type (list 'windows-nt 'ms-dos)))
|
|
|
56 ;; (ad-set-arg 2 t)
|
|
|
57 ;; ))
|
|
|
58 ;;
|
|
21056
|
59 ;; Otherwise, `dired-make-relative' will give error messages like
|
|
16781
|
60 ;; "FILENAME: not in directory tree growing at /"
|
|
|
61
|
|
|
62 ;;; Commentary:
|
|
|
63 ;;
|
|
|
64 ;; Locate.el provides an interface to a program which searches a
|
|
|
65 ;; database of file names. By default, this program is the GNU locate
|
|
|
66 ;; command, but it could also be the BSD-style find command, or even a
|
|
|
67 ;; user specified command.
|
|
|
68 ;;
|
|
|
69 ;; To use the BSD-style "fast find", or any other shell command of the
|
|
26043
|
70 ;; form
|
|
16781
|
71 ;;
|
|
|
72 ;; SHELLPROGRAM Name-to-find
|
|
|
73 ;;
|
|
21056
|
74 ;; set the variable `locate-command' in your .emacs file.
|
|
16781
|
75 ;;
|
|
26043
|
76 ;; To use a more complicated expression, create a function which
|
|
21056
|
77 ;; takes a string (the name to find) as input and returns a list.
|
|
|
78 ;; The first element should be the command to be executed, the remaining
|
|
|
79 ;; elements should be the arguments (including the name to find). Then put
|
|
16781
|
80 ;;
|
|
26043
|
81 ;; (setq locate-make-command-line 'my-locate-command-line)
|
|
16781
|
82 ;;
|
|
|
83 ;; in your .emacs, using the name of your function in place of
|
|
21056
|
84 ;; my-locate-command-line.
|
|
16781
|
85 ;;
|
|
|
86 ;; You should make sure that whichever command you use works correctly
|
|
|
87 ;; from a shell prompt. GNU locate and BSD find expect the file databases
|
|
|
88 ;; to either be in standard places or located via environment variables.
|
|
|
89 ;; If the latter, make sure these environment variables are set in
|
|
21056
|
90 ;; your emacs process.
|
|
16781
|
91 ;;
|
|
|
92 ;; Locate-mode assumes that each line output from the locate-command
|
|
|
93 ;; consists exactly of a file name, possibly preceded or trailed by
|
|
|
94 ;; whitespace. If your file database has other information on the line (for
|
|
26043
|
95 ;; example, the file size), you will need to redefine the function
|
|
21056
|
96 ;; `locate-get-file-positions' to return a list consisting of the first
|
|
16781
|
97 ;; character in the file name and the last character in the file name.
|
|
|
98 ;;
|
|
|
99 ;; To use locate-mode, simply type M-x locate and then the string
|
|
|
100 ;; you wish to find. You can use almost all of the dired commands in
|
|
|
101 ;; the resulting *Locate* buffer. It is worth noting that your commands
|
|
|
102 ;; do not, of course, affect the file database. For example, if you
|
|
|
103 ;; compress a file in the locate buffer, the actual file will be
|
|
|
104 ;; compressed, but the entry in the file database will not be
|
|
|
105 ;; affected. Consequently, the database and the filesystem will be out
|
|
21056
|
106 ;; of sync until the next time the database is updated.
|
|
16781
|
107 ;;
|
|
21056
|
108 ;; The command `locate-with-filter' keeps only lines matching a
|
|
16781
|
109 ;; regular expression; this is often useful to constrain a big search.
|
|
|
110 ;;
|
|
|
111
|
|
|
112 ;;; Code:
|
|
|
113
|
|
|
114 (eval-when-compile
|
|
|
115 (require 'dired))
|
|
|
116
|
|
|
117 ;; Variables
|
|
20845
|
118
|
|
21056
|
119 (defvar locate-current-filter nil)
|
|
|
120
|
|
20845
|
121 (defgroup locate nil
|
|
|
122 "Interface to the locate command."
|
|
|
123 :prefix "locate-"
|
|
|
124 :group 'external)
|
|
|
125
|
|
|
126 (defcustom locate-command "locate"
|
|
|
127 "*The executable program used to search a database of files."
|
|
|
128 :type 'string
|
|
|
129 :group 'locate)
|
|
16781
|
130
|
|
|
131 (defvar locate-history-list nil
|
|
|
132 "The history list used by the \\[locate] command.")
|
|
|
133
|
|
26043
|
134 (defvar locate-grep-history-list nil
|
|
|
135 "The history list used by the \\[locate-with-filter] command.")
|
|
|
136
|
|
20845
|
137 (defcustom locate-make-command-line 'locate-default-make-command-line
|
|
|
138 "*Function used to create the locate command line."
|
|
|
139 :type 'function
|
|
|
140 :group 'locate)
|
|
16781
|
141
|
|
20845
|
142 (defcustom locate-buffer-name "*Locate*"
|
|
|
143 "*Name of the buffer to show results from the \\[locate] command."
|
|
|
144 :type 'string
|
|
|
145 :group 'locate)
|
|
16781
|
146
|
|
20845
|
147 (defcustom locate-fcodes-file nil
|
|
21056
|
148 "*File name for the database of file names."
|
|
|
149 :type '(choice file (const nil))
|
|
20845
|
150 :group 'locate)
|
|
16781
|
151
|
|
26043
|
152 (defcustom locate-header-face nil
|
|
20845
|
153 "*Face used to highlight the locate header."
|
|
|
154 :type 'face
|
|
|
155 :group 'locate)
|
|
16781
|
156
|
|
21056
|
157 (defcustom locate-update-command "updatedb"
|
|
|
158 "The command used to update the locate database."
|
|
|
159 :type 'string
|
|
|
160 :group 'locate)
|
|
16781
|
161
|
|
26043
|
162 (defcustom locate-prompt-for-command nil
|
|
|
163 "If non-nil, the default behavior of the locate command is to prompt for a command to run.
|
|
|
164 Otherwise, that behavior is invoked via a prefix argument."
|
|
|
165 :group 'locate
|
|
|
166 :type 'boolean
|
|
|
167 )
|
|
|
168
|
|
16781
|
169 ;; Functions
|
|
|
170
|
|
|
171 (defun locate-default-make-command-line (search-string)
|
|
21056
|
172 (list locate-command search-string))
|
|
16781
|
173
|
|
28413
|
174 (defun locate-word-at-point ()
|
|
|
175 (let ((pt (point)))
|
|
|
176 (buffer-substring-no-properties
|
|
|
177 (save-excursion
|
|
|
178 (skip-chars-backward "-a-zA-Z0-9.")
|
|
|
179 (point))
|
|
|
180 (save-excursion
|
|
|
181 (skip-chars-forward "-a-zA-Z0-9.")
|
|
|
182 (skip-chars-backward "." pt)
|
|
|
183 (point)))))
|
|
|
184
|
|
22346
|
185 ;;;###autoload
|
|
31237
|
186 (defun locate (search-string &optional filter)
|
|
26043
|
187 "Run the program `locate', putting results in `*Locate*' buffer.
|
|
|
188 With prefix arg, prompt for the locate command to run."
|
|
16781
|
189 (interactive
|
|
26043
|
190 (list
|
|
31237
|
191 (if (or (and current-prefix-arg
|
|
|
192 (not locate-prompt-for-command))
|
|
26043
|
193 (and (not current-prefix-arg) locate-prompt-for-command))
|
|
31237
|
194 (let ((locate-cmd (funcall locate-make-command-line "")))
|
|
|
195 (read-from-minibuffer
|
|
|
196 "Run locate (like this): "
|
|
|
197 (cons
|
|
|
198 (concat (car locate-cmd) " "
|
|
|
199 (mapconcat 'identity (cdr locate-cmd) " "))
|
|
|
200 (+ 2 (length (car locate-cmd))))
|
|
|
201 nil nil 'locate-history-list))
|
|
|
202 (read-from-minibuffer
|
|
|
203 "Locate: "
|
|
|
204 (locate-word-at-point)
|
|
|
205 nil nil 'locate-history-list)
|
|
26043
|
206 )))
|
|
21056
|
207 (let* ((locate-cmd-list (funcall locate-make-command-line search-string))
|
|
16781
|
208 (locate-cmd (car locate-cmd-list))
|
|
|
209 (locate-cmd-args (cdr locate-cmd-list))
|
|
26043
|
210 (run-locate-command
|
|
31237
|
211 (or (and current-prefix-arg (not locate-prompt-for-command))
|
|
|
212 (and (not current-prefix-arg) locate-prompt-for-command)))
|
|
21056
|
213 )
|
|
26043
|
214
|
|
16781
|
215 ;; Find the Locate buffer
|
|
21056
|
216 (save-window-excursion
|
|
|
217 (set-buffer (get-buffer-create locate-buffer-name))
|
|
|
218 (locate-mode)
|
|
|
219 (erase-buffer)
|
|
26043
|
220
|
|
21056
|
221 (setq locate-current-filter filter)
|
|
26043
|
222
|
|
|
223 (if run-locate-command
|
|
|
224 (shell-command search-string locate-buffer-name)
|
|
|
225 (apply 'call-process locate-cmd nil t nil locate-cmd-args))
|
|
|
226
|
|
21056
|
227 (and filter
|
|
|
228 (locate-filter-output filter))
|
|
16781
|
229
|
|
31237
|
230 (locate-do-setup search-string)
|
|
21056
|
231 )
|
|
|
232 (and (not (string-equal (buffer-name) locate-buffer-name))
|
|
|
233 (switch-to-buffer-other-window locate-buffer-name))
|
|
26043
|
234
|
|
28413
|
235 (run-hooks 'dired-mode-hook)
|
|
26043
|
236 (run-hooks 'locate-post-command-hook)
|
|
21056
|
237 )
|
|
|
238 )
|
|
16781
|
239
|
|
22347
|
240 ;;;###autoload
|
|
16781
|
241 (defun locate-with-filter (search-string filter)
|
|
26578
|
242 "Run the locate command with a filter.
|
|
|
243
|
|
|
244 The filter is a regular expression. Only results matching the filter are
|
|
|
245 shown; this is often useful to constrain a big search."
|
|
16781
|
246 (interactive
|
|
21056
|
247 (list (read-from-minibuffer "Locate: " nil nil
|
|
|
248 nil 'locate-history-list)
|
|
|
249 (read-from-minibuffer "Filter: " nil nil
|
|
26043
|
250 nil 'locate-grep-history-list)))
|
|
31237
|
251 (locate search-string filter))
|
|
16781
|
252
|
|
|
253 (defun locate-filter-output (filter)
|
|
|
254 "Filter output from the locate command."
|
|
|
255 (goto-char (point-min))
|
|
26043
|
256 (delete-non-matching-lines filter))
|
|
16781
|
257
|
|
|
258 (defvar locate-mode-map nil
|
|
|
259 "Local keymap for Locate mode buffers.")
|
|
|
260 (if locate-mode-map
|
|
|
261 nil
|
|
|
262
|
|
|
263 (require 'dired)
|
|
|
264
|
|
|
265 (setq locate-mode-map (copy-keymap dired-mode-map))
|
|
|
266
|
|
|
267 ;; Undefine Useless Dired Menu bars
|
|
|
268 (define-key locate-mode-map [menu-bar Dired] 'undefined)
|
|
|
269 (define-key locate-mode-map [menu-bar subdir] 'undefined)
|
|
|
270
|
|
|
271 (define-key locate-mode-map [menu-bar mark executables] 'undefined)
|
|
|
272 (define-key locate-mode-map [menu-bar mark directory] 'undefined)
|
|
|
273 (define-key locate-mode-map [menu-bar mark directories] 'undefined)
|
|
|
274 (define-key locate-mode-map [menu-bar mark symlinks] 'undefined)
|
|
|
275
|
|
26043
|
276 (define-key locate-mode-map [mouse-2] 'locate-mouse-view-file)
|
|
|
277 (define-key locate-mode-map "\C-c\C-t" 'locate-tags)
|
|
16781
|
278
|
|
26043
|
279 (define-key locate-mode-map "U" 'dired-unmark-all-files)
|
|
|
280 (define-key locate-mode-map "V" 'locate-find-directory)
|
|
16781
|
281 )
|
|
|
282
|
|
|
283 ;; This variable is used to indent the lines and then to search for
|
|
|
284 ;; the file name
|
|
|
285 (defconst locate-filename-indentation 4
|
|
21056
|
286 "The amount of indentation for each file.")
|
|
16781
|
287
|
|
|
288 (defun locate-get-file-positions ()
|
|
|
289 (save-excursion
|
|
21056
|
290 (end-of-line)
|
|
|
291 (let ((eol (point)))
|
|
|
292 (beginning-of-line)
|
|
26043
|
293
|
|
21056
|
294 ;; Assumes names end at the end of the line
|
|
|
295 (forward-char locate-filename-indentation)
|
|
|
296 (list (point) eol))))
|
|
16781
|
297
|
|
|
298 ;; From SQL-mode
|
|
21056
|
299 (defun locate-current-line-number ()
|
|
16781
|
300 "Return the current line number, as an integer."
|
|
|
301 (+ (count-lines (point-min) (point))
|
|
|
302 (if (eq (current-column) 0)
|
|
|
303 1
|
|
|
304 0)))
|
|
|
305
|
|
|
306 (defun locate-get-filename ()
|
|
|
307 (let ((pos (locate-get-file-positions))
|
|
21056
|
308 (lineno (locate-current-line-number)))
|
|
26043
|
309 (and (not (eq lineno 1))
|
|
|
310 (not (eq lineno 2))
|
|
16781
|
311 (buffer-substring (elt pos 0) (elt pos 1)))))
|
|
|
312
|
|
26043
|
313 (defun locate-mouse-view-file (event)
|
|
16781
|
314 "In Locate mode, view a file, using the mouse."
|
|
26043
|
315 (interactive "@e")
|
|
16781
|
316 (save-excursion
|
|
|
317 (goto-char (posn-point (event-start event)))
|
|
21056
|
318 (view-file (locate-get-filename))))
|
|
16781
|
319
|
|
|
320 ;; Define a mode for locate
|
|
|
321 ;; Default directory is set to "/" so that dired commands, which
|
|
|
322 ;; expect to be in a tree, will work properly
|
|
|
323 (defun locate-mode ()
|
|
|
324 "Major mode for the `*Locate*' buffer made by \\[locate]."
|
|
|
325 (kill-all-local-variables)
|
|
26043
|
326 ;; Avoid clobbering this variables
|
|
|
327 (make-local-variable 'dired-subdir-alist)
|
|
16781
|
328 (use-local-map locate-mode-map)
|
|
|
329 (setq major-mode 'locate-mode
|
|
|
330 mode-name "Locate"
|
|
26043
|
331 default-directory "/")
|
|
|
332 (dired-alist-add-1 default-directory (point-min-marker))
|
|
16795
|
333 (make-local-variable 'dired-move-to-filename-regexp)
|
|
26043
|
334 ;; This should support both Unix and Windoze style names
|
|
16795
|
335 (setq dired-move-to-filename-regexp
|
|
26043
|
336 (concat "."
|
|
|
337 (make-string (1- locate-filename-indentation) ?\ )
|
|
|
338 "\\(/\\|[A-Za-z]:\\)"))
|
|
16795
|
339 (make-local-variable 'dired-actual-switches)
|
|
|
340 (setq dired-actual-switches "")
|
|
|
341 (make-local-variable 'dired-permission-flags-regexp)
|
|
26043
|
342 (setq dired-permission-flags-regexp
|
|
|
343 (concat "^.\\("
|
|
|
344 (make-string (1- locate-filename-indentation) ?\ )
|
|
|
345 "\\)"))
|
|
21056
|
346 (make-local-variable 'revert-buffer-function)
|
|
26043
|
347 (setq revert-buffer-function 'locate-update)
|
|
16781
|
348 (run-hooks 'locate-mode-hook))
|
|
|
349
|
|
31237
|
350 (defun locate-do-setup (search-string)
|
|
|
351 (goto-char (point-min))
|
|
|
352 (save-excursion
|
|
26043
|
353
|
|
31237
|
354 ;; Nothing returned from locate command?
|
|
|
355 (and (eobp)
|
|
|
356 (progn
|
|
|
357 (kill-buffer locate-buffer-name)
|
|
|
358 (if locate-current-filter
|
|
|
359 (error "Locate: no match for %s in database using filter %s"
|
|
|
360 search-string locate-current-filter)
|
|
|
361 (error "Locate: no match for %s in database" search-string))))
|
|
26043
|
362
|
|
31237
|
363 (locate-insert-header search-string)
|
|
26043
|
364
|
|
31237
|
365 (while (not (eobp))
|
|
|
366 (insert-char ?\ locate-filename-indentation t)
|
|
|
367 (locate-set-properties)
|
|
|
368 (forward-line 1)))
|
|
|
369 (goto-char (point-min)))
|
|
16781
|
370
|
|
|
371 (defun locate-set-properties ()
|
|
|
372 (save-excursion
|
|
|
373 (let ((pos (locate-get-file-positions)))
|
|
26043
|
374 (dired-insert-set-properties (elt pos 0) (elt pos 1)))))
|
|
16781
|
375
|
|
|
376 (defun locate-insert-header (search-string)
|
|
|
377 (let ((locate-format-string "Matches for %s")
|
|
|
378 (locate-regexp-match
|
|
|
379 (concat " *Matches for \\(" (regexp-quote search-string) "\\)"))
|
|
|
380 (locate-format-args (list search-string))
|
|
|
381 )
|
|
26043
|
382
|
|
21056
|
383 (and locate-fcodes-file
|
|
16781
|
384 (setq locate-format-string
|
|
|
385 (concat locate-format-string " in %s")
|
|
|
386 locate-regexp-match
|
|
|
387 (concat locate-regexp-match
|
|
|
388 " in \\("
|
|
|
389 (regexp-quote locate-fcodes-file)
|
|
|
390 "\\)")
|
|
|
391 locate-format-args
|
|
|
392 (append (list locate-fcodes-file) locate-format-args)))
|
|
|
393
|
|
21056
|
394 (and locate-current-filter
|
|
16781
|
395 (setq locate-format-string
|
|
|
396 (concat locate-format-string " using filter %s")
|
|
|
397 locate-regexp-match
|
|
|
398 (concat locate-regexp-match
|
|
|
399 " using filter "
|
|
|
400 "\\("
|
|
|
401 (regexp-quote locate-current-filter)
|
|
|
402 "\\)")
|
|
|
403 locate-format-args
|
|
|
404 (append (list locate-current-filter) locate-format-args)))
|
|
26043
|
405
|
|
16781
|
406 (setq locate-format-string
|
|
39184
|
407 (concat locate-format-string ":\n\n")
|
|
16781
|
408 locate-regexp-match
|
|
39184
|
409 (concat locate-regexp-match ":\n"))
|
|
26043
|
410
|
|
16795
|
411 (insert (apply 'format locate-format-string (reverse locate-format-args)))
|
|
26043
|
412
|
|
16781
|
413 (save-excursion
|
|
|
414 (goto-char (point-min))
|
|
|
415 (if (not (looking-at locate-regexp-match))
|
|
|
416 nil
|
|
|
417 (add-text-properties (match-beginning 1) (match-end 1)
|
|
|
418 (list 'face locate-header-face))
|
|
|
419 (and (match-beginning 2)
|
|
|
420 (add-text-properties (match-beginning 2) (match-end 2)
|
|
|
421 (list 'face locate-header-face)))
|
|
|
422 (and (match-beginning 3)
|
|
|
423 (add-text-properties (match-beginning 3) (match-end 3)
|
|
|
424 (list 'face locate-header-face)))
|
|
|
425 ))))
|
|
|
426
|
|
|
427 (defun locate-tags ()
|
|
|
428 "Visit a tags table in `*Locate*' mode."
|
|
|
429 (interactive)
|
|
|
430 (let ((tags-table (locate-get-filename)))
|
|
26043
|
431 (and (y-or-n-p (format "Visit tags table %s? " tags-table))
|
|
21056
|
432 (visit-tags-table tags-table))))
|
|
|
433
|
|
|
434 ;; From Stephen Eglen <stephen@cns.ed.ac.uk>
|
|
|
435 (defun locate-update (ignore1 ignore2)
|
|
|
436 "Update the locate database.
|
|
|
437 Database is updated using the shell command in `locate-update-command'."
|
|
|
438 (let ((str (car locate-history-list)))
|
|
|
439 (cond ((yes-or-no-p "Update locate database (may take a few seconds)? ")
|
|
|
440 (shell-command locate-update-command)
|
|
31237
|
441 (locate str)))))
|
|
26043
|
442
|
|
|
443 ;;; Modified three functions from `dired.el':
|
|
|
444 ;;; dired-find-directory,
|
|
|
445 ;;; dired-find-directory-other-window
|
|
|
446 ;;; dired-get-filename
|
|
|
447
|
|
|
448 (defun locate-find-directory ()
|
|
|
449 "Visit the directory of the file mentioned on this line."
|
|
|
450 (interactive)
|
|
|
451 (let ((directory-name (locate-get-dirname)))
|
|
|
452 (if (file-directory-p directory-name)
|
|
|
453 (find-file directory-name)
|
|
|
454 (if (file-symlink-p directory-name)
|
|
|
455 (error "Directory is a symlink to a nonexistent target")
|
|
|
456 (error "Directory no longer exists; run `updatedb' to update database")))))
|
|
|
457
|
|
|
458 (defun locate-find-directory-other-window ()
|
|
|
459 "Visit the directory of the file named on this line in other window."
|
|
|
460 (interactive)
|
|
|
461 (find-file-other-window (locate-get-dirname)))
|
|
|
462
|
|
|
463 (defun locate-get-dirname ()
|
|
|
464 "Return the directory name of the file mentioned on this line."
|
|
|
465 (let (file (filepos (locate-get-file-positions)))
|
|
|
466 (if (setq file (buffer-substring (nth 0 filepos) (nth 1 filepos)))
|
|
|
467 (progn
|
|
|
468 ;; Get rid of the mouse-face property that file names have.
|
|
|
469 (set-text-properties 0 (length file) nil file)
|
|
|
470 (setq file (file-name-directory file))
|
|
|
471 ;; Unquote names quoted by ls or by dired-insert-directory.
|
|
|
472 ;; Using read to unquote is much faster than substituting
|
|
|
473 ;; \007 (4 chars) -> ^G (1 char) etc. in a lisp loop.
|
|
|
474 (setq file
|
|
|
475 (read
|
|
|
476 (concat "\""
|
|
|
477 ;; some ls -b don't escape quotes, argh!
|
|
|
478 ;; This is not needed for GNU ls, though.
|
|
|
479 (or (dired-string-replace-match
|
|
|
480 "\\([^\\]\\|\\`\\)\"" file "\\1\\\\\"" nil t)
|
|
|
481 file)
|
|
|
482 "\"")))))
|
|
|
483 (and file buffer-file-coding-system
|
|
|
484 (not file-name-coding-system)
|
|
|
485 (setq file (encode-coding-string file buffer-file-coding-system)))
|
|
|
486 file))
|
|
|
487
|
|
|
488 ;; Only for GNU locate
|
|
|
489 (defun locate-in-alternate-database (search-string database)
|
|
|
490 "Run the GNU locate command, using an alternate database."
|
|
|
491 (interactive
|
|
|
492 (list
|
|
|
493 (progn
|
|
|
494 ;; (require 'locate)
|
|
|
495 (read-from-minibuffer "Locate: " nil nil
|
|
|
496 nil 'locate-history-list))
|
|
|
497 (read-file-name "Locate using Database: " )
|
|
|
498 ))
|
|
|
499 (or (file-exists-p database)
|
|
|
500 (error "Database file %s does not exist" database))
|
|
|
501 (let ((locate-make-command-line
|
|
|
502 (function (lambda (string)
|
|
|
503 (cons locate-command
|
|
|
504 (list (concat "--database="
|
|
|
505 (expand-file-name database))
|
|
|
506 string))))))
|
|
31237
|
507 (locate search-string)))
|
|
16781
|
508
|
|
|
509 (provide 'locate)
|
|
|
510
|
|
|
511 ;;; locate.el ends here
|
