1 ;;; ffap.el --- find file or URL at point
3 ;; Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
5 ;; Author: Michelangelo Grigni <mic@mathcs.emory.edu>
6 ;; Created: 29 Mar 1993
7 ;; Keywords: files, hypermedia, matching, mouse
8 ;; X-Latest: ftp://ftp.mathcs.emory.edu:/pub/mic/emacs/
10 ;; This file is part of GNU Emacs.
12 ;; GNU Emacs is free software; you can redistribute it and/or modify
13 ;; it under the terms of the GNU General Public License as published by
14 ;; the Free Software Foundation; either version 2, or (at your option)
17 ;; GNU Emacs is distributed in the hope that it will be useful,
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 ;; GNU General Public License for more details.
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs; see the file COPYING. If not, write to the
24 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
25 ;; Boston, MA 02111-1307, USA.
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
32 ;; to guess a default file or URL from the text around the point
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
38 ;; For the default installation, byte-compile ffap.el somewhere in
39 ;; your `load-path' and add these two lines to your .emacs file:
41 ;; (require 'ffap) ; load the package
42 ;; (ffap-bindings) ; do default key bindings
44 ;; ffap-bindings makes the following global key bindings:
46 ;; C-x C-f find-file-at-point (abbreviated as ffap)
47 ;; C-x 4 f ffap-other-window
48 ;; C-x 5 f ffap-other-frame
49 ;; S-mouse-3 ffap-at-mouse
51 ;; ffap-bindings also adds hooks to make the following local bindings
52 ;; in vm, gnus, and rmail:
54 ;; M-l ffap-next, or ffap-gnus-next in gnus
55 ;; M-m ffap-menu, or ffap-gnus-menu in gnus
57 ;; If you do not like these bindings, modify the variable
58 ;; `ffap-bindings', or write your own.
60 ;; If you use ange-ftp, browse-url, complete, efs, or w3, it is best
61 ;; to load or autoload them before ffap. If you use ff-paths, load it
62 ;; afterwards. Try apropos {C-h a ffap RET} to get a list of the many
63 ;; option variables. In particular, if ffap is slow, try these:
65 ;; (setq ffap-alist nil) ; faster, dumber prompting
66 ;; (setq ffap-machine-p-known 'accept) ; no pinging
67 ;; (setq ffap-url-regexp nil) ; disable URL features in ffap
69 ;; ffap uses w3 (if found) or else browse-url to fetch URL's. For
70 ;; a hairier `ffap-url-fetcher', try ffap-url.el (same ftp site).
71 ;; Also, you can add `ffap-menu-rescan' to various hooks to fontify
72 ;; the file and URL references within a buffer.
75 ;; * recognize paths inside /usr/bin:/bin:/etc, ./ffap.el:80:
76 ;; * let "/path/file#key" jump to key (offset or regexp) in /path/file
77 ;; * find file of symbol if TAGS is loaded (like above)
78 ;; * break up long menus into multiple panes (like imenu?)
79 ;; * notice node in "(dired)Virtual Dired" (handle the space?)
80 ;; * notice "machine.dom blah blah blah path/file" (how?)
81 ;; * if w3 becomes standard, could rewrite to use its functions
82 ;; * regexp options for ffap-string-at-point, like font-lock (MCOOK)
83 ;; * v19: could replace `ffap-locate-file' with a quieter `locate-library'
84 ;; * support for custom.el
85 ;; + handle "$(HOME)" in Makefiles?
86 ;; + modify `font-lock-keywords' to do fontification
93 ;; Versions: This file is tested with Emacs 19.30. It mostly works
94 ;; with XEmacs, but get ffap-xe.el for the popup menu. Emacs 18 is
95 ;; now abandoned (get ffap-15.el instead).
97 (defvar ffap-xemacs
(and (string-match "X[Ee]macs" emacs-version
) t
)
98 "Whether ffap thinks it is running under XEmacs.")
105 "Find file or URL at point."
109 ;; This function is used inside defvars:
110 (defun ffap-soft-value (name &optional default
)
111 "Return value of symbol with NAME, if it is interned.
112 Otherwise return nil (or the optional DEFAULT value)."
113 ;; Bug: (ffap-soft-value "nil" 5) --> 5
114 (let ((sym (intern-soft name
)))
115 (if (and sym
(boundp sym
)) (symbol-value sym
) default
)))
118 (defcustom ffap-ftp-regexp
120 (or (featurep 'ange-ftp
)
122 (and (boundp 'file-name-handler-alist
) ; v19
123 (or (rassq 'ange-ftp-hook-function file-name-handler-alist
)
124 (rassq 'efs-file-handler-function file-name-handler-alist
))))
125 ;; Apparently this is good enough for both ange-ftp and efs:
127 "*Treat paths matching this as remote ftp paths. nil to disable.
128 nil also disables the generation of such paths by ffap."
129 :type
'(choice (const :tag
"Disable" nil
)
133 (defcustom ffap-url-unwrap-local t
134 "*If non-nil, convert \"file:\" URL to local path before prompting."
138 (defcustom ffap-url-unwrap-remote t
139 "*If non-nil, convert \"ftp:\" URL to remote path before prompting.
140 This is ignored if `ffap-ftp-regexp' is nil."
144 (defcustom ffap-ftp-default-user
145 (if (or (equal (ffap-soft-value "ange-ftp-default-user") "anonymous")
146 (equal (ffap-soft-value "efs-default-user") "anonymous"))
149 "*User name in ftp paths generated by `ffap-host-to-path'.
150 nil to rely on `efs-default-user' or `ange-ftp-default-user'."
151 :type
'(choice (const :tag
"Default" nil
)
155 (defcustom ffap-rfs-regexp
156 ;; Remote file access built into file system? HP rfa or Andrew afs:
157 "\\`/\\(afs\\|net\\)/."
158 ;; afs only: (and (file-exists-p "/afs") "\\`/afs/.")
159 "*Matching paths are treated as remote. nil to disable."
163 (defvar ffap-url-regexp
164 ;; Could just use `url-nonrelative-link' of w3, if loaded.
165 ;; This regexp is not exhaustive, it just matches common cases.
168 "news\\(post\\)?:\\|mailto:\\|file:" ; no host ok
170 "\\(ftp\\|http\\|telnet\\|gopher\\|www\\|wais\\)://" ; needs host
171 "\\)." ; require one more character
173 "Regexp matching URL's. nil to disable URL features in ffap.")
175 (defcustom ffap-foo-at-bar-prefix
"mailto"
176 "*Presumed URL prefix type of strings like \"<foo.9z@bar>\".
177 Sensible values are nil, \"news\", or \"mailto\"."
184 ;; Users of ffap occasionally suggest new features. If I consider
185 ;; those features interesting but not clear winners (a matter of
186 ;; personal taste) I try to leave options to enable them. Read
187 ;; through this section for features that you like, put an appropriate
188 ;; enabler in your .emacs file.
190 (defcustom ffap-dired-wildcards nil
; "[*?][^/]*$"
191 ;; Suggestion from RHOGEE, 07 Jul 1994. Disabled, dired is still
192 ;; available by "C-x C-d <pattern>", and valid filenames may
193 ;; sometimes contain wildcard characters.
194 "*A regexp matching filename wildcard characters, or nil.
195 If `find-file-at-point' gets a filename matching this pattern,
196 it passes it on to `dired' instead of `find-file'."
197 :type
'(choice (const :tag
"off" nil
)
201 (defcustom ffap-newfile-prompt nil
; t
202 ;; Suggestion from RHOGEE, 11 Jul 1994. Disabled, I think this is
203 ;; better handled by `find-file-not-found-hooks'.
204 "*Whether `find-file-at-point' prompts about a nonexistent file."
208 (defcustom ffap-require-prefix nil
209 ;; Suggestion from RHOGEE, 20 Oct 1994.
210 "*If set, reverses the prefix argument to `find-file-at-point'.
211 This is nil so neophytes notice ffap. Experts may prefer to disable
212 ffap most of the time."
216 (defcustom ffap-file-finder
'find-file
217 "*The command called by `find-file-at-point' to find a file."
220 (put 'ffap-file-finder
'risky-local-variable t
)
222 (defcustom ffap-url-fetcher
223 (cond ((fboundp 'w3-fetch
) 'w3-fetch
)
224 ((fboundp 'browse-url-netscape
) 'browse-url-netscape
)
226 ;; Remote control references:
227 ;; http://www.ncsa.uiuc.edu/SDG/Software/XMosaic/remote-control.html
228 ;; http://home.netscape.com/newsref/std/x-remote.html
229 "*A function of one argument, called by ffap to fetch an URL.
230 Reasonable choices are `w3-fetch' or `browse-url-netscape'.
231 For a fancier alternative, get ffap-url.el."
234 (put 'ffap-url-fetcher
'risky-local-variable t
)
237 ;;; Command ffap-next:
239 ;; Original ffap-next-url (URL's only) from RPECK 30 Mar 1995. Since
240 ;; then, broke it up into ffap-next-guess (noninteractive) and
241 ;; ffap-next (a command). It now work on files as well as url's.
243 (defcustom ffap-next-regexp
244 ;; If you want ffap-next to find URL's only, try this:
245 ;; (and ffap-url-regexp (string-match "\\\\`" ffap-url-regexp)
246 ;; (concat "\\<" (substring ffap-url-regexp 2))))
248 ;; It pays to put a big fancy regexp here, since ffap-guesser is
249 ;; much more time-consuming than regexp searching:
250 "[/:.~a-zA-Z]/\\|@[a-zA-Z][-a-zA-Z0-9]*\\."
251 "*Regular expression governing movements of `ffap-next'."
255 (defvar ffap-next-guess nil
"Last value returned by `ffap-next-guess'.")
256 (defun ffap-next-guess (&optional back lim
)
257 "Move point to next file or URL, and return it as a string.
258 If nothing is found, leave point at limit and return nil.
259 Optional BACK argument makes search backwards.
260 Optional LIM argument limits the search.
261 Only considers strings that match `ffap-next-regexp'."
262 (or lim
(setq lim
(if back
(point-min) (point-max))))
264 (while (not (or guess
(eq (point) lim
)))
265 (funcall (if back
're-search-backward
're-search-forward
)
266 ffap-next-regexp lim
'move
)
267 (setq guess
(ffap-guesser)))
268 ;; Go to end, so we do not get same guess twice:
269 (goto-char (nth (if back
0 1) ffap-string-at-point-region
))
270 (setq ffap-next-guess guess
)))
273 (defun ffap-next (&optional back wrap
)
274 "Search buffer for next file or URL, and run ffap.
275 Optional argument BACK says to search backwards.
276 Optional argument WRAP says to try wrapping around if necessary.
277 Interactively: use a single prefix to search backwards,
278 double prefix to wrap forward, triple to wrap backwards.
279 Actual search is done by `ffap-next-guess'."
281 (cdr (assq (prefix-numeric-value current-prefix-arg
)
282 '((1) (4 t
) (16 nil t
) (64 t t
)))))
284 (guess (ffap-next-guess back
)))
285 ;; Try wraparound if necessary:
286 (and (not guess
) wrap
287 (goto-char (if back
(point-max) (point-min)))
288 (setq guess
(ffap-next-guess back pt
)))
291 (sit-for 0) ; display point movement
292 (find-file-at-point (ffap-prompter guess
)))
293 (goto-char pt
) ; restore point
294 (message "No %sfiles or URL's found"
295 (if wrap
"" "more ")))))
297 (defun ffap-next-url (&optional back wrap
)
298 "Like `ffap-next', but search with `ffap-url-regexp'."
300 (let ((ffap-next-regexp ffap-url-regexp
))
302 (call-interactively 'ffap-next
)
303 (ffap-next back wrap
))))
306 ;;; Remote machines and paths:
308 (defun ffap-replace-path-component (fullname name
)
309 "In remote FULLNAME, replace path with NAME. May return nil."
310 ;; Use ange-ftp or efs if loaded, but do not load them otherwise.
313 (function (lambda (sym) (and (fboundp sym
) (setq found sym
))))
315 efs-replace-path-component
316 ange-ftp-replace-path-component
317 ange-ftp-replace-name-component
320 (fset 'ffap-replace-path-component found
)
321 (funcall found fullname name
))))
322 ;; (ffap-replace-path-component "/who@foo.com:/whatever" "/new")
324 (defun ffap-file-exists-string (file)
325 ;; With certain packages (ange-ftp, jka-compr?) file-exists-p
326 ;; sometimes returns a nicer string than it is given. Otherwise, it
327 ;; just returns nil or t.
328 "Return FILE \(maybe modified\) if it exists, else nil."
329 (and file
; quietly reject nil
330 (let ((exists (file-exists-p file
)))
331 (and exists
(if (stringp exists
) exists file
)))))
333 ;; I cannot decide a "best" strategy here, so these are variables. In
334 ;; particular, if `Pinging...' is broken or takes too long on your
335 ;; machine, try setting these all to accept or reject.
336 (defcustom ffap-machine-p-local
'reject
; this happens often
337 "*A symbol, one of: ping, accept, reject.
338 What `ffap-machine-p' does with hostnames that have no domain."
339 :type
'(choice (const ping
)
343 (defcustom ffap-machine-p-known
'ping
; 'accept for speed
344 "*A symbol, one of: ping, accept, reject.
345 What `ffap-machine-p' does with hostnames that have a known domain
346 \(see mail-extr.el for the known domains\)."
347 :type
'(choice (const ping
)
351 (defcustom ffap-machine-p-unknown
'reject
352 "*A symbol, one of: ping, accept, reject.
353 What `ffap-machine-p' does with hostnames that have an unknown domain
354 \(see mail-extr.el for the known domains\)."
355 :type
'(choice (const ping
)
360 (defun ffap-what-domain (domain)
361 ;; Like what-domain in mail-extr.el, returns string or nil.
363 (defvar mail-extr-all-top-level-domains
364 (ffap-soft-value "all-top-level-domains" obarray
)) ; XEmacs, old Emacs
365 (get (intern-soft (downcase domain
) mail-extr-all-top-level-domains
)
368 (defun ffap-machine-p (host &optional service quiet strategy
)
369 "Decide whether HOST is the name of a real, reachable machine.
370 Depending on the domain (none, known, or unknown), follow the strategy
371 named by the variable `ffap-machine-p-local', `ffap-machine-p-known',
372 or `ffap-machine-p-unknown'. Pinging uses `open-network-stream'.
373 Optional SERVICE specifies the port used \(default \"discard\"\).
374 Optional QUIET flag suppresses the \"Pinging...\" message.
375 Optional STRATEGY overrides the three variables above.
377 t means that HOST answered.
378 'accept means the relevant variable told us to accept.
379 \"mesg\" means HOST exists, but does not respond for some reason."
380 ;; Try some (Emory local):
381 ;; (ffap-machine-p "ftp" nil nil 'ping)
382 ;; (ffap-machine-p "nonesuch" nil nil 'ping)
383 ;; (ffap-machine-p "ftp.mathcs.emory.edu" nil nil 'ping)
384 ;; (ffap-machine-p "mathcs" 5678 nil 'ping)
385 ;; (ffap-machine-p "foo.bonk" nil nil 'ping)
386 ;; (ffap-machine-p "foo.bonk.com" nil nil 'ping)
387 (if (or (string-match "[^-a-zA-Z0-9.]" host
) ; Illegal chars (?)
388 (not (string-match "[^0-9]" host
))) ; 1: a number? 2: quick reject
391 (and (string-match "\\.[^.]*$" host
)
392 (downcase (substring host
(1+ (match-beginning 0))))))
393 (what-domain (if domain
(ffap-what-domain domain
) "Local")))
396 (cond ((not domain
) ffap-machine-p-local
)
397 ((not what-domain
) ffap-machine-p-unknown
)
398 (t ffap-machine-p-known
))))
400 ((eq strategy
'accept
) 'accept
)
401 ((eq strategy
'reject
) nil
)
402 ;; assume (eq strategy 'ping)
405 (if (stringp what-domain
)
406 (message "Pinging %s (%s)..." host what-domain
)
407 (message "Pinging %s ..." host
)))
408 (condition-case error
412 "ffap-machine-p" nil host
(or service
"discard")))
415 (let ((mesg (car (cdr error
))))
418 ((string-match "^Unknown host" mesg
) nil
)
419 ((string-match "not responding$" mesg
) mesg
)
421 ;; (file-error "connection failed" "permission denied"
422 ;; "nonesuch" "ffap-machine-p")
423 ;; (file-error "connection failed" "host is unreachable"
424 ;; "gopher.house.gov" "ffap-machine-p")
425 ;; (file-error "connection failed" "address already in use"
426 ;; "ftp.uu.net" "ffap-machine-p")
427 ((equal mesg
"connection failed")
428 (if (equal (nth 2 error
) "permission denied")
429 nil
; host does not exist
430 ;; Other errors mean the host exists:
432 ;; Could be "Unknown service":
433 (t (signal (car error
) (cdr error
))))))))))))
435 (defun ffap-file-remote-p (filename)
436 "If FILENAME looks remote, return it \(maybe slightly improved\)."
437 ;; (ffap-file-remote-p "/user@foo.bar.com:/pub")
438 ;; (ffap-file-remote-p "/cssun.mathcs.emory.edu://path")
439 ;; (ffap-file-remote-p "/ffap.el:80")
440 (or (and ffap-ftp-regexp
441 (string-match ffap-ftp-regexp filename
)
442 ;; Convert "/host.com://path" to "/host:/path", to handle a dieing
443 ;; practice of advertising ftp paths as "host.dom://path".
444 (if (string-match "//" filename
)
445 ;; (replace-match "/" nil nil filename)
446 (concat (substring filename
0 (1+ (match-beginning 0)))
447 (substring filename
(match-end 0)))
450 (string-match ffap-rfs-regexp filename
)
453 (defun ffap-machine-at-point nil
454 "Return machine name at point if it exists, or nil."
455 (let ((mach (ffap-string-at-point 'machine
)))
456 (and (ffap-machine-p mach
) mach
)))
458 (defsubst ffap-host-to-path
(host)
459 "Convert HOST to something like \"/anonymous@HOST:\".
460 Looks at `ffap-ftp-default-user', returns \"\" for \"localhost\"."
461 (if (equal host
"localhost") ""
463 ffap-ftp-default-user
(and ffap-ftp-default-user
"@")
466 (defun ffap-fixup-machine (mach)
467 ;; Convert a hostname into an url, an ftp path, or nil.
469 ((not (and ffap-url-regexp
(stringp mach
))) nil
)
471 ((string-match "\\`gopher[-.]" mach
) ; or "info"?
472 (concat "gopher://" mach
"/"))
474 ((and (string-match "\\`w\\(ww\\|eb\\)[-.]" mach
))
475 (concat "http://" mach
"/"))
476 ;; More cases? Maybe "telnet:" for archie?
477 (ffap-ftp-regexp (ffap-host-to-path mach
))
480 (defun ffap-newsgroup-p (string)
481 "Return STRING if it looks like a newsgroup name, else nil."
483 (string-match ffap-newsgroup-regexp string
)
484 (let ((htbs '(gnus-active-hashtb gnus-newsrc-hashtb gnus-killed-hashtb
))
485 (heads ffap-newsgroup-heads
)
488 (setq htb
(car htbs
) htbs
(cdr htbs
))
491 ;; errs: htb symbol may be unbound, or not a hash-table.
492 ;; gnus-gethash is just a macro for intern-soft.
493 (and (intern-soft string
(symbol-value htb
))
494 (setq ret string htbs nil
))
495 ;; If we made it this far, gnus is running, so ignore "heads":
499 (let ((head (string-match "\\`\\([a-z]+\\)\\." string
)))
500 (and head
(setq head
(substring string
0 (match-end 1)))
503 ;; Is there ever a need to modify string as a newsgroup name?
505 (defvar ffap-newsgroup-regexp
"^[a-z]+\\.[-+a-z_0-9.]+$"
506 "Strings not matching this fail `ffap-newsgroup-p'.")
507 (defvar ffap-newsgroup-heads
; entirely inadequate
508 '("alt" "comp" "gnu" "misc" "news" "sci" "soc" "talk")
509 "Used by `ffap-newsgroup-p' if gnus is not running.")
511 (defsubst ffap-url-p
(string)
512 "If STRING looks like an url, return it (maybe improved), else nil."
513 (let ((case-fold-search t
))
514 (and ffap-url-regexp
(string-match ffap-url-regexp string
)
515 ;; I lied, no improvement:
518 ;; Broke these out of ffap-fixup-url, for use of ffap-url package.
519 (defsubst ffap-url-unwrap-local
(url)
520 "Return URL as a local file, or nil. Ignores `ffap-url-regexp'."
521 (and (string-match "\\`\\(file\\|ftp\\):/?\\([^/]\\|\\'\\)" url
)
522 (substring url
(1+ (match-end 1)))))
523 (defsubst ffap-url-unwrap-remote
(url)
524 "Return URL as a remote file, or nil. Ignores `ffap-url-regexp'."
525 (and (string-match "\\`\\(ftp\\|file\\)://\\([^:/]+\\):?\\(/.*\\)" url
)
527 (ffap-host-to-path (substring url
(match-beginning 2) (match-end 2)))
528 (substring url
(match-beginning 3) (match-end 3)))))
529 ;; Test: (ffap-url-unwrap-remote "ftp://foo.com/bar.boz")
531 (defun ffap-fixup-url (url)
532 "Clean up URL and return it, maybe as a file name."
534 ((not (stringp url
)) nil
)
535 ((and ffap-url-unwrap-local
(ffap-url-unwrap-local url
)))
536 ((and ffap-url-unwrap-remote ffap-ftp-regexp
537 (ffap-url-unwrap-remote url
)))
538 ;; Do not load w3 just for this:
539 (t (let ((normal (and (fboundp 'url-normalize-url
)
540 (url-normalize-url url
))))
541 ;; In case url-normalize-url is confused:
542 (or (and normal
(not (zerop (length normal
))) normal
)
548 ;; Search actions depending on the major-mode or extensions of the
549 ;; current name. Note all the little defun's could be broken out, at
550 ;; some loss of locality. A good example of featuritis.
552 ;; First, some helpers for functions in `ffap-alist':
554 (defun ffap-list-env (env &optional empty
)
555 ;; Replace this with parse-colon-path (lisp/files.el)?
556 "Directory list parsed from path envinronment variable ENV.
557 Optional EMPTY is default if (getenv ENV) is undefined, and is also
558 substituted for the first empty-string component, if there is one.
559 Uses `path-separator' to separate the path into directories."
560 ;; Derived from psg-list-env in RHOGEE's ff-paths and
561 ;; bib-cite packages. The `empty' argument is intended to mimic
562 ;; the semantics of TeX/BibTeX variables, it is substituted for
563 ;; any empty string entry.
564 (if (or empty
(getenv env
)) ; should return something
565 (let ((start 0) match dir ret
)
566 (setq env
(concat (getenv env
) path-separator
))
567 (while (setq match
(string-match path-separator env start
))
568 (setq dir
(substring env start match
) start
(1+ match
))
569 ;;(and (file-directory-p dir) (not (member dir ret)) ...)
570 (setq ret
(cons dir ret
)))
571 (setq ret
(nreverse ret
))
572 (and empty
(setq match
(member "" ret
))
574 (setcdr match
(append (cdr-safe empty
) (cdr match
)))
575 (setcar match
(or (car-safe empty
) empty
))))
578 (defun ffap-reduce-path (path)
579 "Remove duplicates and non-directories from PATH list."
582 (setq tem path path
(cdr path
))
583 (if (equal (car tem
) ".") (setcar tem
""))
584 (or (member (car tem
) ret
)
585 (not (file-directory-p (car tem
)))
586 (progn (setcdr tem ret
) (setq ret tem
))))
589 (defun ffap-add-subdirs (path)
590 "Return PATH augmented with its immediate subdirectories."
591 ;; (ffap-add-subdirs '("/notexist" "~"))
596 (lambda (f) (and (file-directory-p f
) (setq ret
(cons f ret
)))))
598 (directory-files (car path
) t
"[^.]")
600 (setq ret
(cons (car path
) ret
)
605 ;; A big mess! Parts are probably useless.
608 (defun ffap-info (name)
611 (or (ffap-soft-value "Info-directory-list")
612 (ffap-soft-value "Info-default-directory-list")
614 (list (ffap-soft-value "Info-directory" "~/info/"))))))
615 ;; Since so many info files do not have .info extension, also do this:
617 (defun ffap-info-2 (name) (ffap-info (substring name
5))))
618 (cons "\\`[-a-z]+\\'"
619 ;; This ignores the node! "(emacs)Top" same as "(emacs)Intro"
620 (defun ffap-info-3 (name)
621 (and (equal (ffap-string-around) "()") (ffap-info name
))))
623 (defun ffap-el (name) (locate-library name t
)))
624 (cons 'emacs-lisp-mode
625 (defun ffap-el-mode (name)
626 ;; We do not bother with "" here, since it was considered above.
627 ;; Also ignore "elc", for speed (who else reads elc files?)
628 (and (not (string-match "\\.el\\'" name
))
629 (locate-library name
'(".el")))))
630 '(finder-mode . ffap-el-mode
) ; v19: {C-h p}
631 '(help-mode . ffap-el-mode
) ; v19.29
634 ;; Need better defaults here!
635 (defvar ffap-c-path
'("/usr/include" "/usr/local/include"))
636 (defun ffap-c-mode (name)
637 (locate-library name t ffap-c-path
))))
638 '(c++-mode . ffap-c-mode
)
639 '(cc-mode . ffap-c-mode
)
640 '("\\.\\([chCH]\\|cc\\|hh\\)\\'" . ffap-c-mode
)
642 ;; Complicated because auctex may not be loaded yet.
644 (defvar ffap-tex-path
645 t
; delayed initialization
646 "Path where `ffap-tex-mode' looks for tex files.
647 If t, `ffap-tex-init' will initialize this when needed.")
648 (defun ffap-tex-init nil
649 ;; Compute ffap-tex-path if it is now t.
650 (and (eq t ffap-tex-path
)
651 (message "Initializing ffap-tex-path ...")
656 (ffap-list-env "TEXINPUTS")
657 ;; (ffap-list-env "BIBINPUTS")
659 (ffap-list-env "TEXINPUTS_SUBDIR"
662 '("/usr/local/lib/tex/macros"
663 "/usr/local/lib/tex/inputs")
665 (defun ffap-tex-mode (name)
667 (locate-library name
'(".tex" "") ffap-tex-path
))))
669 (defun ffap-latex-mode (name)
671 ;; Any real need for "" here?
672 (locate-library name
'(".cls" ".sty" ".tex" "")
674 (cons "\\.\\(tex\\|sty\\|doc\\|cls\\)\\'"
675 (defun ffap-tex (name)
677 (locate-library name t ffap-tex-path
)))
679 (defun ffap-bib (name)
682 (ffap-list-env "BIBINPUTS" '("/usr/local/lib/tex/macros/bib")))))
684 (defun ffap-math-mode (name)
685 (while (string-match "`" name
)
686 (setq name
(concat (substring name
0 (match-beginning 0))
688 (substring name
(match-end 0)))))
690 name
'(".m" "") (ffap-soft-value "Mathematica-search-path"))))
691 (cons "\\`\\." (defun ffap-home (name) (locate-library name t
'("~"))))
693 ;; Maybe a "Lisp Code Directory" reference:
694 (defun ffap-lcd (name)
697 ;; lisp-dir-apropos output buffer:
698 (string-match "Lisp Code Dir" (buffer-name))
699 ;; Inside an LCD entry like |~/misc/ffap.el.Z|,
700 ;; or maybe the holy LCD-Datafile itself:
701 (member (ffap-string-around) '("||" "|\n")))
703 ;; lispdir.el may not be loaded yet:
705 (ffap-soft-value "elisp-archive-host"
706 "archive.cis.ohio-state.edu"))
707 (file-name-as-directory
708 (ffap-soft-value "elisp-archive-directory"
709 "/pub/gnu/emacs/elisp-archive/"))
710 (substring name
2)))))
711 (cons "^[Rr][Ff][Cc][- #]?\\([0-9]+\\)" ; no $
713 (defvar ffap-rfc-path
714 (concat (ffap-host-to-path "ds.internic.net") "/rfc/rfc%s.txt"))
715 (defun ffap-rfc (name)
716 (format ffap-rfc-path
717 (substring name
(match-beginning 1) (match-end 1))))))
719 (defun ffap-dired (name)
720 (let ((pt (point)) dir try
)
724 (looking-at " *[-d]r[-w][-x][-r][-w][-x][-r][-w][-x] "))
725 (re-search-backward "^ *$" nil t
)
726 (re-search-forward "^ *\\([^ \t\n:]*\\):\n *total " pt t
)
732 (match-beginning 1) (match-end 1)))))
735 "Alist of \(KEY . FUNCTION\) pairs parsed by `ffap-file-at-point'.
736 If string NAME at point (maybe \"\") is not a file or url, these pairs
737 specify actions to try creating such a string. A pair matches if either
738 KEY is a symbol, and it equals `major-mode', or
739 KEY is a string, it should matches NAME as a regexp.
740 On a match, \(FUNCTION NAME\) is called and should return a file, an
741 url, or nil. If nil, search the alist for further matches.")
743 (put 'ffap-alist
'risky-local-variable t
)
746 ;;; At-Point Functions:
748 (defvar ffap-string-at-point-mode-alist
750 ;; The default, used when the `major-mode' is not found.
751 ;; Slightly controversial decisions:
752 ;; * strip trailing "@" and ":"
753 ;; * no commas (good for latex)
754 (file "--:$+<>@-Z_a-z~" "<@" "@>;.,!?:")
755 ;; An url, or maybe a email/news message-id:
756 (url "--:?$+@-Z_a-z~#,%" "^A-Za-z0-9" ":;.,!?")
757 ;; Find a string that does *not* contain a colon:
758 (nocolon "--9$+<>@-Z_a-z~" "<@" "@>;.,!?")
760 (machine "-a-zA-Z0-9." "" ".")
761 ;; Mathematica paths: allow backquotes
762 (math-mode ",-:$+<>@-Z_a-z~`" "<" "@>;.,!?`:")
764 "Alist of \(MODE CHARS BEG END\), where MODE is a symbol,
765 possibly a `major-mode' or some symbol internal to ffap
766 \(such as 'file, 'url, 'machine, and 'nocolon\).
767 `ffap-string-at-point' uses the data fields as follows:
768 1. find a maximal string of CHARS around point,
769 2. strip BEG chars before point from the beginning,
770 3. Strip END chars after point from the end.")
772 (defvar ffap-string-at-point-region
'(1 1)
773 "List (BEG END), last region returned by `ffap-string-at-point'.")
775 (defvar ffap-string-at-point nil
776 ;; Added at suggestion of RHOGEE (for ff-paths), 7/24/95.
777 "Last string returned by `ffap-string-at-point'.")
779 (defun ffap-string-at-point (&optional mode
)
780 "Return a string of characters from around point.
781 MODE (defaults to `major-mode') is a symbol used to lookup string
782 syntax parameters in `ffap-string-at-point-mode-alist'.
783 If MODE is not found, we fall back on the symbol 'file.
784 Sets `ffap-string-at-point' and `ffap-string-at-point-region'."
787 (or (assq (or mode major-mode
) ffap-string-at-point-mode-alist
)
788 (assq 'file ffap-string-at-point-mode-alist
))))
793 (skip-chars-backward (car args
))
794 (skip-chars-forward (nth 1 args
) pt
)
795 (setcar ffap-string-at-point-region
(point)))
797 (skip-chars-forward (car args
))
798 (skip-chars-backward (nth 2 args
) pt
)
799 (setcar (cdr ffap-string-at-point-region
) (point))))))
800 (or ffap-xemacs
(set-text-properties 0 (length str
) nil str
))
801 (setq ffap-string-at-point str
)))
803 (defun ffap-string-around nil
804 ;; Sometimes useful to decide how to treat a string.
805 "Return string of two chars around last `ffap-string-at-point'.
806 Assumes the buffer has not changed."
810 (goto-char (car ffap-string-at-point-region
))
811 (preceding-char)) ; maybe 0
813 (goto-char (nth 1 ffap-string-at-point-region
))
814 (following-char)) ; maybe 0
817 (defun ffap-copy-string-as-kill (&optional mode
)
818 ;; Requested by MCOOK. Useful?
819 "Call `ffap-string-at-point', and copy result to `kill-ring'."
821 (let ((str (ffap-string-at-point mode
)))
823 (message "No string found around point.")
825 ;; Older: (apply 'copy-region-as-kill ffap-string-at-point-region)
826 (message "Copied to kill ring: %s" str
))))
828 (defun ffap-url-at-point nil
829 "Return url from around point if it exists, or nil."
830 ;; Could use w3's url-get-url-at-point instead. Both handle "URL:",
831 ;; ignore non-relative links, trim punctuation. The other will
832 ;; actually look back if point is in whitespace, but I would rather
833 ;; ffap be non-rabid in such situations.
837 ;; In a w3 buffer button zone?
839 (and (eq major-mode
'w3-mode
)
840 ;; assume: (boundp 'w3-zone-at) (boundp 'w3-zone-data)
841 (setq tem
(w3-zone-at (point)))
842 (consp (setq tem
(w3-zone-data tem
)))
844 ;; Is there a reason not to strip trailing colon?
845 (let ((name (ffap-string-at-point 'url
)))
846 ;; (case-fold-search t), why?
848 ((string-match "^url:" name
) (setq name
(substring name
4)))
849 ((and (string-match "\\`[^:</>@]+@[^:</>@]+[a-zA-Z]\\'" name
)
850 ;; "foo@bar": could be "mailto" or "news" (a Message-ID).
851 ;; If not adorned with "<>", it must be "mailto".
852 ;; Otherwise could be either, so consult `ffap-foo-at-bar-prefix'.
853 (let ((prefix (if (and (equal (ffap-string-around) "<>")
854 ;; At least a couple of odd characters:
855 (string-match "[$.0-9].*[$.0-9].*@" name
))
857 ffap-foo-at-bar-prefix
859 (and prefix
(setq name
(concat prefix
":" name
))))))
860 ((ffap-newsgroup-p name
) (setq name
(concat "news:" name
)))
861 ((and (string-match "\\`[a-z0-9]+\\'" name
) ; <mic> <root> <nobody>
862 (equal (ffap-string-around) "<>")
863 ;; (ffap-user-p name):
864 (not (string-match "~" (expand-file-name (concat "~" name
))))
866 (setq name
(concat "mailto:" name
)))
868 (and (ffap-url-p name
) name
)
871 (defvar ffap-gopher-regexp
872 "^.*\\<\\(Type\\|Name\\|Path\\|Host\\|Port\\) *= *\\(.*\\) *$"
873 "Regexp Matching a line in a gopher bookmark (maybe indented).
874 The two subexpressions are the KEY and VALUE.")
876 (defun ffap-gopher-at-point nil
877 "If point is inside a gopher bookmark block, return its url."
878 ;; `gopher-parse-bookmark' from gopher.el is not so robust
881 (if (looking-at ffap-gopher-regexp
)
883 (while (and (looking-at ffap-gopher-regexp
) (not (bobp)))
885 (or (looking-at ffap-gopher-regexp
) (forward-line 1))
886 (let ((type "1") name path host
(port "70"))
887 (while (looking-at ffap-gopher-regexp
)
890 (buffer-substring (match-beginning 1)
892 (val (buffer-substring (match-beginning 2)
896 (if (and path
(string-match "^ftp:.*@" path
))
898 (substring path
4 (1- (match-end 0)))
899 (substring path
(match-end 0)))
900 (and (= (length type
) 1)
901 host
;; (ffap-machine-p host)
902 (concat "gopher://" host
903 (if (equal port
"70") "" (concat ":" port
))
904 "/" type path
))))))))
906 (defvar ffap-ftp-sans-slash-regexp
909 ;; Note: by now, we know it is not an url.
910 ;; Icky regexp avoids: default: 123: foo::bar cs:pub
911 ;; It does match on: mic@cs: cs:/pub mathcs.emory.edu: (point at end)
912 "\\`\\([^:@]+@[^:@]+:\\|[^@.:]+\\.[^@:]+:\\|[^:]+:[~/]\\)\\([^:]\\|\\'\\)")
913 "Strings matching this are coerced to ftp paths by ffap.
914 That is, ffap just prepends \"/\". Set to nil to disable.")
916 (defun ffap-file-at-point nil
917 "Return filename from around point if it exists, or nil.
918 Existence test is skipped for names that look remote.
919 If the filename is not obvious, it also tries `ffap-alist',
920 which may actually result in an url rather than a filename."
921 ;; Note: this function does not need to look for url's, just
922 ;; filenames. On the other hand, it is responsible for converting
923 ;; a pseudo-url "site.com://path" to an ftp path
924 (let* ((case-fold-search t
) ; url prefixes are case-insensitive
926 (string (ffap-string-at-point)) ; uses mode alist
928 (or (condition-case nil
929 (and (not (string-match "//" string
)) ; foo.com://bar
930 (substitute-in-file-name string
))
933 (abs (file-name-absolute-p name
))
934 (default-directory default-directory
))
937 ;; Immediate rejects (/ and // are too common in C++):
938 ((member name
'("" "/" "//")) nil
)
939 ;; Immediately test local filenames. If default-directory is
940 ;; remote, you probably already have a connection.
941 ((and (not abs
) (ffap-file-exists-string name
)))
942 ;; Accept remote names without actual checking (too slow):
944 (ffap-file-remote-p name
)
945 ;; Try adding a leading "/" (common omission in ftp paths):
947 ffap-ftp-sans-slash-regexp
948 (string-match ffap-ftp-sans-slash-regexp name
)
949 (ffap-file-remote-p (concat "/" name
)))))
950 ;; Ok, not remote, try the existence test even if it is absolute:
951 ((and abs
(ffap-file-exists-string name
)))
952 ;; If it contains a colon, get rid of it (and return if exists)
953 ((and (string-match path-separator name
)
954 (setq name
(ffap-string-at-point 'nocolon
))
955 (ffap-file-exists-string name
)))
956 ;; File does not exist, try the alist:
957 ((let ((alist ffap-alist
) tem try case-fold-search
)
958 (while (and alist
(not try
))
959 (setq tem
(car alist
) alist
(cdr alist
))
960 (if (or (eq major-mode
(car tem
))
961 (and (stringp (car tem
))
962 (string-match (car tem
) name
)))
963 (and (setq try
(funcall (cdr tem
) name
))
965 (ffap-url-p try
) ; not a file!
966 (ffap-file-remote-p try
)
967 (ffap-file-exists-string try
))))))
969 ;; Alist failed? Try to guess an active remote connection
970 ;; from buffer variables, and try once more, both as an
971 ;; absolute and relative path on that remote host.
972 ((let* (ffap-rfs-regexp ; suppress
975 ((ffap-file-remote-p default-directory
))
976 ((and (eq major-mode
'internal-ange-ftp-mode
)
977 (string-match "^\\*ftp \\(.*\\)@\\(.*\\)\\*$"
979 (concat "/" (substring (buffer-name) 5 -
1) ":"))
980 ;; This is too often a bad idea:
981 ;;((and (eq major-mode 'w3-mode)
982 ;; (stringp url-current-server))
983 ;; (host-to-ange-path url-current-server))
987 (and (string-match "\\`\\(/?~?ftp\\)/" name
)
988 (ffap-file-exists-string
989 (ffap-replace-path-component
990 remote-dir
(substring name
(match-end 1)))))
991 (ffap-file-exists-string
992 (ffap-replace-path-component remote-dir name
))))))
994 (store-match-data data
))))
997 ;;; ffap-read-file-or-url:
999 ;; We want to complete filenames as in read-file-name, but also url's
1000 ;; which read-file-name-internal would truncate at the "//" string.
1001 ;; The solution here is to replace read-file-name-internal with
1002 ;; `ffap-read-file-or-url-internal', which checks the minibuffer
1003 ;; contents before attempting to complete filenames.
1005 (defun ffap-read-file-or-url (prompt guess
)
1006 "Read file or url from minibuffer, with PROMPT and initial GUESS."
1007 (or guess
(setq guess default-directory
))
1009 ;; Tricky: guess may have or be a local directory, like "w3/w3.elc"
1010 ;; or "w3/" or "../el/ffap.el" or "../../../"
1011 (or (ffap-url-p guess
)
1013 (or (ffap-file-remote-p guess
)
1014 (setq guess
(abbreviate-file-name (expand-file-name guess
))))
1015 (setq dir
(file-name-directory guess
))))
1019 'ffap-read-file-or-url-internal
1022 (if dir
(cons guess
(length dir
)) guess
)
1023 (list 'file-name-history
)
1025 ;; Do file substitution like (interactive "F"), suggested by MCOOK.
1026 (or (ffap-url-p guess
) (setq guess
(substitute-in-file-name guess
)))
1027 ;; Should not do it on url's, where $ is a common (VMS?) character.
1028 ;; Note: upcoming url.el package ought to handle this automatically.
1031 (defun ffap-read-url-internal (string dir action
)
1032 "Complete url's from history, treating given string as valid."
1033 (let ((hist (ffap-soft-value "url-global-history-hash-table")))
1036 (or (try-completion string hist
) string
))
1038 (or (all-completions string hist
) (list string
)))
1039 ;; action == lambda, documented where? Tests whether string is a
1040 ;; valid "match". Let us always say yes.
1043 (defun ffap-read-file-or-url-internal (string dir action
)
1044 (if (ffap-url-p string
)
1045 (ffap-read-url-internal string dir action
)
1046 (read-file-name-internal string dir action
)))
1048 ;; The rest of this page is just to work with package complete.el.
1049 ;; This code assumes that you load ffap.el after complete.el.
1051 ;; We must inform complete about whether our completion function
1052 ;; will do filename style completion. For earlier versions of
1053 ;; complete.el, this requires a defadvice. For recent versions
1054 ;; there may be a special variable for this purpose.
1056 (defun ffap-complete-as-file-p nil
1057 ;; Will `minibuffer-completion-table' complete the minibuffer
1058 ;; contents as a filename? Assumes the minibuffer is current.
1059 ;; Note: t and non-nil mean somewhat different reasons.
1060 (if (eq minibuffer-completion-table
'ffap-read-file-or-url-internal
)
1061 (not (ffap-url-p (buffer-string))) ; t
1062 (memq minibuffer-completion-table
1063 '(read-file-name-internal read-directory-name-internal
)) ; list
1067 (featurep 'complete
)
1068 (if (boundp 'PC-completion-as-file-name-predicate
)
1069 ;; modern version of complete.el, just set the variable:
1070 (setq PC-completion-as-file-name-predicate
'ffap-complete-as-file-p
)
1072 (defadvice PC-do-completion
(around ffap-fix act
)
1074 (let ((minibuffer-completion-table
1075 (if (eq t
(ffap-complete-as-file-p))
1076 'read-file-name-internal
1077 minibuffer-completion-table
)))
1083 ;; Based on overlay highlighting in Emacs 19.28 isearch.el.
1085 (defvar ffap-highlight
(and window-system t
)
1086 "If non-nil, ffap highlights the current buffer substring.")
1088 (defvar ffap-highlight-overlay nil
"Overlay used by `ffap-highlight'.")
1090 (defun ffap-highlight (&optional remove
)
1091 "If `ffap-highlight' is set, highlight the guess in this buffer.
1092 That is, the last buffer substring found by `ffap-string-at-point'.
1093 Optional argument REMOVE means to remove any such highlighting.
1094 Uses the face `ffap' if it is defined, or else `highlight'."
1096 (remove (and ffap-highlight-overlay
(delete-overlay ffap-highlight-overlay
)))
1097 ((not ffap-highlight
) nil
)
1098 (ffap-highlight-overlay
1099 (move-overlay ffap-highlight-overlay
1100 (car ffap-string-at-point-region
)
1101 (nth 1 ffap-string-at-point-region
)
1104 (setq ffap-highlight-overlay
(apply 'make-overlay ffap-string-at-point-region
))
1105 (overlay-put ffap-highlight-overlay
'face
1106 (if (internal-find-face 'ffap nil
)
1107 'ffap
'highlight
)))))
1110 ;;; The big enchilada:
1112 (defun ffap-guesser nil
1113 "Return file or url or nil, guessed from text around point."
1114 (or (and ffap-url-regexp
1115 (ffap-fixup-url (or (ffap-url-at-point)
1116 (ffap-gopher-at-point))))
1117 (ffap-file-at-point) ; may yield url!
1118 (ffap-fixup-machine (ffap-machine-at-point))))
1120 (defun ffap-prompter (&optional guess
)
1121 ;; Does guess and prompt step for find-file-at-point.
1122 ;; Extra complication for the temporary highlighting.
1124 (ffap-read-file-or-url
1125 (if ffap-url-regexp
"Find file or URL: " "Find file: ")
1127 (setq guess
(or guess
(ffap-guesser)))
1128 (and guess
(ffap-highlight))
1130 (ffap-highlight t
)))
1133 (defun find-file-at-point (&optional filename
)
1134 "Find FILENAME (or url), guessing default from text around point.
1135 If `ffap-dired-wildcards' is set, wildcard patterns are passed to dired.
1136 See also the functions `ffap-file-at-point', `ffap-url-at-point'.
1137 With a prefix, this command behaves *exactly* like `ffap-file-finder'.
1138 If `ffap-require-prefix' is set, the prefix meaning is reversed.
1140 See <ftp://ftp.mathcs.emory.edu/pub/mic/emacs/> for latest version."
1142 (if (and (interactive-p)
1143 (if ffap-require-prefix
(not current-prefix-arg
)
1144 current-prefix-arg
))
1145 ;; Do exactly the ffap-file-finder command, even the prompting:
1146 (let (current-prefix-arg) ; we already interpreted it
1147 (call-interactively ffap-file-finder
))
1148 (or filename
(setq filename
(ffap-prompter)))
1150 ((ffap-url-p filename
)
1151 (let (current-prefix-arg) ; w3 2.3.25 bug, reported by KPC
1152 (funcall ffap-url-fetcher filename
)))
1153 ;; This junk more properly belongs in a modified ffap-file-finder:
1154 ((and ffap-dired-wildcards
1155 (string-match ffap-dired-wildcards filename
))
1157 ((or (not ffap-newfile-prompt
)
1158 (file-exists-p filename
)
1159 (y-or-n-p "File does not exist, create buffer? "))
1160 (funcall ffap-file-finder
1161 ;; expand-file-name fixes "~/~/.emacs" bug sent by CHUCKR.
1162 (expand-file-name filename
)))
1163 ;; User does not want to find a non-existent file:
1164 ((signal 'file-error
(list "Opening file buffer"
1165 "no such file or directory"
1170 (defalias 'ffap
'find-file-at-point
)
1175 ;; Bind ffap-menu to a key if you want, since it also works in tty mode.
1176 ;; Or just use it through the ffap-at-mouse binding (next section).
1178 (defvar ffap-menu-regexp nil
1179 "*If non-nil, overrides `ffap-next-regexp' during `ffap-menu'.
1180 Make this more restrictive for faster menu building.
1181 For example, try \":/\" for url (and some ftp) references.")
1183 (defvar ffap-menu-alist nil
1184 "Buffer local cache of menu presented by `ffap-menu'.")
1185 (make-variable-buffer-local 'ffap-menu-alist
)
1187 (defvar ffap-menu-text-plist
1189 ;; These choices emulate goto-addr:
1191 '(face bold highlight t
) ; keymap <map>
1192 '(face bold mouse-face highlight
) ; keymap <mousy-map>
1194 "Text properties applied to strings found by `ffap-menu-rescan'.
1195 These properties may be used to fontify the menu references.")
1198 (defun ffap-menu (&optional rescan
)
1199 "Put up a menu of files and urls mentioned in this buffer.
1200 Then set mark, jump to choice, and try to fetch it. The menu is
1201 cached in `ffap-menu-alist', and rebuilt by `ffap-menu-rescan'.
1202 The optional RESCAN argument \(a prefix, interactively\) forces
1203 a rebuild. Searches with `ffap-menu-regexp'."
1205 ;; (require 'imenu) -- no longer used, but roughly emulated
1206 (if (or (not ffap-menu-alist
) rescan
1207 ;; or if the first entry is wrong:
1208 (and ffap-menu-alist
1209 (let ((first (car ffap-menu-alist
)))
1211 (goto-char (cdr first
))
1212 (not (equal (car first
) (ffap-guesser)))))))
1216 (if ffap-url-regexp
"Find file or URL" "Find file")
1217 (cons (cons "*Rescan Buffer*" -
1) ffap-menu-alist
)
1220 (defun ffap-menu-cont (choice) ; continuation of ffap-menu
1221 (if (< (cdr choice
) 0)
1222 (ffap-menu t
) ; *Rescan*
1224 (goto-char (cdr choice
))
1225 ;; Momentary highlight:
1228 (and ffap-highlight
(ffap-guesser) (ffap-highlight))
1229 (sit-for 0) ; display
1230 (find-file-at-point (car choice
)))
1231 (ffap-highlight t
))))
1233 (defun ffap-menu-ask (title alist cont
)
1234 "Prompt from a menu of choices, and then apply some action.
1235 Arguments are TITLE, ALIST, and CONT (a continuation).
1236 This uses either a menu or the minibuffer depending on invocation.
1237 The TITLE string is used as either the prompt or menu title.
1238 Each \(string . data\) ALIST entry defines a choice \(data is ignored\).
1239 Once the user makes a choice, function CONT is applied to the entry.
1240 Always returns nil."
1241 ;; Bug: minibuffer prompting assumes the strings are unique.
1243 (if (and (fboundp 'x-popup-menu
) ; Emacs 19 or XEmacs 19.13
1244 (boundp 'last-nonmenu-event
) ; not in XEmacs 19.13
1245 (listp last-nonmenu-event
))
1251 (function (lambda (i) (cons (car i
) i
)))
1253 ;; Immediately popup completion buffer:
1255 (let ((minibuffer-setup-hook 'minibuffer-completion-help
))
1256 ;; BUG: this code assumes that "" is not a valid choice
1258 (format "%s (default %s): " title
(car (car alist
)))
1260 ;; (cons (car (car alist)) 0)
1263 ;; Redraw original screen:
1265 ;; Defaulting: convert "" to (car (car alist))
1266 (and (equal choice
"") (setq choice
(car (car alist
))))
1267 (and (stringp choice
) (setq choice
(assoc choice alist
)))
1268 (if choice
(funcall cont choice
) (message "No choice made!")))
1269 nil
) ; return nothing
1271 (defun ffap-menu-rescan nil
1272 "Search buffer for `ffap-menu-regexp' to build `ffap-menu-alist'.
1273 Applies `ffap-menu-text-plist' text properties at all matches."
1275 (let ((ffap-next-regexp (or ffap-menu-regexp ffap-next-regexp
))
1276 (range (- (point-max) (point-min))) item
1277 buffer-read-only
; to set text-properties
1278 ;; Avoid repeated searches of the *mode-alist:
1279 (major-mode (if (assq major-mode ffap-string-at-point-mode-alist
)
1283 (setq ffap-menu-alist nil
)
1285 (goto-char (point-min))
1286 (while (setq item
(ffap-next-guess))
1287 (setq ffap-menu-alist
(cons (cons item
(point)) ffap-menu-alist
))
1288 (add-text-properties (car ffap-string-at-point-region
) (point)
1289 ffap-menu-text-plist
)
1290 (message "Scanning...%2d%% <%s>"
1291 (/ (* 100 (- (point) (point-min))) range
) item
))))
1292 (message "Scanning...done")
1293 ;; Remove duplicates.
1294 (setq ffap-menu-alist
; sort by item
1295 (sort ffap-menu-alist
1297 (lambda (a b
) (string-lessp (car a
) (car b
))))))
1298 (let ((ptr ffap-menu-alist
))
1300 (if (equal (car (car ptr
)) (car (car (cdr ptr
))))
1301 (setcdr ptr
(cdr (cdr ptr
)))
1302 (setq ptr
(cdr ptr
)))))
1303 (setq ffap-menu-alist
; sort by position
1304 (sort ffap-menu-alist
1306 (lambda (a b
) (< (cdr a
) (cdr b
)))))))
1311 ;; See the suggested binding in ffap-bindings (near eof).
1313 (defvar ffap-at-mouse-fallback
'ffap-menu
1314 "Invoked by `ffap-at-mouse' if no file or url at click.
1315 A command symbol, or nil for nothing.")
1316 (put 'ffap-at-mouse-fallback
'risky-local-variable t
)
1318 (defun ffap-at-mouse (e)
1319 "Find file or url guessed from text around mouse point.
1320 If none is found, call `ffap-at-mouse-fallback'."
1323 ;; Maybe less surprising without the save-excursion?
1326 ;; Would like to do nothing unless click was *on* text. How?
1327 ;; (cdr (posn-col-row (event-start e))) is always same as
1328 ;; current column. For posn-x-y, need pixel-width!
1335 (sit-for 0) ; display
1336 (message "Guessing `%s'" guess
)
1337 (find-file-at-point guess
))
1338 (ffap-highlight t
)))
1339 ((and (interactive-p)
1340 ffap-at-mouse-fallback
)
1341 (call-interactively ffap-at-mouse-fallback
))
1342 ((message "No file or URL found at mouse click.")))))
1345 ;;; ffap-other-* commands
1346 ;; Suggested by KPC.
1348 (defun ffap-other-window nil
1349 "Like `ffap', but put buffer in another window."
1351 (switch-to-buffer-other-window
1352 (save-window-excursion (call-interactively 'ffap
) (current-buffer))))
1354 (defun ffap-other-frame nil
1355 "Like `ffap', but put buffer in another frame."
1357 (switch-to-buffer-other-frame
1358 (save-window-excursion (call-interactively 'ffap
) (current-buffer))))
1364 "Submit a bug report for the ffap package."
1365 ;; Important: keep the version string here in synch with that at top
1366 ;; of file! Could use lisp-mnt from Emacs 19, but that would depend
1367 ;; on being able to find the ffap.el source file.
1370 (let ((reporter-prompt-for-summary-p t
))
1371 (reporter-submit-bug-report
1372 "Michelangelo Grigni <mic@mathcs.emory.edu>"
1374 (mapcar 'intern
(all-completions "ffap-" obarray
'boundp
)))))
1376 (fset 'ffap-submit-bug
'ffap-bug
) ; another likely name
1379 ;;; Hooks for Gnus, VM, Rmail:
1381 ;; If you do not like these bindings, write versions with whatever
1382 ;; bindings you would prefer.
1384 (defun ffap-ro-mode-hook nil
1385 "Bind `ffap-next' and `ffap-menu' to M-l and M-m, resp."
1386 (local-set-key "\M-l" 'ffap-next
)
1387 (local-set-key "\M-m" 'ffap-menu
)
1390 (defun ffap-gnus-hook nil
1391 "Bind `ffap-gnus-next' and `ffap-gnus-menu' to M-l and M-m, resp."
1392 (set (make-local-variable 'ffap-foo-at-bar-prefix
) "news") ; message-id's
1393 ;; Note "l", "L", "m", "M" are taken:
1394 (local-set-key "\M-l" 'ffap-gnus-next
)
1395 (local-set-key "\M-m" 'ffap-gnus-menu
))
1397 (defun ffap-gnus-wrapper (form) ; used by both commands below
1398 (and (eq (current-buffer) (get-buffer gnus-summary-buffer
))
1399 (gnus-summary-select-article)) ; get article of current line
1400 ;; Preserve selected buffer, but do not do save-window-excursion,
1401 ;; since we want to see any window created by the form. Temporarily
1402 ;; select the article buffer, so we can see any point movement.
1403 (let ((sb (window-buffer (selected-window))))
1404 (gnus-configure-windows 'article
)
1405 (pop-to-buffer gnus-article-buffer
)
1407 ;; Skip headers for ffap-gnus-next (which will wrap around)
1408 (if (eq (point) (point-min)) (search-forward "\n\n" nil t
))
1411 (pop-to-buffer sb
))))
1413 (defun ffap-gnus-next nil
1414 "Run `ffap-next' in the gnus article buffer."
1415 (interactive) (ffap-gnus-wrapper '(ffap-next nil t
)))
1417 (defun ffap-gnus-menu nil
1418 "Run `ffap-menu' in the gnus article buffer."
1419 (interactive) (ffap-gnus-wrapper '(ffap-menu)))
1422 ;;; ffap-bindings: offer default global bindings
1424 (defvar ffap-bindings
1427 ((not (eq window-system
'x
))
1429 ;; GNU coding standards say packages should not bind S-mouse-*.
1430 ;; Is it ok to simply suggest such a binding to the user?
1432 '((global-set-key '(shift button3
) 'ffap-at-mouse
)))
1434 '((global-set-key [S-down-mouse-3
] 'ffap-at-mouse
))))
1436 (global-set-key "\C-x\C-f" 'find-file-at-point
)
1437 (global-set-key "\C-x4f" 'ffap-other-window
)
1438 (global-set-key "\C-x5f" 'ffap-other-frame
)
1439 (add-hook 'gnus-summary-mode-hook
'ffap-gnus-hook
)
1440 (add-hook 'gnus-article-mode-hook
'ffap-gnus-hook
)
1441 (add-hook 'vm-mode-hook
'ffap-ro-mode-hook
)
1442 (add-hook 'rmail-mode-hook
'ffap-ro-mode-hook
)
1443 ;; (setq dired-x-hands-off-my-keys t) ; the default
1445 "List of forms evaluated by function `ffap-bindings'.
1446 A reasonable ffap installation needs just these two lines:
1449 These are only suggestions, they may be modified or ignored.")
1451 (defun ffap-bindings nil
1452 "Evaluate the forms in variable `ffap-bindings'."
1453 (eval (cons 'progn ffap-bindings
)))
1455 ;; Example modifications:
1457 ;; (setq ffap-alist ; remove a feature in `ffap-alist'
1458 ;; (delete (assoc 'c-mode ffap-alist) ffap-alist))
1460 ;; (setq ffap-alist ; add something to `ffap-alist'
1462 ;; (cons "^[Yy][Ss][Nn][0-9]+$"
1463 ;; (defun ffap-ysn (name)
1465 ;; "http://snorri.chem.washington.edu/ysnarchive/issuefiles/"
1466 ;; (substring name 3) ".html")))
1471 ;; Extended suppport in another file, for copyright reasons.
1472 (or (not ffap-xemacs
)
1473 (load "ffap-xe" t t
)
1474 (message "ffap warning: ffap-xe.el not found"))
1477 ;;; ffap.el ends here