54183
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1 ;;; ffap.el --- find file (or url) at point
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
2
|
|
104886
|
3 ;; Copyright (C) 1995, 1996, 1997, 2000, 2001, 2002, 2003, 2004, 2005,
|
|
|
4 ;; 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
|
54183
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
5
|
|
14169
|
6 ;; Author: Michelangelo Grigni <mic@mathcs.emory.edu>
|
|
73776
|
7 ;; Maintainer: FSF
|
|
14874
|
8 ;; Created: 29 Mar 1993
|
|
22250
|
9 ;; Keywords: files, hypermedia, matching, mouse, convenience
|
|
18486
|
10 ;; X-URL: ftp://ftp.mathcs.emory.edu/pub/mic/emacs/
|
|
13531
|
11
|
|
|
12 ;; This file is part of GNU Emacs.
|
|
|
13
|
|
94678
|
14 ;; GNU Emacs is free software: you can redistribute it and/or modify
|
|
13531
|
15 ;; it under the terms of the GNU General Public License as published by
|
|
94678
|
16 ;; the Free Software Foundation, either version 3 of the License, or
|
|
|
17 ;; (at your option) any later version.
|
|
13531
|
18
|
|
|
19 ;; GNU Emacs is distributed in the hope that it will be useful,
|
|
|
20 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
21 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
22 ;; GNU General Public License for more details.
|
|
|
23
|
|
|
24 ;; You should have received a copy of the GNU General Public License
|
|
94678
|
25 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
|
|
13531
|
26
|
|
14874
|
27
|
|
13531
|
28 ;;; Commentary:
|
|
|
29 ;;
|
|
14874
|
30 ;; Command find-file-at-point replaces find-file. With a prefix, it
|
|
|
31 ;; behaves exactly like find-file. Without a prefix, it first tries
|
|
17635
|
32 ;; to guess a default file or URL from the text around the point
|
|
14874
|
33 ;; (`ffap-require-prefix' swaps these behaviors). This is useful for
|
|
|
34 ;; following references in situations such as mail or news buffers,
|
|
|
35 ;; README's, MANIFEST's, and so on. Submit bugs or suggestions with
|
|
|
36 ;; M-x ffap-bug.
|
|
13531
|
37 ;;
|
|
34867
|
38 ;; For the default installation, add this line to your .emacs file:
|
|
13531
|
39 ;;
|
|
14874
|
40 ;; (ffap-bindings) ; do default key bindings
|
|
13531
|
41 ;;
|
|
14874
|
42 ;; ffap-bindings makes the following global key bindings:
|
|
13531
|
43 ;;
|
|
58923
|
44 ;; C-x C-f find-file-at-point (abbreviated as ffap)
|
|
|
45 ;; C-x C-r ffap-read-only
|
|
|
46 ;; C-x C-v ffap-alternate-file
|
|
|
47 ;;
|
|
|
48 ;; C-x d dired-at-point
|
|
|
49 ;; C-x C-d ffap-list-directory
|
|
|
50 ;;
|
|
|
51 ;; C-x 4 f ffap-other-window
|
|
|
52 ;; C-x 4 r ffap-read-only-other-window
|
|
|
53 ;; C-x 4 d ffap-dired-other-window
|
|
|
54 ;;
|
|
|
55 ;; C-x 5 f ffap-other-frame
|
|
|
56 ;; C-x 5 r ffap-read-only-other-frame
|
|
|
57 ;; C-x 5 d ffap-dired-other-frame
|
|
|
58 ;;
|
|
14874
|
59 ;; S-mouse-3 ffap-at-mouse
|
|
18291
|
60 ;; C-S-mouse-3 ffap-menu
|
|
13531
|
61 ;;
|
|
14874
|
62 ;; ffap-bindings also adds hooks to make the following local bindings
|
|
|
63 ;; in vm, gnus, and rmail:
|
|
13531
|
64 ;;
|
|
18291
|
65 ;; M-l ffap-next, or ffap-gnus-next in gnus (l == "link")
|
|
|
66 ;; M-m ffap-menu, or ffap-gnus-menu in gnus (m == "menu")
|
|
13531
|
67 ;;
|
|
14874
|
68 ;; If you do not like these bindings, modify the variable
|
|
|
69 ;; `ffap-bindings', or write your own.
|
|
13531
|
70 ;;
|
|
14874
|
71 ;; If you use ange-ftp, browse-url, complete, efs, or w3, it is best
|
|
|
72 ;; to load or autoload them before ffap. If you use ff-paths, load it
|
|
|
73 ;; afterwards. Try apropos {C-h a ffap RET} to get a list of the many
|
|
|
74 ;; option variables. In particular, if ffap is slow, try these:
|
|
13531
|
75 ;;
|
|
14874
|
76 ;; (setq ffap-alist nil) ; faster, dumber prompting
|
|
|
77 ;; (setq ffap-machine-p-known 'accept) ; no pinging
|
|
17635
|
78 ;; (setq ffap-url-regexp nil) ; disable URL features in ffap
|
52672
d4d213cfb340
whitespace.el now takes user customizable variable to display cleanliness of
Rajesh Vaidheeswarran <rv@gnu.org>
diff
changeset
|
79 ;; (setq ffap-shell-prompt-regexp nil) ; disable shell prompt stripping
|
|
13531
|
80 ;;
|
|
18486
|
81 ;; ffap uses `browse-url' (if found, else `w3-fetch') to fetch URL's.
|
|
|
82 ;; For a hairier `ffap-url-fetcher', try ffap-url.el (same ftp site).
|
|
14874
|
83 ;; Also, you can add `ffap-menu-rescan' to various hooks to fontify
|
|
49588
|
84 ;; the file and URL references within a buffer.
|
|
13531
|
85
|
|
18291
|
86
|
|
|
87 ;;; Change Log:
|
|
|
88 ;;
|
|
|
89 ;; The History and Contributors moved to ffap.LOG (same ftp site),
|
|
|
90 ;; which also has some old examples and commentary from ffap 1.5.
|
|
|
91
|
|
|
92
|
|
14874
|
93 ;;; Todo list:
|
|
18291
|
94 ;; * use kpsewhich
|
|
49808
|
95 ;; * let "/dir/file#key" jump to key (tag or regexp) in /dir/file
|
|
14874
|
96 ;; * find file of symbol if TAGS is loaded (like above)
|
|
18291
|
97 ;; * break long menus into multiple panes (like imenu?)
|
|
|
98 ;; * notice node in "(dired)Virtual Dired" (quotes, parentheses, whitespace)
|
|
49808
|
99 ;; * notice "machine.dom blah blah blah dir/file" (how?)
|
|
18291
|
100 ;; * as w3 becomes standard, rewrite to rely more on its functions
|
|
14874
|
101 ;; * regexp options for ffap-string-at-point, like font-lock (MCOOK)
|
|
|
102 ;; * v19: could replace `ffap-locate-file' with a quieter `locate-library'
|
|
18291
|
103 ;; * handle "$(VAR)" in Makefiles
|
|
|
104 ;; * use the font-lock machinery
|
|
13531
|
105
|
|
|
106
|
|
|
107 ;;; Code:
|
|
|
108
|
|
103729
|
109 (define-obsolete-variable-alias 'ffap-version 'emacs-version "23.2")
|
|
18486
|
110
|
|
|
111 (defgroup ffap nil
|
|
|
112 "Find file or URL at point."
|
|
103730
|
113 ;; Dead 2009/07/05.
|
|
|
114 ;; :link '(url-link :tag "URL" "ftp://ftp.mathcs.emory.edu/pub/mic/emacs/")
|
|
22250
|
115 :group 'matching
|
|
|
116 :group 'convenience)
|
|
18486
|
117
|
|
18291
|
118 ;; The code is organized in pages, separated by formfeed characters.
|
|
|
119 ;; See the next two pages for standard customization ideas.
|
|
14874
|
120
|
|
|
121
|
|
13531
|
122 ;;; User Variables:
|
|
|
123
|
|
106503
|
124 (defun ffap-symbol-value (sym &optional default)
|
|
|
125 "Return value of symbol SYM, if bound, or DEFAULT otherwise."
|
|
|
126 (if (boundp sym) (symbol-value sym) default))
|
|
13531
|
127
|
52672
d4d213cfb340
whitespace.el now takes user customizable variable to display cleanliness of
Rajesh Vaidheeswarran <rv@gnu.org>
diff
changeset
|
128 (defcustom ffap-shell-prompt-regexp
|
d4d213cfb340
whitespace.el now takes user customizable variable to display cleanliness of
Rajesh Vaidheeswarran <rv@gnu.org>
diff
changeset
|
129 ;; This used to test for some shell prompts that don't have a space
|
d4d213cfb340
whitespace.el now takes user customizable variable to display cleanliness of
Rajesh Vaidheeswarran <rv@gnu.org>
diff
changeset
|
130 ;; after them. The common root shell prompt (#) is not listed since it
|
d4d213cfb340
whitespace.el now takes user customizable variable to display cleanliness of
Rajesh Vaidheeswarran <rv@gnu.org>
diff
changeset
|
131 ;; also doubles up as a valid URL character.
|
d4d213cfb340
whitespace.el now takes user customizable variable to display cleanliness of
Rajesh Vaidheeswarran <rv@gnu.org>
diff
changeset
|
132 "[$%><]*"
|
d4d213cfb340
whitespace.el now takes user customizable variable to display cleanliness of
Rajesh Vaidheeswarran <rv@gnu.org>
diff
changeset
|
133 "Paths matching this regexp are stripped off the shell prompt
|
d4d213cfb340
whitespace.el now takes user customizable variable to display cleanliness of
Rajesh Vaidheeswarran <rv@gnu.org>
diff
changeset
|
134 If nil, ffap doesn't do shell prompt stripping."
|
d4d213cfb340
whitespace.el now takes user customizable variable to display cleanliness of
Rajesh Vaidheeswarran <rv@gnu.org>
diff
changeset
|
135 :type '(choice (const :tag "Disable" nil)
|
d4d213cfb340
whitespace.el now takes user customizable variable to display cleanliness of
Rajesh Vaidheeswarran <rv@gnu.org>
diff
changeset
|
136 (const :tag "Standard" "[$%><]*")
|
d4d213cfb340
whitespace.el now takes user customizable variable to display cleanliness of
Rajesh Vaidheeswarran <rv@gnu.org>
diff
changeset
|
137 regexp)
|
d4d213cfb340
whitespace.el now takes user customizable variable to display cleanliness of
Rajesh Vaidheeswarran <rv@gnu.org>
diff
changeset
|
138 :group 'ffap)
|
d4d213cfb340
whitespace.el now takes user customizable variable to display cleanliness of
Rajesh Vaidheeswarran <rv@gnu.org>
diff
changeset
|
139
|
|
17635
|
140 (defcustom ffap-ftp-regexp
|
|
18291
|
141 ;; This used to test for ange-ftp or efs being present, but it should be
|
|
|
142 ;; harmless (and simpler) to give it this value unconditionally.
|
|
|
143 "\\`/[^/:]+:"
|
|
100171
|
144 "File names matching this regexp are treated as remote ffap.
|
|
49808
|
145 If nil, ffap neither recognizes nor generates such names."
|
|
17635
|
146 :type '(choice (const :tag "Disable" nil)
|
|
18291
|
147 (const :tag "Standard" "\\`/[^/:]+:")
|
|
17635
|
148 regexp)
|
|
|
149 :group 'ffap)
|
|
13531
|
150
|
|
17635
|
151 (defcustom ffap-url-unwrap-local t
|
|
100171
|
152 "If non-nil, convert `file:' URL to local file name before prompting."
|
|
17635
|
153 :type 'boolean
|
|
|
154 :group 'ffap)
|
|
13531
|
155
|
|
17635
|
156 (defcustom ffap-url-unwrap-remote t
|
|
100171
|
157 "If non-nil, convert `ftp:' URL to remote file name before prompting.
|
|
17635
|
158 This is ignored if `ffap-ftp-regexp' is nil."
|
|
|
159 :type 'boolean
|
|
|
160 :group 'ffap)
|
|
|
161
|
|
18291
|
162 (defcustom ffap-ftp-default-user "anonymous"
|
|
100171
|
163 "User name in ftp file names generated by `ffap-host-to-path'.
|
|
18291
|
164 Note this name may be omitted if it equals the default
|
|
|
165 \(either `efs-default-user' or `ange-ftp-default-user'\)."
|
|
|
166 :type 'string
|
|
17635
|
167 :group 'ffap)
|
|
13531
|
168
|
|
17635
|
169 (defcustom ffap-rfs-regexp
|
|
13531
|
170 ;; Remote file access built into file system? HP rfa or Andrew afs:
|
|
|
171 "\\`/\\(afs\\|net\\)/."
|
|
|
172 ;; afs only: (and (file-exists-p "/afs") "\\`/afs/.")
|
|
100171
|
173 "Matching file names are treated as remote. Use nil to disable."
|
|
17635
|
174 :type 'regexp
|
|
|
175 :group 'ffap)
|
|
13531
|
176
|
|
|
177 (defvar ffap-url-regexp
|
|
|
178 ;; Could just use `url-nonrelative-link' of w3, if loaded.
|
|
|
179 ;; This regexp is not exhaustive, it just matches common cases.
|
|
|
180 (concat
|
|
|
181 "\\`\\("
|
|
|
182 "news\\(post\\)?:\\|mailto:\\|file:" ; no host ok
|
|
|
183 "\\|"
|
|
29115
|
184 "\\(ftp\\|https?\\|telnet\\|gopher\\|www\\|wais\\)://" ; needs host
|
|
13531
|
185 "\\)." ; require one more character
|
|
|
186 )
|
|
17635
|
187 "Regexp matching URL's. nil to disable URL features in ffap.")
|
|
13531
|
188
|
|
17635
|
189 (defcustom ffap-foo-at-bar-prefix "mailto"
|
|
100171
|
190 "Presumed URL prefix type of strings like \"<foo.9z@bar>\".
|
|
17635
|
191 Sensible values are nil, \"news\", or \"mailto\"."
|
|
18291
|
192 :type '(choice (const "mailto")
|
|
|
193 (const "news")
|
|
|
194 (const :tag "Disable" nil)
|
|
|
195 ;; string -- possible, but not really useful
|
|
|
196 )
|
|
17635
|
197 :group 'ffap)
|
|
13531
|
198
|
|
|
199
|
|
18291
|
200 ;;; Peanut Gallery (More User Variables):
|
|
14874
|
201 ;;
|
|
13531
|
202 ;; Users of ffap occasionally suggest new features. If I consider
|
|
|
203 ;; those features interesting but not clear winners (a matter of
|
|
|
204 ;; personal taste) I try to leave options to enable them. Read
|
|
14874
|
205 ;; through this section for features that you like, put an appropriate
|
|
|
206 ;; enabler in your .emacs file.
|
|
13531
|
207
|
|
58923
|
208 (defcustom ffap-dired-wildcards "[*?][^/]*\\'"
|
|
100171
|
209 "A regexp matching filename wildcard characters, or nil.
|
|
58923
|
210
|
|
14874
|
211 If `find-file-at-point' gets a filename matching this pattern,
|
|
61365
|
212 and `ffap-pass-wildcards-to-dired' is nil, it passes it on to
|
|
|
213 `find-file' with non-nil WILDCARDS argument, which expands
|
|
|
214 wildcards and visits multiple files. To visit a file whose name
|
|
|
215 contains wildcard characters you can suppress wildcard expansion
|
|
|
216 by setting `find-file-wildcards'. If `find-file-at-point' gets a
|
|
|
217 filename matching this pattern and `ffap-pass-wildcards-to-dired'
|
|
|
218 is non-nil, it passes it on to `dired'.
|
|
58923
|
219
|
|
|
220 If `dired-at-point' gets a filename matching this pattern,
|
|
|
221 it passes it on to `dired'."
|
|
18291
|
222 :type '(choice (const :tag "Disable" nil)
|
|
|
223 (const :tag "Enable" "[*?][^/]*\\'")
|
|
|
224 ;; regexp -- probably not useful
|
|
|
225 )
|
|
17635
|
226 :group 'ffap)
|
|
13531
|
227
|
|
61365
|
228 (defcustom ffap-pass-wildcards-to-dired nil
|
|
100171
|
229 "If non-nil, pass filenames matching `ffap-dired-wildcards' to dired."
|
|
61365
|
230 :type 'boolean
|
|
|
231 :group 'ffap)
|
|
|
232
|
|
18291
|
233 (defcustom ffap-newfile-prompt nil
|
|
14874
|
234 ;; Suggestion from RHOGEE, 11 Jul 1994. Disabled, I think this is
|
|
|
235 ;; better handled by `find-file-not-found-hooks'.
|
|
100171
|
236 "Whether `find-file-at-point' prompts about a nonexistent file."
|
|
17635
|
237 :type 'boolean
|
|
|
238 :group 'ffap)
|
|
13531
|
239
|
|
17635
|
240 (defcustom ffap-require-prefix nil
|
|
14874
|
241 ;; Suggestion from RHOGEE, 20 Oct 1994.
|
|
100171
|
242 "If set, reverses the prefix argument to `find-file-at-point'.
|
|
14874
|
243 This is nil so neophytes notice ffap. Experts may prefer to disable
|
|
17635
|
244 ffap most of the time."
|
|
|
245 :type 'boolean
|
|
|
246 :group 'ffap)
|
|
13531
|
247
|
|
17635
|
248 (defcustom ffap-file-finder 'find-file
|
|
100171
|
249 "The command called by `find-file-at-point' to find a file."
|
|
17635
|
250 :type 'function
|
|
|
251 :group 'ffap)
|
|
13531
|
252 (put 'ffap-file-finder 'risky-local-variable t)
|
|
|
253
|
|
58923
|
254 (defcustom ffap-directory-finder 'dired
|
|
100171
|
255 "The command called by `dired-at-point' to find a directory."
|
|
58923
|
256 :type 'function
|
|
|
257 :group 'ffap)
|
|
|
258 (put 'ffap-directory-finder 'risky-local-variable t)
|
|
|
259
|
|
17635
|
260 (defcustom ffap-url-fetcher
|
|
18486
|
261 (if (fboundp 'browse-url)
|
|
|
262 'browse-url ; rely on browse-url-browser-function
|
|
|
263 'w3-fetch)
|
|
14874
|
264 ;; Remote control references:
|
|
13531
|
265 ;; http://www.ncsa.uiuc.edu/SDG/Software/XMosaic/remote-control.html
|
|
|
266 ;; http://home.netscape.com/newsref/std/x-remote.html
|
|
100171
|
267 "A function of one argument, called by ffap to fetch an URL.
|
|
18486
|
268 Reasonable choices are `w3-fetch' or a `browse-url-*' function.
|
|
23352
|
269 For a fancy alternative, get `ffap-url.el'."
|
|
18291
|
270 :type '(choice (const w3-fetch)
|
|
18486
|
271 (const browse-url) ; in recent versions of browse-url
|
|
18291
|
272 (const browse-url-netscape)
|
|
|
273 (const browse-url-mosaic)
|
|
|
274 function)
|
|
17635
|
275 :group 'ffap)
|
|
13531
|
276 (put 'ffap-url-fetcher 'risky-local-variable t)
|
|
|
277
|
|
|
278
|
|
18486
|
279 ;;; Compatibility:
|
|
|
280 ;;
|
|
68828
|
281 ;; This version of ffap supports only the Emacs it is distributed in.
|
|
|
282 ;; See the ftp site for a more general version. The following
|
|
|
283 ;; functions are necessary "leftovers" from the more general version.
|
|
18291
|
284
|
|
106503
|
285 (defun ffap-mouse-event () ; current mouse event, or nil
|
|
18486
|
286 (and (listp last-nonmenu-event) last-nonmenu-event))
|
|
|
287 (defun ffap-event-buffer (event)
|
|
|
288 (window-buffer (car (event-start event))))
|
|
18291
|
289
|
|
|
290
|
|
|
291 ;;; Find Next Thing in buffer (`ffap-next'):
|
|
13531
|
292 ;;
|
|
14874
|
293 ;; Original ffap-next-url (URL's only) from RPECK 30 Mar 1995. Since
|
|
|
294 ;; then, broke it up into ffap-next-guess (noninteractive) and
|
|
|
295 ;; ffap-next (a command). It now work on files as well as url's.
|
|
13531
|
296
|
|
17635
|
297 (defcustom ffap-next-regexp
|
|
13531
|
298 ;; If you want ffap-next to find URL's only, try this:
|
|
|
299 ;; (and ffap-url-regexp (string-match "\\\\`" ffap-url-regexp)
|
|
|
300 ;; (concat "\\<" (substring ffap-url-regexp 2))))
|
|
|
301 ;;
|
|
|
302 ;; It pays to put a big fancy regexp here, since ffap-guesser is
|
|
|
303 ;; much more time-consuming than regexp searching:
|
75189
c456d15d23fd
(ffap-next-regexp, ffap-machine-p, ffap-newsgroup-regexp)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
304 "[/:.~[:alpha:]]/\\|@[[:alpha:]][-[:alnum:]]*\\."
|
|
100171
|
305 "Regular expression governing movements of `ffap-next'."
|
|
17635
|
306 :type 'regexp
|
|
|
307 :group 'ffap)
|
|
13531
|
308
|
|
17676
|
309 (defvar ffap-next-guess nil
|
|
|
310 "Last value returned by `ffap-next-guess'.")
|
|
|
311
|
|
|
312 (defvar ffap-string-at-point-region '(1 1)
|
|
|
313 "List (BEG END), last region returned by `ffap-string-at-point'.")
|
|
|
314
|
|
13531
|
315 (defun ffap-next-guess (&optional back lim)
|
|
17635
|
316 "Move point to next file or URL, and return it as a string.
|
|
14874
|
317 If nothing is found, leave point at limit and return nil.
|
|
13531
|
318 Optional BACK argument makes search backwards.
|
|
|
319 Optional LIM argument limits the search.
|
|
|
320 Only considers strings that match `ffap-next-regexp'."
|
|
|
321 (or lim (setq lim (if back (point-min) (point-max))))
|
|
|
322 (let (guess)
|
|
|
323 (while (not (or guess (eq (point) lim)))
|
|
|
324 (funcall (if back 're-search-backward 're-search-forward)
|
|
|
325 ffap-next-regexp lim 'move)
|
|
|
326 (setq guess (ffap-guesser)))
|
|
|
327 ;; Go to end, so we do not get same guess twice:
|
|
|
328 (goto-char (nth (if back 0 1) ffap-string-at-point-region))
|
|
|
329 (setq ffap-next-guess guess)))
|
|
|
330
|
|
|
331 ;;;###autoload
|
|
|
332 (defun ffap-next (&optional back wrap)
|
|
17635
|
333 "Search buffer for next file or URL, and run ffap.
|
|
13531
|
334 Optional argument BACK says to search backwards.
|
|
|
335 Optional argument WRAP says to try wrapping around if necessary.
|
|
|
336 Interactively: use a single prefix to search backwards,
|
|
|
337 double prefix to wrap forward, triple to wrap backwards.
|
|
14874
|
338 Actual search is done by `ffap-next-guess'."
|
|
13531
|
339 (interactive
|
|
|
340 (cdr (assq (prefix-numeric-value current-prefix-arg)
|
|
|
341 '((1) (4 t) (16 nil t) (64 t t)))))
|
|
|
342 (let ((pt (point))
|
|
|
343 (guess (ffap-next-guess back)))
|
|
|
344 ;; Try wraparound if necessary:
|
|
|
345 (and (not guess) wrap
|
|
|
346 (goto-char (if back (point-max) (point-min)))
|
|
|
347 (setq guess (ffap-next-guess back pt)))
|
|
|
348 (if guess
|
|
|
349 (progn
|
|
|
350 (sit-for 0) ; display point movement
|
|
|
351 (find-file-at-point (ffap-prompter guess)))
|
|
|
352 (goto-char pt) ; restore point
|
|
17635
|
353 (message "No %sfiles or URL's found"
|
|
13531
|
354 (if wrap "" "more ")))))
|
|
|
355
|
|
|
356 (defun ffap-next-url (&optional back wrap)
|
|
14874
|
357 "Like `ffap-next', but search with `ffap-url-regexp'."
|
|
13531
|
358 (interactive)
|
|
|
359 (let ((ffap-next-regexp ffap-url-regexp))
|
|
105372
|
360 (if (called-interactively-p 'interactive)
|
|
13531
|
361 (call-interactively 'ffap-next)
|
|
|
362 (ffap-next back wrap))))
|
|
|
363
|
|
|
364
|
|
18291
|
365 ;;; Machines (`ffap-machine-p'):
|
|
13531
|
366
|
|
|
367 ;; I cannot decide a "best" strategy here, so these are variables. In
|
|
|
368 ;; particular, if `Pinging...' is broken or takes too long on your
|
|
|
369 ;; machine, try setting these all to accept or reject.
|
|
17635
|
370 (defcustom ffap-machine-p-local 'reject ; this happens often
|
|
100171
|
371 "What `ffap-machine-p' does with hostnames that have no domain.
|
|
23443
|
372 Value should be a symbol, one of `ping', `accept', and `reject'."
|
|
17635
|
373 :type '(choice (const ping)
|
|
|
374 (const accept)
|
|
|
375 (const reject))
|
|
|
376 :group 'ffap)
|
|
23352
|
377 (defcustom ffap-machine-p-known 'ping ; `accept' for higher speed
|
|
100171
|
378 "What `ffap-machine-p' does with hostnames that have a known domain.
|
|
23352
|
379 Value should be a symbol, one of `ping', `accept', and `reject'.
|
|
|
380 See `mail-extr.el' for the known domains."
|
|
17635
|
381 :type '(choice (const ping)
|
|
|
382 (const accept)
|
|
|
383 (const reject))
|
|
|
384 :group 'ffap)
|
|
|
385 (defcustom ffap-machine-p-unknown 'reject
|
|
100171
|
386 "What `ffap-machine-p' does with hostnames that have an unknown domain.
|
|
23352
|
387 Value should be a symbol, one of `ping', `accept', and `reject'.
|
|
|
388 See `mail-extr.el' for the known domains."
|
|
17635
|
389 :type '(choice (const ping)
|
|
|
390 (const accept)
|
|
|
391 (const reject))
|
|
|
392 :group 'ffap)
|
|
13531
|
393
|
|
14874
|
394 (defun ffap-what-domain (domain)
|
|
|
395 ;; Like what-domain in mail-extr.el, returns string or nil.
|
|
|
396 (require 'mail-extr)
|
|
106503
|
397 (let ((ob (or (ffap-symbol-value 'mail-extr-all-top-level-domains)
|
|
|
398 (ffap-symbol-value 'all-top-level-domains)))) ; XEmacs
|
|
18486
|
399 (and ob (get (intern-soft (downcase domain) ob) 'domain-name))))
|
|
13531
|
400
|
|
14874
|
401 (defun ffap-machine-p (host &optional service quiet strategy)
|
|
|
402 "Decide whether HOST is the name of a real, reachable machine.
|
|
|
403 Depending on the domain (none, known, or unknown), follow the strategy
|
|
|
404 named by the variable `ffap-machine-p-local', `ffap-machine-p-known',
|
|
|
405 or `ffap-machine-p-unknown'. Pinging uses `open-network-stream'.
|
|
|
406 Optional SERVICE specifies the port used \(default \"discard\"\).
|
|
13531
|
407 Optional QUIET flag suppresses the \"Pinging...\" message.
|
|
14874
|
408 Optional STRATEGY overrides the three variables above.
|
|
13531
|
409 Returned values:
|
|
14874
|
410 t means that HOST answered.
|
|
|
411 'accept means the relevant variable told us to accept.
|
|
|
412 \"mesg\" means HOST exists, but does not respond for some reason."
|
|
|
413 ;; Try some (Emory local):
|
|
|
414 ;; (ffap-machine-p "ftp" nil nil 'ping)
|
|
|
415 ;; (ffap-machine-p "nonesuch" nil nil 'ping)
|
|
|
416 ;; (ffap-machine-p "ftp.mathcs.emory.edu" nil nil 'ping)
|
|
|
417 ;; (ffap-machine-p "mathcs" 5678 nil 'ping)
|
|
|
418 ;; (ffap-machine-p "foo.bonk" nil nil 'ping)
|
|
|
419 ;; (ffap-machine-p "foo.bonk.com" nil nil 'ping)
|
|
80037
|
420 (if (or (string-match "[^-[:alnum:].]" host) ; Invalid chars (?)
|
|
14874
|
421 (not (string-match "[^0-9]" host))) ; 1: a number? 2: quick reject
|
|
13531
|
422 nil
|
|
|
423 (let* ((domain
|
|
|
424 (and (string-match "\\.[^.]*$" host)
|
|
|
425 (downcase (substring host (1+ (match-beginning 0))))))
|
|
14874
|
426 (what-domain (if domain (ffap-what-domain domain) "Local")))
|
|
|
427 (or strategy
|
|
|
428 (setq strategy
|
|
|
429 (cond ((not domain) ffap-machine-p-local)
|
|
|
430 ((not what-domain) ffap-machine-p-unknown)
|
|
|
431 (t ffap-machine-p-known))))
|
|
13531
|
432 (cond
|
|
|
433 ((eq strategy 'accept) 'accept)
|
|
|
434 ((eq strategy 'reject) nil)
|
|
38070
|
435 ((not (fboundp 'open-network-stream)) nil)
|
|
13531
|
436 ;; assume (eq strategy 'ping)
|
|
|
437 (t
|
|
|
438 (or quiet
|
|
14874
|
439 (if (stringp what-domain)
|
|
|
440 (message "Pinging %s (%s)..." host what-domain)
|
|
13531
|
441 (message "Pinging %s ..." host)))
|
|
|
442 (condition-case error
|
|
|
443 (progn
|
|
|
444 (delete-process
|
|
|
445 (open-network-stream
|
|
|
446 "ffap-machine-p" nil host (or service "discard")))
|
|
|
447 t)
|
|
|
448 (error
|
|
|
449 (let ((mesg (car (cdr error))))
|
|
|
450 (cond
|
|
|
451 ;; v18:
|
|
|
452 ((string-match "^Unknown host" mesg) nil)
|
|
|
453 ((string-match "not responding$" mesg) mesg)
|
|
|
454 ;; v19:
|
|
|
455 ;; (file-error "connection failed" "permission denied"
|
|
|
456 ;; "nonesuch" "ffap-machine-p")
|
|
|
457 ;; (file-error "connection failed" "host is unreachable"
|
|
|
458 ;; "gopher.house.gov" "ffap-machine-p")
|
|
|
459 ;; (file-error "connection failed" "address already in use"
|
|
|
460 ;; "ftp.uu.net" "ffap-machine-p")
|
|
|
461 ((equal mesg "connection failed")
|
|
|
462 (if (equal (nth 2 error) "permission denied")
|
|
|
463 nil ; host does not exist
|
|
14874
|
464 ;; Other errors mean the host exists:
|
|
13531
|
465 (nth 2 error)))
|
|
|
466 ;; Could be "Unknown service":
|
|
|
467 (t (signal (car error) (cdr error))))))))))))
|
|
|
468
|
|
18291
|
469
|
|
|
470 ;;; Possibly Remote Resources:
|
|
|
471
|
|
49808
|
472 (defun ffap-replace-file-component (fullname name)
|
|
18291
|
473 "In remote FULLNAME, replace path with NAME. May return nil."
|
|
|
474 ;; Use ange-ftp or efs if loaded, but do not load them otherwise.
|
|
|
475 (let (found)
|
84866
45ab0bfaaa12
(ffap-replace-file-component): Use `mapc' rather than `mapcar'.
Juanma Barranquero <lekktu@gmail.com>
diff
changeset
|
476 (mapc
|
|
18291
|
477 (function (lambda (sym) (and (fboundp sym) (setq found sym))))
|
|
|
478 '(
|
|
|
479 efs-replace-path-component
|
|
|
480 ange-ftp-replace-path-component
|
|
|
481 ange-ftp-replace-name-component
|
|
|
482 ))
|
|
|
483 (and found
|
|
49808
|
484 (fset 'ffap-replace-file-component found)
|
|
18291
|
485 (funcall found fullname name))))
|
|
49808
|
486 ;; (ffap-replace-file-component "/who@foo.com:/whatever" "/new")
|
|
18291
|
487
|
|
18486
|
488 (defun ffap-file-suffix (file)
|
|
23352
|
489 "Return trailing `.foo' suffix of FILE, or nil if none."
|
|
18486
|
490 (let ((pos (string-match "\\.[^./]*\\'" file)))
|
|
|
491 (and pos (substring file pos nil))))
|
|
|
492
|
|
|
493 (defvar ffap-compression-suffixes '(".gz" ".Z") ; .z is mostly dead
|
|
|
494 "List of suffixes tried by `ffap-file-exists-string'.")
|
|
18291
|
495
|
|
18486
|
496 (defun ffap-file-exists-string (file &optional nomodify)
|
|
|
497 ;; Early jka-compr versions modified file-exists-p to return the
|
|
|
498 ;; filename, maybe modified by adding a suffix like ".gz". That
|
|
|
499 ;; broke the interface of file-exists-p, so it was later dropped.
|
|
|
500 ;; Here we document and simulate the old behavior.
|
|
23352
|
501 "Return FILE (maybe modified) if the file exists, else nil.
|
|
18486
|
502 When using jka-compr (a.k.a. `auto-compression-mode'), the returned
|
|
|
503 name may have a suffix added from `ffap-compression-suffixes'.
|
|
|
504 The optional NOMODIFY argument suppresses the extra search."
|
|
|
505 (cond
|
|
|
506 ((not file) nil) ; quietly reject nil
|
|
|
507 ((file-exists-p file) file) ; try unmodified first
|
|
|
508 ;; three reasons to suppress search:
|
|
|
509 (nomodify nil)
|
|
|
510 ((not (rassq 'jka-compr-handler file-name-handler-alist)) nil)
|
|
|
511 ((member (ffap-file-suffix file) ffap-compression-suffixes) nil)
|
|
|
512 (t ; ok, do the search
|
|
|
513 (let ((list ffap-compression-suffixes) try ret)
|
|
|
514 (while list
|
|
|
515 (if (file-exists-p (setq try (concat file (car list))))
|
|
|
516 (setq ret try list nil)
|
|
|
517 (setq list (cdr list))))
|
|
|
518 ret))))
|
|
18291
|
519
|
|
13531
|
520 (defun ffap-file-remote-p (filename)
|
|
23352
|
521 "If FILENAME looks remote, return it (maybe slightly improved)."
|
|
13531
|
522 ;; (ffap-file-remote-p "/user@foo.bar.com:/pub")
|
|
49808
|
523 ;; (ffap-file-remote-p "/cssun.mathcs.emory.edu://dir")
|
|
14874
|
524 ;; (ffap-file-remote-p "/ffap.el:80")
|
|
13531
|
525 (or (and ffap-ftp-regexp
|
|
|
526 (string-match ffap-ftp-regexp filename)
|
|
49808
|
527 ;; Convert "/host.com://dir" to "/host:/dir", to handle a dieing
|
|
|
528 ;; practice of advertising ftp files as "host.dom://filename".
|
|
13531
|
529 (if (string-match "//" filename)
|
|
14874
|
530 ;; (replace-match "/" nil nil filename)
|
|
|
531 (concat (substring filename 0 (1+ (match-beginning 0)))
|
|
|
532 (substring filename (match-end 0)))
|
|
13531
|
533 filename))
|
|
|
534 (and ffap-rfs-regexp
|
|
|
535 (string-match ffap-rfs-regexp filename)
|
|
|
536 filename)))
|
|
|
537
|
|
106503
|
538 (defun ffap-machine-at-point ()
|
|
14874
|
539 "Return machine name at point if it exists, or nil."
|
|
|
540 (let ((mach (ffap-string-at-point 'machine)))
|
|
13531
|
541 (and (ffap-machine-p mach) mach)))
|
|
|
542
|
|
49808
|
543 (defsubst ffap-host-to-filename (host)
|
|
18291
|
544 "Convert HOST to something like \"/USER@HOST:\" or \"/HOST:\".
|
|
14874
|
545 Looks at `ffap-ftp-default-user', returns \"\" for \"localhost\"."
|
|
18291
|
546 (if (equal host "localhost")
|
|
|
547 ""
|
|
|
548 (let ((user ffap-ftp-default-user))
|
|
|
549 ;; Avoid including the user if it is same as default:
|
|
106503
|
550 (if (or (equal user (ffap-symbol-value 'ange-ftp-default-user))
|
|
|
551 (equal user (ffap-symbol-value 'efs-default-user)))
|
|
18291
|
552 (setq user nil))
|
|
|
553 (concat "/" user (and user "@") host ":"))))
|
|
14874
|
554
|
|
13531
|
555 (defun ffap-fixup-machine (mach)
|
|
49808
|
556 ;; Convert a hostname into an url, an ftp file name, or nil.
|
|
13531
|
557 (cond
|
|
|
558 ((not (and ffap-url-regexp (stringp mach))) nil)
|
|
14874
|
559 ;; gopher.well.com
|
|
13531
|
560 ((string-match "\\`gopher[-.]" mach) ; or "info"?
|
|
|
561 (concat "gopher://" mach "/"))
|
|
14874
|
562 ;; www.ncsa.uiuc.edu
|
|
13531
|
563 ((and (string-match "\\`w\\(ww\\|eb\\)[-.]" mach))
|
|
|
564 (concat "http://" mach "/"))
|
|
|
565 ;; More cases? Maybe "telnet:" for archie?
|
|
49808
|
566 (ffap-ftp-regexp (ffap-host-to-filename mach))
|
|
13531
|
567 ))
|
|
|
568
|
75189
c456d15d23fd
(ffap-next-regexp, ffap-machine-p, ffap-newsgroup-regexp)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
569 (defvar ffap-newsgroup-regexp "^[[:lower:]]+\\.[-+[:lower:]_0-9.]+$"
|
|
17676
|
570 "Strings not matching this fail `ffap-newsgroup-p'.")
|
|
|
571 (defvar ffap-newsgroup-heads ; entirely inadequate
|
|
|
572 '("alt" "comp" "gnu" "misc" "news" "sci" "soc" "talk")
|
|
|
573 "Used by `ffap-newsgroup-p' if gnus is not running.")
|
|
|
574
|
|
13531
|
575 (defun ffap-newsgroup-p (string)
|
|
|
576 "Return STRING if it looks like a newsgroup name, else nil."
|
|
|
577 (and
|
|
|
578 (string-match ffap-newsgroup-regexp string)
|
|
|
579 (let ((htbs '(gnus-active-hashtb gnus-newsrc-hashtb gnus-killed-hashtb))
|
|
|
580 (heads ffap-newsgroup-heads)
|
|
|
581 htb ret)
|
|
|
582 (while htbs
|
|
|
583 (setq htb (car htbs) htbs (cdr htbs))
|
|
|
584 (condition-case nil
|
|
|
585 (progn
|
|
|
586 ;; errs: htb symbol may be unbound, or not a hash-table.
|
|
|
587 ;; gnus-gethash is just a macro for intern-soft.
|
|
43174
|
588 (and (symbol-value htb)
|
|
|
589 (intern-soft string (symbol-value htb))
|
|
13531
|
590 (setq ret string htbs nil))
|
|
14874
|
591 ;; If we made it this far, gnus is running, so ignore "heads":
|
|
13531
|
592 (setq heads nil))
|
|
|
593 (error nil)))
|
|
|
594 (or ret (not heads)
|
75189
c456d15d23fd
(ffap-next-regexp, ffap-machine-p, ffap-newsgroup-regexp)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
595 (let ((head (string-match "\\`\\([[:lower:]]+\\)\\." string)))
|
|
13531
|
596 (and head (setq head (substring string 0 (match-end 1)))
|
|
|
597 (member head heads)
|
|
|
598 (setq ret string))))
|
|
14874
|
599 ;; Is there ever a need to modify string as a newsgroup name?
|
|
13531
|
600 ret)))
|
|
|
601
|
|
14874
|
602 (defsubst ffap-url-p (string)
|
|
|
603 "If STRING looks like an url, return it (maybe improved), else nil."
|
|
13531
|
604 (let ((case-fold-search t))
|
|
|
605 (and ffap-url-regexp (string-match ffap-url-regexp string)
|
|
|
606 ;; I lied, no improvement:
|
|
|
607 string)))
|
|
|
608
|
|
14874
|
609 ;; Broke these out of ffap-fixup-url, for use of ffap-url package.
|
|
|
610 (defsubst ffap-url-unwrap-local (url)
|
|
|
611 "Return URL as a local file, or nil. Ignores `ffap-url-regexp'."
|
|
13531
|
612 (and (string-match "\\`\\(file\\|ftp\\):/?\\([^/]\\|\\'\\)" url)
|
|
|
613 (substring url (1+ (match-end 1)))))
|
|
14874
|
614 (defsubst ffap-url-unwrap-remote (url)
|
|
|
615 "Return URL as a remote file, or nil. Ignores `ffap-url-regexp'."
|
|
13531
|
616 (and (string-match "\\`\\(ftp\\|file\\)://\\([^:/]+\\):?\\(/.*\\)" url)
|
|
|
617 (concat
|
|
49808
|
618 (ffap-host-to-filename (substring url (match-beginning 2) (match-end 2)))
|
|
13531
|
619 (substring url (match-beginning 3) (match-end 3)))))
|
|
14874
|
620 ;; Test: (ffap-url-unwrap-remote "ftp://foo.com/bar.boz")
|
|
13531
|
621
|
|
|
622 (defun ffap-fixup-url (url)
|
|
14874
|
623 "Clean up URL and return it, maybe as a file name."
|
|
13531
|
624 (cond
|
|
|
625 ((not (stringp url)) nil)
|
|
|
626 ((and ffap-url-unwrap-local (ffap-url-unwrap-local url)))
|
|
|
627 ((and ffap-url-unwrap-remote ffap-ftp-regexp
|
|
|
628 (ffap-url-unwrap-remote url)))
|
|
98339
|
629 ;; All this seems to do is remove any trailing "#anchor" part (Bug#898).
|
|
|
630 ;;; ((fboundp 'url-normalize-url) ; may autoload url (part of w3)
|
|
|
631 ;;; (url-normalize-url url))
|
|
18486
|
632 (url)))
|
|
13531
|
633
|
|
|
634
|
|
49808
|
635 ;;; File Name Handling:
|
|
13531
|
636 ;;
|
|
18291
|
637 ;; The upcoming ffap-alist actions need various utilities to prepare
|
|
49808
|
638 ;; and search directories. Too many features here.
|
|
13531
|
639
|
|
18291
|
640 ;; (defun ffap-last (l) (while (cdr l) (setq l (cdr l))) l)
|
|
|
641 ;; (defun ffap-splice (func inlist)
|
|
|
642 ;; "Equivalent to (apply 'nconc (mapcar FUNC INLIST)), but less consing."
|
|
|
643 ;; (let* ((head (cons 17 nil)) (last head))
|
|
|
644 ;; (while inlist
|
|
|
645 ;; (setcdr last (funcall func (car inlist)))
|
|
|
646 ;; (setq last (ffap-last last) inlist (cdr inlist)))
|
|
|
647 ;; (cdr head)))
|
|
13531
|
648
|
|
|
649 (defun ffap-list-env (env &optional empty)
|
|
18291
|
650 "Return a list of strings parsed from environment variable ENV.
|
|
|
651 Optional EMPTY is the default list if \(getenv ENV\) is undefined, and
|
|
|
652 also is substituted for the first empty-string component, if there is one.
|
|
|
653 Uses `path-separator' to separate the path into substrings."
|
|
|
654 ;; We cannot use parse-colon-path (files.el), since it kills
|
|
|
655 ;; "//" entries using file-name-as-directory.
|
|
|
656 ;; Similar: dired-split, TeX-split-string, and RHOGEE's psg-list-env
|
|
|
657 ;; in ff-paths and bib-cite. The EMPTY arg may help mimic kpathsea.
|
|
13531
|
658 (if (or empty (getenv env)) ; should return something
|
|
|
659 (let ((start 0) match dir ret)
|
|
14874
|
660 (setq env (concat (getenv env) path-separator))
|
|
13905
|
661 (while (setq match (string-match path-separator env start))
|
|
13531
|
662 (setq dir (substring env start match) start (1+ match))
|
|
|
663 ;;(and (file-directory-p dir) (not (member dir ret)) ...)
|
|
|
664 (setq ret (cons dir ret)))
|
|
|
665 (setq ret (nreverse ret))
|
|
|
666 (and empty (setq match (member "" ret))
|
|
18291
|
667 (progn ; allow string or list here
|
|
13531
|
668 (setcdr match (append (cdr-safe empty) (cdr match)))
|
|
|
669 (setcar match (or (car-safe empty) empty))))
|
|
|
670 ret)))
|
|
|
671
|
|
|
672 (defun ffap-reduce-path (path)
|
|
14874
|
673 "Remove duplicates and non-directories from PATH list."
|
|
13531
|
674 (let (ret tem)
|
|
|
675 (while path
|
|
|
676 (setq tem path path (cdr path))
|
|
14874
|
677 (if (equal (car tem) ".") (setcar tem ""))
|
|
13531
|
678 (or (member (car tem) ret)
|
|
|
679 (not (file-directory-p (car tem)))
|
|
|
680 (progn (setcdr tem ret) (setq ret tem))))
|
|
|
681 (nreverse ret)))
|
|
|
682
|
|
18291
|
683 (defun ffap-all-subdirs (dir &optional depth)
|
|
|
684 "Return list all subdirectories under DIR, starting with itself.
|
|
|
685 Directories beginning with \".\" are ignored, and directory symlinks
|
|
|
686 are listed but never searched (to avoid loops).
|
|
|
687 Optional DEPTH limits search depth."
|
|
|
688 (and (file-exists-p dir)
|
|
|
689 (ffap-all-subdirs-loop (expand-file-name dir) (or depth -1))))
|
|
|
690
|
|
|
691 (defun ffap-all-subdirs-loop (dir depth) ; internal
|
|
|
692 (setq depth (1- depth))
|
|
|
693 (cons dir
|
|
|
694 (and (not (eq depth -1))
|
|
|
695 (apply 'nconc
|
|
|
696 (mapcar
|
|
|
697 (function
|
|
|
698 (lambda (d)
|
|
|
699 (cond
|
|
|
700 ((not (file-directory-p d)) nil)
|
|
|
701 ((file-symlink-p d) (list d))
|
|
|
702 (t (ffap-all-subdirs-loop d depth)))))
|
|
|
703 (directory-files dir t "\\`[^.]")
|
|
|
704 )))))
|
|
|
705
|
|
|
706 (defvar ffap-kpathsea-depth 1
|
|
|
707 "Bound on depth of subdirectory search in `ffap-kpathsea-expand-path'.
|
|
|
708 Set to 0 to avoid all searching, or nil for no limit.")
|
|
|
709
|
|
|
710 (defun ffap-kpathsea-expand-path (path)
|
|
|
711 "Replace each \"//\"-suffixed dir in PATH by a list of its subdirs.
|
|
|
712 The subdirs begin with the original directory, and the depth of the
|
|
|
713 search is bounded by `ffap-kpathsea-depth'. This is intended to mimic
|
|
|
714 kpathsea, a library used by some versions of TeX."
|
|
|
715 (apply 'nconc
|
|
|
716 (mapcar
|
|
|
717 (function
|
|
|
718 (lambda (dir)
|
|
|
719 (if (string-match "[^/]//\\'" dir)
|
|
|
720 (ffap-all-subdirs (substring dir 0 -2) ffap-kpathsea-depth)
|
|
|
721 (list dir))))
|
|
|
722 path)))
|
|
|
723
|
|
106503
|
724 (defun ffap-locate-file (file nosuffix path)
|
|
68828
|
725 ;; The current version of locate-library could almost replace this,
|
54183
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
726 ;; except it does not let us override the suffix list. The
|
|
18486
|
727 ;; compression-suffixes search moved to ffap-file-exists-string.
|
|
106503
|
728 "A generic path-searching function.
|
|
|
729 Returns the name of file in PATH, or nil.
|
|
18291
|
730 Optional NOSUFFIX, if nil or t, is like the fourth argument
|
|
106503
|
731 for `load': whether to try the suffixes (\".elc\" \".el\" \"\").
|
|
18291
|
732 If a nonempty list, it is a list of suffixes to try instead.
|
|
106503
|
733 PATH is a list of directories.
|
|
18486
|
734
|
|
106503
|
735 This uses `ffap-file-exists-string', which may try adding suffixes from
|
|
18486
|
736 `ffap-compression-suffixes'."
|
|
18291
|
737 (if (file-name-absolute-p file)
|
|
|
738 (setq path (list (file-name-directory file))
|
|
|
739 file (file-name-nondirectory file)))
|
|
106503
|
740 (let ((dir-ok (equal "" (file-name-nondirectory file)))
|
|
|
741 (suffixes-to-try
|
|
18291
|
742 (cond
|
|
|
743 ((consp nosuffix) nosuffix)
|
|
|
744 (nosuffix '(""))
|
|
18486
|
745 (t '(".elc" ".el" ""))))
|
|
|
746 suffixes try found)
|
|
|
747 (while path
|
|
|
748 (setq suffixes suffixes-to-try)
|
|
|
749 (while suffixes
|
|
|
750 (setq try (ffap-file-exists-string
|
|
|
751 (expand-file-name
|
|
|
752 (concat file (car suffixes)) (car path))))
|
|
|
753 (if (and try (or dir-ok (not (file-directory-p try))))
|
|
|
754 (setq found try suffixes nil path nil)
|
|
|
755 (setq suffixes (cdr suffixes))))
|
|
|
756 (setq path (cdr path)))
|
|
|
757 found))
|
|
18291
|
758
|
|
|
759
|
|
|
760 ;;; Action List (`ffap-alist'):
|
|
|
761 ;;
|
|
|
762 ;; These search actions depend on the major-mode or regexps matching
|
|
|
763 ;; the current name. The little functions and their variables are
|
|
|
764 ;; deferred to the next section, at some loss of "code locality". A
|
|
|
765 ;; good example of featuritis. Trim this list for speed.
|
|
13531
|
766
|
|
|
767 (defvar ffap-alist
|
|
17676
|
768 '(
|
|
18291
|
769 ("" . ffap-completable) ; completion, slow on some systems
|
|
|
770 ("\\.info\\'" . ffap-info) ; gzip.info
|
|
|
771 ("\\`info/" . ffap-info-2) ; info/emacs
|
75189
c456d15d23fd
(ffap-next-regexp, ffap-machine-p, ffap-newsgroup-regexp)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
772 ("\\`[-[:lower:]]+\\'" . ffap-info-3) ; (emacs)Top [only in the parentheses]
|
|
18291
|
773 ("\\.elc?\\'" . ffap-el) ; simple.el, simple.elc
|
|
|
774 (emacs-lisp-mode . ffap-el-mode) ; rmail, gnus, simple, custom
|
|
18486
|
775 ;; (lisp-interaction-mode . ffap-el-mode) ; maybe
|
|
18291
|
776 (finder-mode . ffap-el-mode) ; type {C-h p} and try it
|
|
|
777 (help-mode . ffap-el-mode) ; maybe useful
|
|
|
778 (c++-mode . ffap-c-mode) ; search ffap-c-path
|
|
|
779 (cc-mode . ffap-c-mode) ; same
|
|
|
780 ("\\.\\([chCH]\\|cc\\|hh\\)\\'" . ffap-c-mode) ; stdio.h
|
|
|
781 (fortran-mode . ffap-fortran-mode) ; FORTRAN requested by MDB
|
|
|
782 ("\\.[fF]\\'" . ffap-fortran-mode)
|
|
|
783 (tex-mode . ffap-tex-mode) ; search ffap-tex-path
|
|
|
784 (latex-mode . ffap-latex-mode) ; similar
|
|
17676
|
785 ("\\.\\(tex\\|sty\\|doc\\|cls\\)\\'" . ffap-tex)
|
|
18291
|
786 ("\\.bib\\'" . ffap-bib) ; search ffap-bib-path
|
|
|
787 ("\\`\\." . ffap-home) ; .emacs, .bashrc, .profile
|
|
|
788 ("\\`~/" . ffap-lcd) ; |~/misc/ffap.el.Z|
|
|
106503
|
789 ;; This used to have a blank, but ffap-string-at-point doesn't
|
|
87822
|
790 ;; handle blanks.
|
|
|
791 ;; http://lists.gnu.org/archive/html/emacs-devel/2008-01/msg01058.html
|
|
106503
|
792 ("\\`[Rr][Ff][Cc][-#]?\\([0-9]+\\)" ; no $
|
|
18291
|
793 . ffap-rfc) ; "100% RFC2100 compliant"
|
|
|
794 (dired-mode . ffap-dired) ; maybe in a subdirectory
|
|
|
795 )
|
|
14874
|
796 "Alist of \(KEY . FUNCTION\) pairs parsed by `ffap-file-at-point'.
|
|
|
797 If string NAME at point (maybe \"\") is not a file or url, these pairs
|
|
|
798 specify actions to try creating such a string. A pair matches if either
|
|
|
799 KEY is a symbol, and it equals `major-mode', or
|
|
|
800 KEY is a string, it should matches NAME as a regexp.
|
|
|
801 On a match, \(FUNCTION NAME\) is called and should return a file, an
|
|
|
802 url, or nil. If nil, search the alist for further matches.")
|
|
13531
|
803
|
|
|
804 (put 'ffap-alist 'risky-local-variable t)
|
|
18291
|
805
|
|
18486
|
806 ;; Example `ffap-alist' modifications:
|
|
|
807 ;;
|
|
|
808 ;; (setq ffap-alist ; remove a feature in `ffap-alist'
|
|
|
809 ;; (delete (assoc 'c-mode ffap-alist) ffap-alist))
|
|
|
810 ;;
|
|
|
811 ;; (setq ffap-alist ; add something to `ffap-alist'
|
|
|
812 ;; (cons
|
|
|
813 ;; (cons "^YSN[0-9]+$"
|
|
|
814 ;; (defun ffap-ysn (name)
|
|
|
815 ;; (concat
|
|
|
816 ;; "http://www.physics.uiuc.edu/"
|
|
|
817 ;; "ysn/httpd/htdocs/ysnarchive/issuefiles/"
|
|
|
818 ;; (substring name 3) ".html")))
|
|
|
819 ;; ffap-alist))
|
|
|
820
|
|
17676
|
821
|
|
18291
|
822 ;;; Action Definitions:
|
|
|
823 ;;
|
|
|
824 ;; Define various default members of `ffap-alist'.
|
|
|
825
|
|
|
826 (defun ffap-completable (name)
|
|
|
827 (let* ((dir (or (file-name-directory name) default-directory))
|
|
|
828 (cmp (file-name-completion (file-name-nondirectory name) dir)))
|
|
|
829 (and cmp (concat dir cmp))))
|
|
|
830
|
|
|
831 (defun ffap-home (name) (ffap-locate-file name t '("~")))
|
|
13531
|
832
|
|
17676
|
833 (defun ffap-info (name)
|
|
18291
|
834 (ffap-locate-file
|
|
17676
|
835 name '("" ".info")
|
|
106503
|
836 (or (ffap-symbol-value 'Info-directory-list)
|
|
|
837 (ffap-symbol-value 'Info-default-directory-list)
|
|
18291
|
838 )))
|
|
17676
|
839
|
|
|
840 (defun ffap-info-2 (name) (ffap-info (substring name 5)))
|
|
|
841
|
|
|
842 (defun ffap-info-3 (name)
|
|
18291
|
843 ;; This ignores the node! "(emacs)Top" same as "(emacs)Intro"
|
|
17676
|
844 (and (equal (ffap-string-around) "()") (ffap-info name)))
|
|
|
845
|
|
106503
|
846 (defun ffap-el (name) (ffap-locate-file name t load-path))
|
|
17676
|
847
|
|
|
848 (defun ffap-el-mode (name)
|
|
18291
|
849 ;; If name == "foo.el" we will skip it, since ffap-el already
|
|
|
850 ;; searched for it once. (This assumes the default ffap-alist.)
|
|
17676
|
851 (and (not (string-match "\\.el\\'" name))
|
|
106503
|
852 (ffap-locate-file name '(".el") load-path)))
|
|
17676
|
853
|
|
18291
|
854 (defvar ffap-c-path
|
|
|
855 ;; Need smarter defaults here! Suggestions welcome.
|
|
|
856 '("/usr/include" "/usr/local/include"))
|
|
|
857 (defun ffap-c-mode (name)
|
|
|
858 (ffap-locate-file name t ffap-c-path))
|
|
|
859
|
|
|
860 (defvar ffap-fortran-path '("../include" "/usr/include"))
|
|
|
861
|
|
|
862 (defun ffap-fortran-mode (name)
|
|
|
863 (ffap-locate-file name t ffap-fortran-path))
|
|
|
864
|
|
17676
|
865 (defvar ffap-tex-path
|
|
|
866 t ; delayed initialization
|
|
|
867 "Path where `ffap-tex-mode' looks for tex files.
|
|
|
868 If t, `ffap-tex-init' will initialize this when needed.")
|
|
|
869
|
|
106503
|
870 (defun ffap-tex-init ()
|
|
17676
|
871 ;; Compute ffap-tex-path if it is now t.
|
|
|
872 (and (eq t ffap-tex-path)
|
|
18291
|
873 ;; this may be slow, so say something
|
|
17676
|
874 (message "Initializing ffap-tex-path ...")
|
|
|
875 (setq ffap-tex-path
|
|
|
876 (ffap-reduce-path
|
|
18291
|
877 (cons
|
|
|
878 "."
|
|
|
879 (ffap-kpathsea-expand-path
|
|
|
880 (append
|
|
|
881 (ffap-list-env "TEXINPUTS")
|
|
|
882 ;; (ffap-list-env "BIBINPUTS")
|
|
106503
|
883 (ffap-symbol-value
|
|
|
884 'TeX-macro-global ; AUCTeX
|
|
18291
|
885 '("/usr/local/lib/tex/macros"
|
|
|
886 "/usr/local/lib/tex/inputs")))))))))
|
|
17676
|
887
|
|
|
888 (defun ffap-tex-mode (name)
|
|
|
889 (ffap-tex-init)
|
|
18291
|
890 (ffap-locate-file name '(".tex" "") ffap-tex-path))
|
|
17676
|
891
|
|
|
892 (defun ffap-latex-mode (name)
|
|
|
893 (ffap-tex-init)
|
|
18291
|
894 ;; only rare need for ""
|
|
|
895 (ffap-locate-file name '(".cls" ".sty" ".tex" "") ffap-tex-path))
|
|
17676
|
896
|
|
|
897 (defun ffap-tex (name)
|
|
|
898 (ffap-tex-init)
|
|
18291
|
899 (ffap-locate-file name t ffap-tex-path))
|
|
|
900
|
|
|
901 (defvar ffap-bib-path
|
|
|
902 (ffap-list-env "BIBINPUTS"
|
|
|
903 (ffap-reduce-path
|
|
|
904 '(
|
|
|
905 ;; a few wild guesses, need better
|
|
|
906 "/usr/local/lib/tex/macros/bib" ; Solaris?
|
|
|
907 "/usr/lib/texmf/bibtex/bib" ; Linux?
|
|
|
908 ))))
|
|
17676
|
909
|
|
|
910 (defun ffap-bib (name)
|
|
18291
|
911 (ffap-locate-file name t ffap-bib-path))
|
|
17676
|
912
|
|
|
913 (defun ffap-dired (name)
|
94217
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
914 (let ((pt (point)) try)
|
|
17676
|
915 (save-excursion
|
|
|
916 (and (progn
|
|
|
917 (beginning-of-line)
|
|
|
918 (looking-at " *[-d]r[-w][-x][-r][-w][-x][-r][-w][-x] "))
|
|
|
919 (re-search-backward "^ *$" nil t)
|
|
|
920 (re-search-forward "^ *\\([^ \t\n:]*\\):\n *total " pt t)
|
|
|
921 (file-exists-p
|
|
|
922 (setq try
|
|
|
923 (expand-file-name
|
|
|
924 name
|
|
|
925 (buffer-substring
|
|
|
926 (match-beginning 1) (match-end 1)))))
|
|
|
927 try))))
|
|
|
928
|
|
|
929 ;; Maybe a "Lisp Code Directory" reference:
|
|
|
930 (defun ffap-lcd (name)
|
|
106503
|
931 ;; FIXME: Is this still in use?
|
|
17676
|
932 (and
|
|
|
933 (or
|
|
|
934 ;; lisp-dir-apropos output buffer:
|
|
|
935 (string-match "Lisp Code Dir" (buffer-name))
|
|
|
936 ;; Inside an LCD entry like |~/misc/ffap.el.Z|,
|
|
|
937 ;; or maybe the holy LCD-Datafile itself:
|
|
|
938 (member (ffap-string-around) '("||" "|\n")))
|
|
|
939 (concat
|
|
|
940 ;; lispdir.el may not be loaded yet:
|
|
49808
|
941 (ffap-host-to-filename
|
|
106503
|
942 (ffap-symbol-value 'elisp-archive-host
|
|
|
943 "archive.cis.ohio-state.edu"))
|
|
17676
|
944 (file-name-as-directory
|
|
106503
|
945 (ffap-symbol-value 'elisp-archive-directory
|
|
|
946 "/pub/gnu/emacs/elisp-archive/"))
|
|
17676
|
947 (substring name 2))))
|
|
|
948
|
|
106448
|
949 (defcustom ffap-rfc-path
|
|
|
950 (concat (ffap-host-to-filename "ftp.rfc-editor.org") "/in-notes/rfc%s.txt")
|
|
|
951 "A `format' string making a filename for RFC documents.
|
|
|
952 This can be an ange-ftp or tramp remote filename to download, or
|
|
|
953 a local filename if you have full set of RFCs locally. See also
|
|
|
954 `ffap-rfc-directories'."
|
|
|
955 :type 'string
|
|
|
956 :version "23.1"
|
|
|
957 :group 'ffap)
|
|
|
958
|
|
91755
|
959 (defcustom ffap-rfc-directories nil
|
|
|
960 "A list of directories to look for RFC files.
|
|
|
961 If a given RFC isn't in these then `ffap-rfc-path' is offered."
|
|
|
962 :type '(repeat directory)
|
|
91756
|
963 :version "23.1"
|
|
91755
|
964 :group 'ffap)
|
|
|
965
|
|
17676
|
966 (defun ffap-rfc (name)
|
|
91755
|
967 (let ((num (match-string 1 name)))
|
|
|
968 (or (ffap-locate-file (format "rfc%s.txt" num) t ffap-rfc-directories)
|
|
|
969 (format ffap-rfc-path num))))
|
|
18291
|
970
|
|
13531
|
971
|
|
|
972 ;;; At-Point Functions:
|
|
|
973
|
|
|
974 (defvar ffap-string-at-point-mode-alist
|
|
|
975 '(
|
|
14874
|
976 ;; The default, used when the `major-mode' is not found.
|
|
13531
|
977 ;; Slightly controversial decisions:
|
|
|
978 ;; * strip trailing "@" and ":"
|
|
|
979 ;; * no commas (good for latex)
|
95784
ebad352d55ce
(ffap-string-at-point-mode-alist): Use alpha rather than lower.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
980 (file "--:\\\\$+<>@-Z_[:alpha:]~*?" "<@" "@>;.,!:")
|
|
14874
|
981 ;; An url, or maybe a email/news message-id:
|
95784
ebad352d55ce
(ffap-string-at-point-mode-alist): Use alpha rather than lower.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
982 (url "--:=&?$+@-Z_[:alpha:]~#,%;*" "^[:alnum:]" ":;.,!?")
|
|
14874
|
983 ;; Find a string that does *not* contain a colon:
|
95784
ebad352d55ce
(ffap-string-at-point-mode-alist): Use alpha rather than lower.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
984 (nocolon "--9$+<>@-Z_[:alpha:]~" "<@" "@>;.,!?")
|
|
14874
|
985 ;; A machine:
|
75189
c456d15d23fd
(ffap-next-regexp, ffap-machine-p, ffap-newsgroup-regexp)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
986 (machine "-[:alnum:]." "" ".")
|
|
14874
|
987 ;; Mathematica paths: allow backquotes
|
75189
c456d15d23fd
(ffap-next-regexp, ffap-machine-p, ffap-newsgroup-regexp)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
988 (math-mode ",-:$+<>@-Z_[:lower:]~`" "<" "@>;.,!?`:")
|
|
13531
|
989 )
|
|
14874
|
990 "Alist of \(MODE CHARS BEG END\), where MODE is a symbol,
|
|
23352
|
991 possibly a major-mode name, or one of the symbol
|
|
|
992 `file', `url', `machine', and `nocolon'.
|
|
14874
|
993 `ffap-string-at-point' uses the data fields as follows:
|
|
|
994 1. find a maximal string of CHARS around point,
|
|
|
995 2. strip BEG chars before point from the beginning,
|
|
|
996 3. Strip END chars after point from the end.")
|
|
13531
|
997
|
|
|
998 (defvar ffap-string-at-point nil
|
|
|
999 ;; Added at suggestion of RHOGEE (for ff-paths), 7/24/95.
|
|
14874
|
1000 "Last string returned by `ffap-string-at-point'.")
|
|
|
1001
|
|
|
1002 (defun ffap-string-at-point (&optional mode)
|
|
|
1003 "Return a string of characters from around point.
|
|
23352
|
1004 MODE (defaults to value of `major-mode') is a symbol used to look up string
|
|
14874
|
1005 syntax parameters in `ffap-string-at-point-mode-alist'.
|
|
23352
|
1006 If MODE is not found, we use `file' instead of MODE.
|
54183
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1007 If the region is active, return a string from the region.
|
|
14874
|
1008 Sets `ffap-string-at-point' and `ffap-string-at-point-region'."
|
|
|
1009 (let* ((args
|
|
|
1010 (cdr
|
|
|
1011 (or (assq (or mode major-mode) ffap-string-at-point-mode-alist)
|
|
|
1012 (assq 'file ffap-string-at-point-mode-alist))))
|
|
|
1013 (pt (point))
|
|
|
1014 (str
|
54183
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1015 (if (and transient-mark-mode mark-active)
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1016 (buffer-substring
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1017 (setcar ffap-string-at-point-region (region-beginning))
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1018 (setcar (cdr ffap-string-at-point-region) (region-end)))
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1019 (buffer-substring
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1020 (save-excursion
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1021 (skip-chars-backward (car args))
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1022 (skip-chars-forward (nth 1 args) pt)
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1023 (setcar ffap-string-at-point-region (point)))
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1024 (save-excursion
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1025 (skip-chars-forward (car args))
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1026 (skip-chars-backward (nth 2 args) pt)
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1027 (setcar (cdr ffap-string-at-point-region) (point)))))))
|
|
18291
|
1028 (set-text-properties 0 (length str) nil str)
|
|
14874
|
1029 (setq ffap-string-at-point str)))
|
|
13531
|
1030
|
|
106503
|
1031 (defun ffap-string-around ()
|
|
13531
|
1032 ;; Sometimes useful to decide how to treat a string.
|
|
14874
|
1033 "Return string of two chars around last `ffap-string-at-point'.
|
|
|
1034 Assumes the buffer has not changed."
|
|
13531
|
1035 (save-excursion
|
|
|
1036 (format "%c%c"
|
|
|
1037 (progn
|
|
|
1038 (goto-char (car ffap-string-at-point-region))
|
|
|
1039 (preceding-char)) ; maybe 0
|
|
|
1040 (progn
|
|
|
1041 (goto-char (nth 1 ffap-string-at-point-region))
|
|
|
1042 (following-char)) ; maybe 0
|
|
|
1043 )))
|
|
|
1044
|
|
14874
|
1045 (defun ffap-copy-string-as-kill (&optional mode)
|
|
|
1046 ;; Requested by MCOOK. Useful?
|
|
|
1047 "Call `ffap-string-at-point', and copy result to `kill-ring'."
|
|
|
1048 (interactive)
|
|
|
1049 (let ((str (ffap-string-at-point mode)))
|
|
|
1050 (if (equal "" str)
|
|
|
1051 (message "No string found around point.")
|
|
|
1052 (kill-new str)
|
|
|
1053 ;; Older: (apply 'copy-region-as-kill ffap-string-at-point-region)
|
|
|
1054 (message "Copied to kill ring: %s" str))))
|
|
|
1055
|
|
86479
|
1056 ;; External.
|
|
86812
|
1057 (declare-function w3-view-this-url "ext:w3" (&optional no-show))
|
|
86479
|
1058
|
|
106503
|
1059 (defun ffap-url-at-point ()
|
|
14874
|
1060 "Return url from around point if it exists, or nil."
|
|
|
1061 ;; Could use w3's url-get-url-at-point instead. Both handle "URL:",
|
|
|
1062 ;; ignore non-relative links, trim punctuation. The other will
|
|
|
1063 ;; actually look back if point is in whitespace, but I would rather
|
|
18291
|
1064 ;; ffap be less aggressive in such situations.
|
|
13531
|
1065 (and
|
|
|
1066 ffap-url-regexp
|
|
|
1067 (or
|
|
18291
|
1068 ;; In a w3 buffer button?
|
|
|
1069 (and (eq major-mode 'w3-mode)
|
|
|
1070 ;; interface recommended by wmperry:
|
|
|
1071 (w3-view-this-url t))
|
|
13531
|
1072 ;; Is there a reason not to strip trailing colon?
|
|
14874
|
1073 (let ((name (ffap-string-at-point 'url)))
|
|
13531
|
1074 (cond
|
|
|
1075 ((string-match "^url:" name) (setq name (substring name 4)))
|
75189
c456d15d23fd
(ffap-next-regexp, ffap-machine-p, ffap-newsgroup-regexp)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1076 ((and (string-match "\\`[^:</>@]+@[^:</>@]+[[:alnum:]]\\'" name)
|
|
13531
|
1077 ;; "foo@bar": could be "mailto" or "news" (a Message-ID).
|
|
18291
|
1078 ;; Without "<>" it must be "mailto". Otherwise could be
|
|
|
1079 ;; either, so consult `ffap-foo-at-bar-prefix'.
|
|
13531
|
1080 (let ((prefix (if (and (equal (ffap-string-around) "<>")
|
|
18291
|
1081 ;; Expect some odd characters:
|
|
13531
|
1082 (string-match "[$.0-9].*[$.0-9].*@" name))
|
|
|
1083 ;; Could be news:
|
|
14874
|
1084 ffap-foo-at-bar-prefix
|
|
13531
|
1085 "mailto")))
|
|
|
1086 (and prefix (setq name (concat prefix ":" name))))))
|
|
|
1087 ((ffap-newsgroup-p name) (setq name (concat "news:" name)))
|
75189
c456d15d23fd
(ffap-next-regexp, ffap-machine-p, ffap-newsgroup-regexp)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1088 ((and (string-match "\\`[[:alnum:]]+\\'" name) ; <mic> <root> <nobody>
|
|
13531
|
1089 (equal (ffap-string-around) "<>")
|
|
|
1090 ;; (ffap-user-p name):
|
|
|
1091 (not (string-match "~" (expand-file-name (concat "~" name))))
|
|
|
1092 )
|
|
|
1093 (setq name (concat "mailto:" name)))
|
|
|
1094 )
|
|
|
1095 (and (ffap-url-p name) name)
|
|
|
1096 ))))
|
|
|
1097
|
|
|
1098 (defvar ffap-gopher-regexp
|
|
|
1099 "^.*\\<\\(Type\\|Name\\|Path\\|Host\\|Port\\) *= *\\(.*\\) *$"
|
|
|
1100 "Regexp Matching a line in a gopher bookmark (maybe indented).
|
|
14874
|
1101 The two subexpressions are the KEY and VALUE.")
|
|
13531
|
1102
|
|
106503
|
1103 (defun ffap-gopher-at-point ()
|
|
13531
|
1104 "If point is inside a gopher bookmark block, return its url."
|
|
14874
|
1105 ;; `gopher-parse-bookmark' from gopher.el is not so robust
|
|
13531
|
1106 (save-excursion
|
|
|
1107 (beginning-of-line)
|
|
|
1108 (if (looking-at ffap-gopher-regexp)
|
|
|
1109 (progn
|
|
|
1110 (while (and (looking-at ffap-gopher-regexp) (not (bobp)))
|
|
|
1111 (forward-line -1))
|
|
|
1112 (or (looking-at ffap-gopher-regexp) (forward-line 1))
|
|
106503
|
1113 (let ((type "1") path host (port "70"))
|
|
13531
|
1114 (while (looking-at ffap-gopher-regexp)
|
|
|
1115 (let ((var (intern
|
|
|
1116 (downcase
|
|
|
1117 (buffer-substring (match-beginning 1)
|
|
|
1118 (match-end 1)))))
|
|
|
1119 (val (buffer-substring (match-beginning 2)
|
|
|
1120 (match-end 2))))
|
|
|
1121 (set var val)
|
|
|
1122 (forward-line 1)))
|
|
|
1123 (if (and path (string-match "^ftp:.*@" path))
|
|
|
1124 (concat "ftp://"
|
|
|
1125 (substring path 4 (1- (match-end 0)))
|
|
|
1126 (substring path (match-end 0)))
|
|
|
1127 (and (= (length type) 1)
|
|
|
1128 host;; (ffap-machine-p host)
|
|
|
1129 (concat "gopher://" host
|
|
|
1130 (if (equal port "70") "" (concat ":" port))
|
|
|
1131 "/" type path))))))))
|
|
|
1132
|
|
|
1133 (defvar ffap-ftp-sans-slash-regexp
|
|
|
1134 (and
|
|
|
1135 ffap-ftp-regexp
|
|
14874
|
1136 ;; Note: by now, we know it is not an url.
|
|
13531
|
1137 ;; Icky regexp avoids: default: 123: foo::bar cs:pub
|
|
|
1138 ;; It does match on: mic@cs: cs:/pub mathcs.emory.edu: (point at end)
|
|
|
1139 "\\`\\([^:@]+@[^:@]+:\\|[^@.:]+\\.[^@:]+:\\|[^:]+:[~/]\\)\\([^:]\\|\\'\\)")
|
|
49808
|
1140 "Strings matching this are coerced to ftp file names by ffap.
|
|
13531
|
1141 That is, ffap just prepends \"/\". Set to nil to disable.")
|
|
|
1142
|
|
106503
|
1143 (defun ffap-file-at-point ()
|
|
13531
|
1144 "Return filename from around point if it exists, or nil.
|
|
|
1145 Existence test is skipped for names that look remote.
|
|
|
1146 If the filename is not obvious, it also tries `ffap-alist',
|
|
14874
|
1147 which may actually result in an url rather than a filename."
|
|
|
1148 ;; Note: this function does not need to look for url's, just
|
|
13531
|
1149 ;; filenames. On the other hand, it is responsible for converting
|
|
49808
|
1150 ;; a pseudo-url "site.com://dir" to an ftp file name
|
|
13531
|
1151 (let* ((case-fold-search t) ; url prefixes are case-insensitive
|
|
|
1152 (data (match-data))
|
|
14874
|
1153 (string (ffap-string-at-point)) ; uses mode alist
|
|
13531
|
1154 (name
|
|
14874
|
1155 (or (condition-case nil
|
|
|
1156 (and (not (string-match "//" string)) ; foo.com://bar
|
|
|
1157 (substitute-in-file-name string))
|
|
|
1158 (error nil))
|
|
|
1159 string))
|
|
13531
|
1160 (abs (file-name-absolute-p name))
|
|
77014
|
1161 (default-directory default-directory)
|
|
|
1162 (oname name))
|
|
13531
|
1163 (unwind-protect
|
|
|
1164 (cond
|
|
58923
|
1165 ;; Immediate rejects (/ and // and /* are too common in C/C++):
|
|
|
1166 ((member name '("" "/" "//" "/*" ".")) nil)
|
|
24312
|
1167 ;; Immediately test local filenames. If default-directory is
|
|
|
1168 ;; remote, you probably already have a connection.
|
|
|
1169 ((and (not abs) (ffap-file-exists-string name)))
|
|
|
1170 ;; Try stripping off line numbers; good for compilation/grep output.
|
|
|
1171 ((and (not abs) (string-match ":[0-9]" name)
|
|
|
1172 (ffap-file-exists-string (substring name 0 (match-beginning 0)))))
|
52672
d4d213cfb340
whitespace.el now takes user customizable variable to display cleanliness of
Rajesh Vaidheeswarran <rv@gnu.org>
diff
changeset
|
1173 ;; Try stripping off prominent (non-root - #) shell prompts
|
d4d213cfb340
whitespace.el now takes user customizable variable to display cleanliness of
Rajesh Vaidheeswarran <rv@gnu.org>
diff
changeset
|
1174 ;; if the ffap-shell-prompt-regexp is non-nil.
|
d4d213cfb340
whitespace.el now takes user customizable variable to display cleanliness of
Rajesh Vaidheeswarran <rv@gnu.org>
diff
changeset
|
1175 ((and ffap-shell-prompt-regexp
|
d4d213cfb340
whitespace.el now takes user customizable variable to display cleanliness of
Rajesh Vaidheeswarran <rv@gnu.org>
diff
changeset
|
1176 (not abs) (string-match ffap-shell-prompt-regexp name)
|
d4d213cfb340
whitespace.el now takes user customizable variable to display cleanliness of
Rajesh Vaidheeswarran <rv@gnu.org>
diff
changeset
|
1177 (ffap-file-exists-string (substring name (match-end 0)))))
|
|
13531
|
1178 ;; Accept remote names without actual checking (too slow):
|
|
77014
|
1179 ((and abs (ffap-file-remote-p name)))
|
|
13531
|
1180 ;; Ok, not remote, try the existence test even if it is absolute:
|
|
|
1181 ((and abs (ffap-file-exists-string name)))
|
|
104886
|
1182 ;; Try stripping off line numbers.
|
|
|
1183 ((and abs (string-match ":[0-9]" name)
|
|
|
1184 (ffap-file-exists-string (substring name 0 (match-beginning 0)))))
|
|
14874
|
1185 ;; If it contains a colon, get rid of it (and return if exists)
|
|
|
1186 ((and (string-match path-separator name)
|
|
|
1187 (setq name (ffap-string-at-point 'nocolon))
|
|
|
1188 (ffap-file-exists-string name)))
|
|
13531
|
1189 ;; File does not exist, try the alist:
|
|
|
1190 ((let ((alist ffap-alist) tem try case-fold-search)
|
|
|
1191 (while (and alist (not try))
|
|
|
1192 (setq tem (car alist) alist (cdr alist))
|
|
|
1193 (if (or (eq major-mode (car tem))
|
|
|
1194 (and (stringp (car tem))
|
|
|
1195 (string-match (car tem) name)))
|
|
18291
|
1196 (and (setq try
|
|
|
1197 (condition-case nil
|
|
|
1198 (funcall (cdr tem) name)
|
|
|
1199 (error nil)))
|
|
13531
|
1200 (setq try (or
|
|
|
1201 (ffap-url-p try) ; not a file!
|
|
|
1202 (ffap-file-remote-p try)
|
|
|
1203 (ffap-file-exists-string try))))))
|
|
|
1204 try))
|
|
77014
|
1205 ;; Try adding a leading "/" (common omission in ftp file names).
|
|
|
1206 ;; Note that this uses oname, which still has any colon part.
|
|
|
1207 ;; This should have a lower priority than the alist stuff,
|
|
|
1208 ;; else it matches things like "ffap.el:1234:56:Warning".
|
|
|
1209 ((and (not abs)
|
|
|
1210 ffap-ftp-sans-slash-regexp
|
|
|
1211 (string-match ffap-ftp-sans-slash-regexp oname)
|
|
|
1212 (ffap-file-remote-p (concat "/" oname))))
|
|
13531
|
1213 ;; Alist failed? Try to guess an active remote connection
|
|
|
1214 ;; from buffer variables, and try once more, both as an
|
|
49808
|
1215 ;; absolute and relative file name on that remote host.
|
|
13531
|
1216 ((let* (ffap-rfs-regexp ; suppress
|
|
|
1217 (remote-dir
|
|
|
1218 (cond
|
|
|
1219 ((ffap-file-remote-p default-directory))
|
|
|
1220 ((and (eq major-mode 'internal-ange-ftp-mode)
|
|
|
1221 (string-match "^\\*ftp \\(.*\\)@\\(.*\\)\\*$"
|
|
|
1222 (buffer-name)))
|
|
|
1223 (concat "/" (substring (buffer-name) 5 -1) ":"))
|
|
|
1224 ;; This is too often a bad idea:
|
|
|
1225 ;;((and (eq major-mode 'w3-mode)
|
|
|
1226 ;; (stringp url-current-server))
|
|
|
1227 ;; (host-to-ange-path url-current-server))
|
|
|
1228 )))
|
|
|
1229 (and remote-dir
|
|
|
1230 (or
|
|
|
1231 (and (string-match "\\`\\(/?~?ftp\\)/" name)
|
|
|
1232 (ffap-file-exists-string
|
|
49808
|
1233 (ffap-replace-file-component
|
|
13531
|
1234 remote-dir (substring name (match-end 1)))))
|
|
|
1235 (ffap-file-exists-string
|
|
49808
|
1236 (ffap-replace-file-component remote-dir name))))))
|
|
58923
|
1237 ((and ffap-dired-wildcards
|
|
|
1238 (string-match ffap-dired-wildcards name)
|
|
|
1239 abs
|
|
|
1240 (ffap-file-exists-string (file-name-directory
|
|
|
1241 (directory-file-name name)))
|
|
|
1242 name))
|
|
54106
|
1243 ;; Try all parent directories by deleting the trailing directory
|
|
|
1244 ;; name until existing directory is found or name stops changing
|
|
|
1245 ((let ((dir name))
|
|
|
1246 (while (and dir
|
|
|
1247 (not (ffap-file-exists-string dir))
|
|
|
1248 (not (equal dir (setq dir (file-name-directory
|
|
|
1249 (directory-file-name dir)))))))
|
|
|
1250 (ffap-file-exists-string dir)))
|
|
13531
|
1251 )
|
|
21155
|
1252 (set-match-data data))))
|
|
13531
|
1253
|
|
18291
|
1254 ;;; Prompting (`ffap-read-file-or-url'):
|
|
13531
|
1255 ;;
|
|
14874
|
1256 ;; We want to complete filenames as in read-file-name, but also url's
|
|
|
1257 ;; which read-file-name-internal would truncate at the "//" string.
|
|
|
1258 ;; The solution here is to replace read-file-name-internal with
|
|
|
1259 ;; `ffap-read-file-or-url-internal', which checks the minibuffer
|
|
|
1260 ;; contents before attempting to complete filenames.
|
|
13531
|
1261
|
|
|
1262 (defun ffap-read-file-or-url (prompt guess)
|
|
14874
|
1263 "Read file or url from minibuffer, with PROMPT and initial GUESS."
|
|
13531
|
1264 (or guess (setq guess default-directory))
|
|
14874
|
1265 (let (dir)
|
|
13531
|
1266 ;; Tricky: guess may have or be a local directory, like "w3/w3.elc"
|
|
|
1267 ;; or "w3/" or "../el/ffap.el" or "../../../"
|
|
14874
|
1268 (or (ffap-url-p guess)
|
|
13531
|
1269 (progn
|
|
|
1270 (or (ffap-file-remote-p guess)
|
|
18486
|
1271 (setq guess
|
|
|
1272 (abbreviate-file-name (expand-file-name guess))
|
|
|
1273 ))
|
|
13531
|
1274 (setq dir (file-name-directory guess))))
|
69009
3fe40c860c66
(ffap-read-file-or-url): Bind `completion-ignore-case' to value of
John Paul Wallington <jpw@pobox.com>
diff
changeset
|
1275 (let ((minibuffer-completing-file-name t)
|
|
79697
|
1276 (completion-ignore-case read-file-name-completion-ignore-case)
|
87653
3091cbee6fd8
(ffap-read-file-or-url): Don't use let-binding to temporarily
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1277 (fnh-elem (cons ffap-url-regexp 'url-file-handler)))
|
3091cbee6fd8
(ffap-read-file-or-url): Don't use let-binding to temporarily
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1278 ;; Explain to `rfn-eshadow' that we can use URLs here.
|
3091cbee6fd8
(ffap-read-file-or-url): Don't use let-binding to temporarily
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1279 (push fnh-elem file-name-handler-alist)
|
3091cbee6fd8
(ffap-read-file-or-url): Don't use let-binding to temporarily
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1280 (unwind-protect
|
3091cbee6fd8
(ffap-read-file-or-url): Don't use let-binding to temporarily
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1281 (setq guess
|
94217
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1282 (let ((default-directory (if dir (expand-file-name dir)
|
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1283 default-directory)))
|
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1284 (completing-read
|
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1285 prompt
|
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1286 'ffap-read-file-or-url-internal
|
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1287 nil
|
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1288 nil
|
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1289 (if dir (cons guess (length dir)) guess)
|
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1290 (list 'file-name-history)
|
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1291 (and buffer-file-name
|
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1292 (abbreviate-file-name buffer-file-name)))))
|
87653
3091cbee6fd8
(ffap-read-file-or-url): Don't use let-binding to temporarily
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1293 ;; Remove the special handler manually. We used to just let-bind
|
3091cbee6fd8
(ffap-read-file-or-url): Don't use let-binding to temporarily
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1294 ;; file-name-handler-alist to preserve its value, but that caused
|
3091cbee6fd8
(ffap-read-file-or-url): Don't use let-binding to temporarily
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1295 ;; other modifications to be lost (e.g. when Tramp gets loaded
|
3091cbee6fd8
(ffap-read-file-or-url): Don't use let-binding to temporarily
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1296 ;; during the completing-read call).
|
3091cbee6fd8
(ffap-read-file-or-url): Don't use let-binding to temporarily
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1297 (setq file-name-handler-alist (delq fnh-elem file-name-handler-alist))))
|
|
14874
|
1298 ;; Do file substitution like (interactive "F"), suggested by MCOOK.
|
|
|
1299 (or (ffap-url-p guess) (setq guess (substitute-in-file-name guess)))
|
|
|
1300 ;; Should not do it on url's, where $ is a common (VMS?) character.
|
|
|
1301 ;; Note: upcoming url.el package ought to handle this automatically.
|
|
|
1302 guess))
|
|
13531
|
1303
|
94217
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1304 (defun ffap-read-url-internal (string pred action)
|
|
14874
|
1305 "Complete url's from history, treating given string as valid."
|
|
106503
|
1306 (let ((hist (ffap-symbol-value 'url-global-history-hash-table)))
|
|
13531
|
1307 (cond
|
|
|
1308 ((not action)
|
94217
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1309 (or (try-completion string hist pred) string))
|
|
13531
|
1310 ((eq action t)
|
94217
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1311 (or (all-completions string hist pred) (list string)))
|
|
14874
|
1312 ;; action == lambda, documented where? Tests whether string is a
|
|
|
1313 ;; valid "match". Let us always say yes.
|
|
|
1314 (t t))))
|
|
13531
|
1315
|
94217
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1316 (defun ffap-read-file-or-url-internal (string pred action)
|
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1317 (unless string ;Why would this ever happen?
|
|
30687
|
1318 (setq string default-directory))
|
|
13531
|
1319 (if (ffap-url-p string)
|
94217
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1320 (ffap-read-url-internal string pred action)
|
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1321 (read-file-name-internal string pred action)))
|
|
13531
|
1322
|
|
14874
|
1323 ;; The rest of this page is just to work with package complete.el.
|
|
|
1324 ;; This code assumes that you load ffap.el after complete.el.
|
|
|
1325 ;;
|
|
|
1326 ;; We must inform complete about whether our completion function
|
|
52731
|
1327 ;; will do filename style completion.
|
|
14874
|
1328
|
|
106503
|
1329 (defun ffap-complete-as-file-p ()
|
|
14874
|
1330 ;; Will `minibuffer-completion-table' complete the minibuffer
|
|
|
1331 ;; contents as a filename? Assumes the minibuffer is current.
|
|
|
1332 ;; Note: t and non-nil mean somewhat different reasons.
|
|
|
1333 (if (eq minibuffer-completion-table 'ffap-read-file-or-url-internal)
|
|
|
1334 (not (ffap-url-p (buffer-string))) ; t
|
49694
3738a81ff66f
(ffap-complete-as-file-p): Use minibuffer-completing-file-name.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1335 (and minibuffer-completing-file-name '(t)))) ;list
|
|
14874
|
1336
|
|
13531
|
1337 (and
|
|
|
1338 (featurep 'complete)
|
|
14874
|
1339 (if (boundp 'PC-completion-as-file-name-predicate)
|
|
|
1340 ;; modern version of complete.el, just set the variable:
|
|
52731
|
1341 (setq PC-completion-as-file-name-predicate 'ffap-complete-as-file-p)))
|
|
13531
|
1342
|
|
|
1343
|
|
18291
|
1344 ;;; Highlighting (`ffap-highlight'):
|
|
13531
|
1345 ;;
|
|
|
1346 ;; Based on overlay highlighting in Emacs 19.28 isearch.el.
|
|
|
1347
|
|
29203
|
1348 (defvar ffap-highlight t
|
|
13531
|
1349 "If non-nil, ffap highlights the current buffer substring.")
|
|
|
1350
|
|
68982
|
1351 (defface ffap
|
|
|
1352 '((t :inherit highlight))
|
|
|
1353 "Face used to highlight the current buffer substring."
|
|
|
1354 :group 'ffap
|
|
|
1355 :version "22.1")
|
|
|
1356
|
|
18291
|
1357 (defvar ffap-highlight-overlay nil
|
|
|
1358 "Overlay used by `ffap-highlight'.")
|
|
13531
|
1359
|
|
|
1360 (defun ffap-highlight (&optional remove)
|
|
14874
|
1361 "If `ffap-highlight' is set, highlight the guess in this buffer.
|
|
|
1362 That is, the last buffer substring found by `ffap-string-at-point'.
|
|
13531
|
1363 Optional argument REMOVE means to remove any such highlighting.
|
|
14874
|
1364 Uses the face `ffap' if it is defined, or else `highlight'."
|
|
13531
|
1365 (cond
|
|
18291
|
1366 (remove
|
|
|
1367 (and ffap-highlight-overlay
|
|
18486
|
1368 (delete-overlay ffap-highlight-overlay))
|
|
|
1369 )
|
|
13531
|
1370 ((not ffap-highlight) nil)
|
|
14874
|
1371 (ffap-highlight-overlay
|
|
18486
|
1372 (move-overlay
|
|
|
1373 ffap-highlight-overlay
|
|
|
1374 (car ffap-string-at-point-region)
|
|
|
1375 (nth 1 ffap-string-at-point-region)
|
|
|
1376 (current-buffer)))
|
|
13531
|
1377 (t
|
|
18291
|
1378 (setq ffap-highlight-overlay
|
|
18486
|
1379 (apply 'make-overlay ffap-string-at-point-region))
|
|
68982
|
1380 (overlay-put ffap-highlight-overlay 'face 'ffap))))
|
|
14874
|
1381
|
|
13531
|
1382
|
|
18486
|
1383 ;;; Main Entrance (`find-file-at-point' == `ffap'):
|
|
13531
|
1384
|
|
106503
|
1385 (defun ffap-guesser ()
|
|
18291
|
1386 "Return file or URL or nil, guessed from text around point."
|
|
13531
|
1387 (or (and ffap-url-regexp
|
|
|
1388 (ffap-fixup-url (or (ffap-url-at-point)
|
|
|
1389 (ffap-gopher-at-point))))
|
|
|
1390 (ffap-file-at-point) ; may yield url!
|
|
|
1391 (ffap-fixup-machine (ffap-machine-at-point))))
|
|
|
1392
|
|
|
1393 (defun ffap-prompter (&optional guess)
|
|
|
1394 ;; Does guess and prompt step for find-file-at-point.
|
|
14874
|
1395 ;; Extra complication for the temporary highlighting.
|
|
13531
|
1396 (unwind-protect
|
|
18486
|
1397 ;; This catch will let ffap-alist entries do their own prompting
|
|
|
1398 ;; and then maybe skip over this prompt (ff-paths, for example).
|
|
|
1399 (catch 'ffap-prompter
|
|
|
1400 (ffap-read-file-or-url
|
|
|
1401 (if ffap-url-regexp "Find file or URL: " "Find file: ")
|
|
|
1402 (prog1
|
|
95592
|
1403 (let ((mark-active nil))
|
|
|
1404 ;; Don't use the region here, since it can be something
|
|
|
1405 ;; completely unwieldy. If the user wants that, she could
|
|
|
1406 ;; use M-w before and then C-y. --Stef
|
|
|
1407 (setq guess (or guess (ffap-guesser)))) ; using ffap-alist here
|
|
18486
|
1408 (and guess (ffap-highlight))
|
|
|
1409 )))
|
|
13531
|
1410 (ffap-highlight t)))
|
|
|
1411
|
|
|
1412 ;;;###autoload
|
|
|
1413 (defun find-file-at-point (&optional filename)
|
|
18291
|
1414 "Find FILENAME, guessing a default from text around point.
|
|
|
1415 If `ffap-url-regexp' is not nil, the FILENAME may also be an URL.
|
|
|
1416 With a prefix, this command behaves exactly like `ffap-file-finder'.
|
|
13531
|
1417 If `ffap-require-prefix' is set, the prefix meaning is reversed.
|
|
18291
|
1418 See also the variables `ffap-dired-wildcards', `ffap-newfile-prompt',
|
|
66184
|
1419 and the functions `ffap-file-at-point' and `ffap-url-at-point'."
|
|
13531
|
1420 (interactive)
|
|
105372
|
1421 (if (and (called-interactively-p 'interactive)
|
|
13531
|
1422 (if ffap-require-prefix (not current-prefix-arg)
|
|
|
1423 current-prefix-arg))
|
|
|
1424 ;; Do exactly the ffap-file-finder command, even the prompting:
|
|
14874
|
1425 (let (current-prefix-arg) ; we already interpreted it
|
|
|
1426 (call-interactively ffap-file-finder))
|
|
13531
|
1427 (or filename (setq filename (ffap-prompter)))
|
|
|
1428 (cond
|
|
|
1429 ((ffap-url-p filename)
|
|
14874
|
1430 (let (current-prefix-arg) ; w3 2.3.25 bug, reported by KPC
|
|
|
1431 (funcall ffap-url-fetcher filename)))
|
|
61365
|
1432 ((and ffap-pass-wildcards-to-dired
|
|
|
1433 ffap-dired-wildcards
|
|
|
1434 (string-match ffap-dired-wildcards filename))
|
|
|
1435 (funcall ffap-directory-finder filename))
|
|
14874
|
1436 ((and ffap-dired-wildcards
|
|
58923
|
1437 (string-match ffap-dired-wildcards filename)
|
|
|
1438 find-file-wildcards
|
|
|
1439 ;; Check if it's find-file that supports wildcards arg
|
|
|
1440 (memq ffap-file-finder '(find-file find-alternate-file)))
|
|
|
1441 (funcall ffap-file-finder (expand-file-name filename) t))
|
|
13531
|
1442 ((or (not ffap-newfile-prompt)
|
|
|
1443 (file-exists-p filename)
|
|
|
1444 (y-or-n-p "File does not exist, create buffer? "))
|
|
|
1445 (funcall ffap-file-finder
|
|
|
1446 ;; expand-file-name fixes "~/~/.emacs" bug sent by CHUCKR.
|
|
|
1447 (expand-file-name filename)))
|
|
|
1448 ;; User does not want to find a non-existent file:
|
|
|
1449 ((signal 'file-error (list "Opening file buffer"
|
|
|
1450 "no such file or directory"
|
|
|
1451 filename))))))
|
|
|
1452
|
|
18291
|
1453 ;; Shortcut: allow {M-x ffap} rather than {M-x find-file-at-point}.
|
|
45169
|
1454 ;;;###autoload
|
|
|
1455 (defalias 'ffap 'find-file-at-point)
|
|
|
1456
|
|
13531
|
1457
|
|
18291
|
1458 ;;; Menu support (`ffap-menu'):
|
|
13531
|
1459
|
|
|
1460 (defvar ffap-menu-regexp nil
|
|
14874
|
1461 "*If non-nil, overrides `ffap-next-regexp' during `ffap-menu'.
|
|
13531
|
1462 Make this more restrictive for faster menu building.
|
|
18291
|
1463 For example, try \":/\" for URL (and some ftp) references.")
|
|
13531
|
1464
|
|
|
1465 (defvar ffap-menu-alist nil
|
|
14874
|
1466 "Buffer local cache of menu presented by `ffap-menu'.")
|
|
13531
|
1467 (make-variable-buffer-local 'ffap-menu-alist)
|
|
|
1468
|
|
14874
|
1469 (defvar ffap-menu-text-plist
|
|
18486
|
1470 (cond
|
|
29203
|
1471 ((display-mouse-p) '(face bold mouse-face highlight)) ; keymap <mousy-map>
|
|
|
1472 (t nil))
|
|
14874
|
1473 "Text properties applied to strings found by `ffap-menu-rescan'.
|
|
|
1474 These properties may be used to fontify the menu references.")
|
|
|
1475
|
|
13531
|
1476 ;;;###autoload
|
|
|
1477 (defun ffap-menu (&optional rescan)
|
|
14874
|
1478 "Put up a menu of files and urls mentioned in this buffer.
|
|
|
1479 Then set mark, jump to choice, and try to fetch it. The menu is
|
|
|
1480 cached in `ffap-menu-alist', and rebuilt by `ffap-menu-rescan'.
|
|
|
1481 The optional RESCAN argument \(a prefix, interactively\) forces
|
|
|
1482 a rebuild. Searches with `ffap-menu-regexp'."
|
|
13531
|
1483 (interactive "P")
|
|
|
1484 ;; (require 'imenu) -- no longer used, but roughly emulated
|
|
|
1485 (if (or (not ffap-menu-alist) rescan
|
|
|
1486 ;; or if the first entry is wrong:
|
|
|
1487 (and ffap-menu-alist
|
|
|
1488 (let ((first (car ffap-menu-alist)))
|
|
|
1489 (save-excursion
|
|
|
1490 (goto-char (cdr first))
|
|
|
1491 (not (equal (car first) (ffap-guesser)))))))
|
|
|
1492 (ffap-menu-rescan))
|
|
|
1493 ;; Tail recursive:
|
|
|
1494 (ffap-menu-ask
|
|
|
1495 (if ffap-url-regexp "Find file or URL" "Find file")
|
|
|
1496 (cons (cons "*Rescan Buffer*" -1) ffap-menu-alist)
|
|
|
1497 'ffap-menu-cont))
|
|
|
1498
|
|
|
1499 (defun ffap-menu-cont (choice) ; continuation of ffap-menu
|
|
|
1500 (if (< (cdr choice) 0)
|
|
|
1501 (ffap-menu t) ; *Rescan*
|
|
|
1502 (push-mark)
|
|
|
1503 (goto-char (cdr choice))
|
|
|
1504 ;; Momentary highlight:
|
|
|
1505 (unwind-protect
|
|
|
1506 (progn
|
|
|
1507 (and ffap-highlight (ffap-guesser) (ffap-highlight))
|
|
|
1508 (sit-for 0) ; display
|
|
|
1509 (find-file-at-point (car choice)))
|
|
|
1510 (ffap-highlight t))))
|
|
|
1511
|
|
|
1512 (defun ffap-menu-ask (title alist cont)
|
|
|
1513 "Prompt from a menu of choices, and then apply some action.
|
|
18291
|
1514 Arguments are TITLE, ALIST, and CONT \(a continuation function\).
|
|
13531
|
1515 This uses either a menu or the minibuffer depending on invocation.
|
|
|
1516 The TITLE string is used as either the prompt or menu title.
|
|
23352
|
1517 Each ALIST entry looks like (STRING . DATA) and defines one choice.
|
|
18291
|
1518 Function CONT is applied to the entry chosen by the user."
|
|
|
1519 ;; Note: this function is used with a different continuation
|
|
|
1520 ;; by the ffap-url add-on package.
|
|
|
1521 ;; Could try rewriting to use easymenu.el or lmenu.el.
|
|
|
1522 (let (choice)
|
|
|
1523 (cond
|
|
|
1524 ;; Emacs mouse:
|
|
|
1525 ((and (fboundp 'x-popup-menu) (ffap-mouse-event))
|
|
|
1526 (setq choice
|
|
|
1527 (x-popup-menu
|
|
|
1528 t
|
|
|
1529 (list "" (cons title
|
94217
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1530 (mapcar (lambda (i) (cons (car i) i))
|
|
18291
|
1531 alist))))))
|
|
|
1532 ;; minibuffer with completion buffer:
|
|
|
1533 (t
|
|
|
1534 (let ((minibuffer-setup-hook 'minibuffer-completion-help))
|
|
|
1535 ;; Bug: prompting may assume unique strings, no "".
|
|
|
1536 (setq choice
|
|
|
1537 (completing-read
|
|
|
1538 (format "%s (default %s): " title (car (car alist)))
|
|
|
1539 alist nil t
|
|
|
1540 ;; (cons (car (car alist)) 0)
|
|
|
1541 nil)))
|
|
|
1542 (sit-for 0) ; redraw original screen
|
|
|
1543 ;; Convert string to its entry, or else the default:
|
94217
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1544 (setq choice (or (assoc choice alist) (car alist)))))
|
|
18291
|
1545 (if choice
|
|
|
1546 (funcall cont choice)
|
|
|
1547 (message "No choice made!") ; possible with menus
|
|
|
1548 nil)))
|
|
13531
|
1549
|
|
106503
|
1550 (defun ffap-menu-rescan ()
|
|
14874
|
1551 "Search buffer for `ffap-menu-regexp' to build `ffap-menu-alist'.
|
|
|
1552 Applies `ffap-menu-text-plist' text properties at all matches."
|
|
13531
|
1553 (interactive)
|
|
|
1554 (let ((ffap-next-regexp (or ffap-menu-regexp ffap-next-regexp))
|
|
18291
|
1555 (range (- (point-max) (point-min)))
|
|
|
1556 (mod (buffer-modified-p)) ; was buffer modified?
|
|
67010
|
1557 ;; inhibit-read-only works on read-only text properties
|
|
|
1558 ;; as well as read-only buffers.
|
|
|
1559 (inhibit-read-only t) ; to set text-properties
|
|
18291
|
1560 item
|
|
14874
|
1561 ;; Avoid repeated searches of the *mode-alist:
|
|
|
1562 (major-mode (if (assq major-mode ffap-string-at-point-mode-alist)
|
|
|
1563 major-mode
|
|
18291
|
1564 'file)))
|
|
13531
|
1565 (setq ffap-menu-alist nil)
|
|
18291
|
1566 (unwind-protect
|
|
|
1567 (save-excursion
|
|
|
1568 (goto-char (point-min))
|
|
|
1569 (while (setq item (ffap-next-guess))
|
|
|
1570 (setq ffap-menu-alist (cons (cons item (point)) ffap-menu-alist))
|
|
|
1571 (add-text-properties (car ffap-string-at-point-region) (point)
|
|
|
1572 ffap-menu-text-plist)
|
|
|
1573 (message "Scanning...%2d%% <%s>"
|
|
|
1574 (/ (* 100 (- (point) (point-min))) range) item)))
|
94217
3a71d408918b
(ffap-read-file-or-url): Do not abuse completing-read's
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1575 (or mod (restore-buffer-modified-p nil))))
|
|
13531
|
1576 (message "Scanning...done")
|
|
|
1577 ;; Remove duplicates.
|
|
|
1578 (setq ffap-menu-alist ; sort by item
|
|
|
1579 (sort ffap-menu-alist
|
|
|
1580 (function
|
|
|
1581 (lambda (a b) (string-lessp (car a) (car b))))))
|
|
18291
|
1582 (let ((ptr ffap-menu-alist)) ; remove duplicates
|
|
13531
|
1583 (while (cdr ptr)
|
|
|
1584 (if (equal (car (car ptr)) (car (car (cdr ptr))))
|
|
|
1585 (setcdr ptr (cdr (cdr ptr)))
|
|
|
1586 (setq ptr (cdr ptr)))))
|
|
|
1587 (setq ffap-menu-alist ; sort by position
|
|
|
1588 (sort ffap-menu-alist
|
|
|
1589 (function
|
|
|
1590 (lambda (a b) (< (cdr a) (cdr b)))))))
|
|
|
1591
|
|
|
1592
|
|
18291
|
1593 ;;; Mouse Support (`ffap-at-mouse'):
|
|
13531
|
1594 ;;
|
|
14874
|
1595 ;; See the suggested binding in ffap-bindings (near eof).
|
|
13531
|
1596
|
|
18291
|
1597 (defvar ffap-at-mouse-fallback nil ; ffap-menu? too time-consuming
|
|
|
1598 "Command invoked by `ffap-at-mouse' if nothing found at click, or nil.
|
|
|
1599 Ignored when `ffap-at-mouse' is called programmatically.")
|
|
13531
|
1600 (put 'ffap-at-mouse-fallback 'risky-local-variable t)
|
|
|
1601
|
|
18291
|
1602 ;;;###autoload
|
|
13531
|
1603 (defun ffap-at-mouse (e)
|
|
18291
|
1604 "Find file or url guessed from text around mouse click.
|
|
18486
|
1605 Interactively, calls `ffap-at-mouse-fallback' if no guess is found.
|
|
|
1606 Return value:
|
|
|
1607 * if a guess string is found, return it (after finding it)
|
|
|
1608 * if the fallback is called, return whatever it returns
|
|
|
1609 * otherwise, nil"
|
|
13531
|
1610 (interactive "e")
|
|
|
1611 (let ((guess
|
|
|
1612 ;; Maybe less surprising without the save-excursion?
|
|
|
1613 (save-excursion
|
|
|
1614 (mouse-set-point e)
|
|
18291
|
1615 ;; Would prefer to do nothing unless click was *on* text. How
|
|
|
1616 ;; to tell that the click was beyond the end of current line?
|
|
13531
|
1617 (ffap-guesser))))
|
|
|
1618 (cond
|
|
|
1619 (guess
|
|
18291
|
1620 (set-buffer (ffap-event-buffer e))
|
|
13531
|
1621 (ffap-highlight)
|
|
|
1622 (unwind-protect
|
|
|
1623 (progn
|
|
|
1624 (sit-for 0) ; display
|
|
18291
|
1625 (message "Finding `%s'" guess)
|
|
|
1626 (find-file-at-point guess)
|
|
18486
|
1627 guess) ; success: return non-nil
|
|
13531
|
1628 (ffap-highlight t)))
|
|
105372
|
1629 ((called-interactively-p 'interactive)
|
|
18291
|
1630 (if ffap-at-mouse-fallback
|
|
|
1631 (call-interactively ffap-at-mouse-fallback)
|
|
18486
|
1632 (message "No file or url found at mouse click.")
|
|
|
1633 nil)) ; no fallback, return nil
|
|
18291
|
1634 ;; failure: return nil
|
|
|
1635 )))
|
|
13531
|
1636
|
|
|
1637
|
|
58923
|
1638 ;;; ffap-other-*, ffap-read-only-*, ffap-alternate-* commands:
|
|
18291
|
1639
|
|
|
1640 ;; There could be a real `ffap-noselect' function, but we would need
|
|
|
1641 ;; at least two new user variables, and there is no w3-fetch-noselect.
|
|
|
1642 ;; So instead, we just fake it with a slow save-window-excursion.
|
|
13531
|
1643
|
|
106503
|
1644 (defun ffap-other-window ()
|
|
18291
|
1645 "Like `ffap', but put buffer in another window.
|
|
|
1646 Only intended for interactive use."
|
|
13531
|
1647 (interactive)
|
|
58923
|
1648 (let (value)
|
|
|
1649 (switch-to-buffer-other-window
|
|
|
1650 (save-window-excursion
|
|
|
1651 (setq value (call-interactively 'ffap))
|
|
|
1652 (unless (or (bufferp value) (bufferp (car-safe value)))
|
|
|
1653 (setq value (current-buffer)))
|
|
|
1654 (current-buffer)))
|
|
|
1655 value))
|
|
13531
|
1656
|
|
106503
|
1657 (defun ffap-other-frame ()
|
|
18291
|
1658 "Like `ffap', but put buffer in another frame.
|
|
|
1659 Only intended for interactive use."
|
|
13531
|
1660 (interactive)
|
|
18291
|
1661 ;; Extra code works around dedicated windows (noted by JENS, 7/96):
|
|
58923
|
1662 (let* ((win (selected-window))
|
|
|
1663 (wdp (window-dedicated-p win))
|
|
|
1664 value)
|
|
18291
|
1665 (unwind-protect
|
|
|
1666 (progn
|
|
|
1667 (set-window-dedicated-p win nil)
|
|
|
1668 (switch-to-buffer-other-frame
|
|
|
1669 (save-window-excursion
|
|
58923
|
1670 (setq value (call-interactively 'ffap))
|
|
|
1671 (unless (or (bufferp value) (bufferp (car-safe value)))
|
|
|
1672 (setq value (current-buffer)))
|
|
18291
|
1673 (current-buffer))))
|
|
58923
|
1674 (set-window-dedicated-p win wdp))
|
|
|
1675 value))
|
|
|
1676
|
|
|
1677 (defun ffap-read-only ()
|
|
|
1678 "Like `ffap', but mark buffer as read-only.
|
|
|
1679 Only intended for interactive use."
|
|
|
1680 (interactive)
|
|
|
1681 (let ((value (call-interactively 'ffap)))
|
|
|
1682 (unless (or (bufferp value) (bufferp (car-safe value)))
|
|
|
1683 (setq value (current-buffer)))
|
|
|
1684 (mapc (lambda (b) (with-current-buffer b (toggle-read-only 1)))
|
|
|
1685 (if (listp value) value (list value)))
|
|
|
1686 value))
|
|
|
1687
|
|
|
1688 (defun ffap-read-only-other-window ()
|
|
|
1689 "Like `ffap', but put buffer in another window and mark as read-only.
|
|
|
1690 Only intended for interactive use."
|
|
|
1691 (interactive)
|
|
|
1692 (let ((value (ffap-other-window)))
|
|
|
1693 (mapc (lambda (b) (with-current-buffer b (toggle-read-only 1)))
|
|
|
1694 (if (listp value) value (list value)))
|
|
|
1695 value))
|
|
|
1696
|
|
|
1697 (defun ffap-read-only-other-frame ()
|
|
|
1698 "Like `ffap', but put buffer in another frame and mark as read-only.
|
|
|
1699 Only intended for interactive use."
|
|
|
1700 (interactive)
|
|
|
1701 (let ((value (ffap-other-frame)))
|
|
|
1702 (mapc (lambda (b) (with-current-buffer b (toggle-read-only 1)))
|
|
|
1703 (if (listp value) value (list value)))
|
|
|
1704 value))
|
|
|
1705
|
|
|
1706 (defun ffap-alternate-file ()
|
|
|
1707 "Like `ffap' and `find-alternate-file'.
|
|
|
1708 Only intended for interactive use."
|
|
|
1709 (interactive)
|
|
|
1710 (let ((ffap-file-finder 'find-alternate-file))
|
|
|
1711 (call-interactively 'ffap)))
|
|
13531
|
1712
|
|
105966
|
1713 (defun ffap-alternate-file-other-window ()
|
|
|
1714 "Like `ffap' and `find-alternate-file-other-window'.
|
|
|
1715 Only intended for interactive use."
|
|
|
1716 (interactive)
|
|
|
1717 (let ((ffap-file-finder 'find-alternate-file-other-window))
|
|
|
1718 (call-interactively 'ffap)))
|
|
|
1719
|
|
|
1720 (defun ffap-literally ()
|
|
|
1721 "Like `ffap' and `find-file-literally'.
|
|
|
1722 Only intended for interactive use."
|
|
|
1723 (interactive)
|
|
|
1724 (let ((ffap-file-finder 'find-file-literally))
|
|
|
1725 (call-interactively 'ffap)))
|
|
|
1726
|
|
|
1727 (defalias 'find-file-literally-at-point 'ffap-literally)
|
|
|
1728
|
|
13531
|
1729
|
|
14874
|
1730 ;;; Bug Reporter:
|
|
|
1731
|
|
86479
|
1732 (define-obsolete-function-alias 'ffap-bug 'report-emacs-bug "23.1")
|
|
|
1733 (define-obsolete-function-alias 'ffap-submit-bug 'report-emacs-bug "23.1")
|
|
13531
|
1734
|
|
|
1735
|
|
14874
|
1736 ;;; Hooks for Gnus, VM, Rmail:
|
|
13531
|
1737 ;;
|
|
14874
|
1738 ;; If you do not like these bindings, write versions with whatever
|
|
|
1739 ;; bindings you would prefer.
|
|
|
1740
|
|
106503
|
1741 (defun ffap-ro-mode-hook ()
|
|
14874
|
1742 "Bind `ffap-next' and `ffap-menu' to M-l and M-m, resp."
|
|
|
1743 (local-set-key "\M-l" 'ffap-next)
|
|
|
1744 (local-set-key "\M-m" 'ffap-menu)
|
|
|
1745 )
|
|
|
1746
|
|
106503
|
1747 (defun ffap-gnus-hook ()
|
|
14874
|
1748 "Bind `ffap-gnus-next' and `ffap-gnus-menu' to M-l and M-m, resp."
|
|
|
1749 (set (make-local-variable 'ffap-foo-at-bar-prefix) "news") ; message-id's
|
|
|
1750 ;; Note "l", "L", "m", "M" are taken:
|
|
|
1751 (local-set-key "\M-l" 'ffap-gnus-next)
|
|
|
1752 (local-set-key "\M-m" 'ffap-gnus-menu))
|
|
|
1753
|
|
64797
|
1754 (defvar gnus-summary-buffer)
|
|
|
1755 (defvar gnus-article-buffer)
|
|
|
1756
|
|
86479
|
1757 ;; This code is called from gnus.
|
|
|
1758 (declare-function gnus-summary-select-article "gnus-sum"
|
|
|
1759 (&optional all-headers force pseudo article))
|
|
|
1760
|
|
|
1761 (declare-function gnus-configure-windows "gnus-win"
|
|
|
1762 (setting &optional force))
|
|
|
1763
|
|
14874
|
1764 (defun ffap-gnus-wrapper (form) ; used by both commands below
|
|
|
1765 (and (eq (current-buffer) (get-buffer gnus-summary-buffer))
|
|
|
1766 (gnus-summary-select-article)) ; get article of current line
|
|
|
1767 ;; Preserve selected buffer, but do not do save-window-excursion,
|
|
|
1768 ;; since we want to see any window created by the form. Temporarily
|
|
|
1769 ;; select the article buffer, so we can see any point movement.
|
|
|
1770 (let ((sb (window-buffer (selected-window))))
|
|
|
1771 (gnus-configure-windows 'article)
|
|
|
1772 (pop-to-buffer gnus-article-buffer)
|
|
|
1773 (widen)
|
|
|
1774 ;; Skip headers for ffap-gnus-next (which will wrap around)
|
|
|
1775 (if (eq (point) (point-min)) (search-forward "\n\n" nil t))
|
|
|
1776 (unwind-protect
|
|
|
1777 (eval form)
|
|
|
1778 (pop-to-buffer sb))))
|
|
|
1779
|
|
106503
|
1780 (defun ffap-gnus-next ()
|
|
14874
|
1781 "Run `ffap-next' in the gnus article buffer."
|
|
|
1782 (interactive) (ffap-gnus-wrapper '(ffap-next nil t)))
|
|
|
1783
|
|
106503
|
1784 (defun ffap-gnus-menu ()
|
|
14874
|
1785 "Run `ffap-menu' in the gnus article buffer."
|
|
|
1786 (interactive) (ffap-gnus-wrapper '(ffap-menu)))
|
|
|
1787
|
|
|
1788
|
|
21815
|
1789 (defcustom dired-at-point-require-prefix nil
|
|
100171
|
1790 "If set, reverses the prefix argument to `dired-at-point'.
|
|
21815
|
1791 This is nil so neophytes notice ffap. Experts may prefer to disable
|
|
|
1792 ffap most of the time."
|
|
|
1793 :type 'boolean
|
|
|
1794 :group 'ffap
|
|
|
1795 :version "20.3")
|
|
|
1796
|
|
|
1797 ;;;###autoload
|
|
|
1798 (defun dired-at-point (&optional filename)
|
|
|
1799 "Start Dired, defaulting to file at point. See `ffap'."
|
|
|
1800 (interactive)
|
|
105372
|
1801 (if (and (called-interactively-p 'interactive)
|
|
21815
|
1802 (if dired-at-point-require-prefix
|
|
|
1803 (not current-prefix-arg)
|
|
|
1804 current-prefix-arg))
|
|
|
1805 (let (current-prefix-arg) ; already interpreted
|
|
58923
|
1806 (call-interactively ffap-directory-finder))
|
|
21815
|
1807 (or filename (setq filename (dired-at-point-prompter)))
|
|
|
1808 (cond
|
|
|
1809 ((ffap-url-p filename)
|
|
|
1810 (funcall ffap-url-fetcher filename))
|
|
|
1811 ((and ffap-dired-wildcards
|
|
|
1812 (string-match ffap-dired-wildcards filename))
|
|
58923
|
1813 (funcall ffap-directory-finder filename))
|
|
21815
|
1814 ((file-exists-p filename)
|
|
|
1815 (if (file-directory-p filename)
|
|
58923
|
1816 (funcall ffap-directory-finder
|
|
|
1817 (expand-file-name filename))
|
|
|
1818 (funcall ffap-directory-finder
|
|
|
1819 (concat (expand-file-name filename) "*"))))
|
54183
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1820 ((and (file-writable-p
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1821 (or (file-name-directory (directory-file-name filename))
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1822 filename))
|
50042
5e493709a8ef
(dired-at-point): Check whether the user can create a directory before asking
Juanma Barranquero <lekktu@gmail.com>
diff
changeset
|
1823 (y-or-n-p "Directory does not exist, create it? "))
|
|
21815
|
1824 (make-directory filename)
|
|
58923
|
1825 (funcall ffap-directory-finder filename))
|
|
21815
|
1826 ((error "No such file or directory `%s'" filename)))))
|
|
|
1827
|
|
|
1828 (defun dired-at-point-prompter (&optional guess)
|
|
|
1829 ;; Does guess and prompt step for find-file-at-point.
|
|
|
1830 ;; Extra complication for the temporary highlighting.
|
|
|
1831 (unwind-protect
|
|
|
1832 (ffap-read-file-or-url
|
|
81680
|
1833 (cond
|
|
|
1834 ((eq ffap-directory-finder 'list-directory)
|
|
|
1835 "List directory (brief): ")
|
|
|
1836 (ffap-url-regexp "Dired file or URL: ")
|
|
|
1837 (t "Dired file: "))
|
|
21815
|
1838 (prog1
|
54183
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1839 (setq guess (or guess
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1840 (let ((guess (ffap-guesser)))
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1841 (if (or (not guess)
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1842 (ffap-url-p guess)
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1843 (ffap-file-remote-p guess))
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1844 guess
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1845 (setq guess (abbreviate-file-name
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1846 (expand-file-name guess)))
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1847 (cond
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1848 ;; Interpret local directory as a directory.
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1849 ((file-directory-p guess)
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1850 (file-name-as-directory guess))
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1851 ;; Get directory component from local files.
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1852 ((file-regular-p guess)
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1853 (file-name-directory guess))
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1854 (guess))))
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1855 ))
|
b91c8ab75b81
(dired-at-point): Additional writability test for relative directory names.
Juri Linkov <juri@jurta.org>
diff
changeset
|
1856 (and guess (ffap-highlight))))
|
|
21815
|
1857 (ffap-highlight t)))
|
|
|
1858
|
|
58923
|
1859 ;;; ffap-dired-other-*, ffap-list-directory commands:
|
|
|
1860
|
|
|
1861 (defun ffap-dired-other-window ()
|
|
|
1862 "Like `dired-at-point', but put buffer in another window.
|
|
|
1863 Only intended for interactive use."
|
|
|
1864 (interactive)
|
|
|
1865 (let (value)
|
|
|
1866 (switch-to-buffer-other-window
|
|
|
1867 (save-window-excursion
|
|
|
1868 (setq value (call-interactively 'dired-at-point))
|
|
|
1869 (current-buffer)))
|
|
|
1870 value))
|
|
|
1871
|
|
|
1872 (defun ffap-dired-other-frame ()
|
|
|
1873 "Like `dired-at-point', but put buffer in another frame.
|
|
|
1874 Only intended for interactive use."
|
|
|
1875 (interactive)
|
|
|
1876 ;; Extra code works around dedicated windows (noted by JENS, 7/96):
|
|
|
1877 (let* ((win (selected-window))
|
|
|
1878 (wdp (window-dedicated-p win))
|
|
|
1879 value)
|
|
|
1880 (unwind-protect
|
|
|
1881 (progn
|
|
|
1882 (set-window-dedicated-p win nil)
|
|
|
1883 (switch-to-buffer-other-frame
|
|
|
1884 (save-window-excursion
|
|
|
1885 (setq value (call-interactively 'dired-at-point))
|
|
|
1886 (current-buffer))))
|
|
|
1887 (set-window-dedicated-p win wdp))
|
|
|
1888 value))
|
|
|
1889
|
|
|
1890 (defun ffap-list-directory ()
|
|
|
1891 "Like `dired-at-point' and `list-directory'.
|
|
|
1892 Only intended for interactive use."
|
|
|
1893 (interactive)
|
|
|
1894 (let ((ffap-directory-finder 'list-directory))
|
|
|
1895 (call-interactively 'dired-at-point)))
|
|
|
1896
|
|
|
1897
|
|
106239
|
1898 ;;; Hooks to put in `file-name-at-point-functions':
|
|
|
1899
|
|
|
1900 ;;;###autoload
|
|
|
1901 (progn (defun ffap-guess-file-name-at-point ()
|
|
|
1902 "Try to get a file name at point.
|
|
106503
|
1903 This hook is intended to be put in `file-name-at-point-functions'."
|
|
106239
|
1904 (when (fboundp 'ffap-guesser)
|
|
|
1905 ;; Logic from `ffap-read-file-or-url' and `dired-at-point-prompter'.
|
|
|
1906 (let ((guess (ffap-guesser)))
|
|
|
1907 (setq guess
|
|
|
1908 (if (or (not guess)
|
|
|
1909 (and (fboundp 'ffap-url-p)
|
|
|
1910 (ffap-url-p guess))
|
|
|
1911 (and (fboundp 'ffap-file-remote-p)
|
|
|
1912 (ffap-file-remote-p guess)))
|
|
|
1913 guess
|
|
|
1914 (abbreviate-file-name (expand-file-name guess))))
|
|
|
1915 (when guess
|
|
|
1916 (if (file-directory-p guess)
|
|
|
1917 (file-name-as-directory guess)
|
|
|
1918 guess))))))
|
|
|
1919
|
|
|
1920
|
|
18291
|
1921 ;;; Offer default global bindings (`ffap-bindings'):
|
|
13531
|
1922
|
|
14874
|
1923 (defvar ffap-bindings
|
|
18486
|
1924 '(
|
|
|
1925 (global-set-key [S-mouse-3] 'ffap-at-mouse)
|
|
|
1926 (global-set-key [C-S-mouse-3] 'ffap-menu)
|
|
58923
|
1927
|
|
18486
|
1928 (global-set-key "\C-x\C-f" 'find-file-at-point)
|
|
58923
|
1929 (global-set-key "\C-x\C-r" 'ffap-read-only)
|
|
|
1930 (global-set-key "\C-x\C-v" 'ffap-alternate-file)
|
|
|
1931
|
|
18486
|
1932 (global-set-key "\C-x4f" 'ffap-other-window)
|
|
|
1933 (global-set-key "\C-x5f" 'ffap-other-frame)
|
|
58923
|
1934 (global-set-key "\C-x4r" 'ffap-read-only-other-window)
|
|
|
1935 (global-set-key "\C-x5r" 'ffap-read-only-other-frame)
|
|
|
1936
|
|
22282
|
1937 (global-set-key "\C-xd" 'dired-at-point)
|
|
58923
|
1938 (global-set-key "\C-x4d" 'ffap-dired-other-window)
|
|
|
1939 (global-set-key "\C-x5d" 'ffap-dired-other-frame)
|
|
|
1940 (global-set-key "\C-x\C-d" 'ffap-list-directory)
|
|
|
1941
|
|
18486
|
1942 (add-hook 'gnus-summary-mode-hook 'ffap-gnus-hook)
|
|
|
1943 (add-hook 'gnus-article-mode-hook 'ffap-gnus-hook)
|
|
|
1944 (add-hook 'vm-mode-hook 'ffap-ro-mode-hook)
|
|
|
1945 (add-hook 'rmail-mode-hook 'ffap-ro-mode-hook)
|
|
|
1946 ;; (setq dired-x-hands-off-my-keys t) ; the default
|
|
|
1947 )
|
|
|
1948 "List of binding forms evaluated by function `ffap-bindings'.
|
|
35096
|
1949 A reasonable ffap installation needs just this one line:
|
|
14874
|
1950 (ffap-bindings)
|
|
18291
|
1951 Of course if you do not like these bindings, just roll your own!")
|
|
13531
|
1952
|
|
34867
|
1953 ;;;###autoload
|
|
106503
|
1954 (defun ffap-bindings ()
|
|
14874
|
1955 "Evaluate the forms in variable `ffap-bindings'."
|
|
34867
|
1956 (interactive)
|
|
14874
|
1957 (eval (cons 'progn ffap-bindings)))
|
|
13531
|
1958
|
|
14874
|
1959
|
|
103729
|
1960 (provide 'ffap)
|
|
52401
|
1961
|
|
93975
|
1962 ;; arch-tag: 9dd3e88a-5dec-4607-bd57-60ae9ede8ebc
|
|
13531
|
1963 ;;; ffap.el ends here
|
