mirror of
https://git.savannah.gnu.org/git/emacs.git
synced 2024-12-30 11:09:23 +00:00
1503 lines
56 KiB
EmacsLisp
1503 lines
56 KiB
EmacsLisp
;;; ffap.el -- find-file-at-point,
|
||
|
||
;; Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
|
||
|
||
;; Author: Michelangelo Grigni <mic@mathcs.emory.edu>
|
||
|
||
;; This file is part of GNU Emacs.
|
||
|
||
;; GNU Emacs is free software; you can redistribute it and/or modify
|
||
;; it under the terms of the GNU General Public License as published by
|
||
;; the Free Software Foundation; either version 2, or (at your option)
|
||
;; any later version.
|
||
|
||
;; GNU Emacs is distributed in the hope that it will be useful,
|
||
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
;; GNU General Public License for more details.
|
||
|
||
;; You should have received a copy of the GNU General Public License
|
||
;; along with GNU Emacs; see the file COPYING. If not, write to the
|
||
;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||
;; Boston, MA 02111-1307, USA.
|
||
|
||
;;; Commentary:
|
||
|
||
;; A replacement for find-file {C-x C-f}: finds file or URL,
|
||
;; guessing default from text at point. Many features!
|
||
;; Send bugs or suggestions with M-x ffap-bug.
|
||
|
||
;; See ftp://ftp.mathcs.emory.edu:/pub/mic/emacs/ for most recent version:
|
||
;; ffap.el.gz -- this file, compressed with gzip
|
||
;; ffap-xe.el -- support code for XEmacs 19.*
|
||
;; COPYING.gz -- GNU General Public License, version 2
|
||
;; README -- description of these and other files
|
||
;;
|
||
;; For the last version sent to elisp-archive@cis.ohio-state.edu, see:
|
||
;; ftp://ftp.cis.ohio-state.edu/pub/gnu/emacs/elisp-archive/misc/ffap.el.Z
|
||
;; (mirrored in gatekeeper.dec.com:/pub/GNU/elisp-archive/misc/)
|
||
|
||
;;; Description:
|
||
;;
|
||
;; Command find-file-at-point (== ffap) replaces find-file. With a
|
||
;; prefix, it behaves exactly like find-file. Without a prefix, it
|
||
;; first tries to guess a default file or URL based on the text around
|
||
;; the point (set `ffap-require-prefix' to swap these behaviors).
|
||
;; This is a quick way to fetch URL and file references in many
|
||
;; situations, such as in mail or news messages, README's, and
|
||
;; MANIFEST's.
|
||
;;
|
||
;; Some related commands are ffap-at-mouse, ffap-next, ffap-menu,
|
||
;; ffap-other-window, ffap-other-frame.
|
||
;;
|
||
;; This package is about user convenience. It adds nothing to the
|
||
;; elisp programmer's repertoire.
|
||
|
||
|
||
;;; Installation:
|
||
|
||
;; Quick Setup:
|
||
;;
|
||
;; For a basic installation, just install ffap.el somewhere in your
|
||
;; `load-path', byte-compile it, and add the following two lines near
|
||
;; the end of your ~/.emacs (or equivalent) file:
|
||
;;
|
||
;; (require 'ffap) ; load this file
|
||
;; (global-set-key "\C-x\C-f" 'find-file-at-point)
|
||
;;
|
||
;; Other Packages: ffap notices the presence of several other packages
|
||
;; when it is loaded. In particular, if you use ange-ftp, efs, w3,
|
||
;; complete, or ff-paths (version < 3.00), it is best to load or
|
||
;; autoload them before loading ffap (ffap does not need any of them).
|
||
;; If you use ff-paths version >= 3.00, load it after ffap.
|
||
|
||
;; Fancier Setup:
|
||
;;
|
||
;; ffap has many options. The next comment block contains some
|
||
;; fancier code that you might want to adapt for your .emacs. For
|
||
;; even more features, look at the documentation (M-x apropos ffap),
|
||
;; and perhaps check the comments in the "User Variables" and "Peanut
|
||
;; Gallery" sections of this file.
|
||
|
||
;; ;; Before loading ffap:
|
||
;;
|
||
;; (setq ffap-url-regexp nil) ; to disable all URL features
|
||
;;
|
||
;; ;; Loading ffap:
|
||
;; (require 'ffap) ; as in "Quick Setup" above
|
||
;;
|
||
;; After loading ffap:
|
||
;;
|
||
;; (global-set-key "\C-x\C-f" 'find-file-at-point) ; as in "Quick Setup"
|
||
;; (global-set-key "\C-x4f" 'ffap-other-window) ; or \C-f
|
||
;; (global-set-key "\C-x5f" 'ffap-other-frame) ; or \C-f
|
||
;;
|
||
;; (setq ffap-alist ; remove something in `ffap-alist'
|
||
;; (delete (assoc 'c-mode ffap-alist) ffap-alist))
|
||
;;
|
||
;; (setq ffap-alist ; add something to `ffap-alist'
|
||
;; (cons
|
||
;; (cons "^[Yy][Ss][Nn][0-9]+$"
|
||
;; (defun ffap-ysn (name)
|
||
;; (concat
|
||
;; "http://snorri.chem.washington.edu/ysnarchive/issuefiles/"
|
||
;; (substring name 3) ".html")))
|
||
;; ffap-alist))
|
||
;;
|
||
;;
|
||
;; Before or after loading ffap:
|
||
;;
|
||
;; (setq ffap-alist nil) ; disable all `ffap-alist' actions
|
||
;;
|
||
;; (setq ffap-require-prefix t) ; without prefix, ffap == find-file
|
||
;;
|
||
;; (setq ffap-machine-p-known 'accept) ; to avoid pinging
|
||
;;
|
||
;; ;; Choose a mouse binding appropriate for your emacs version:
|
||
;; (global-set-key [S-mouse-1] 'ffap-at-mouse) ; Emacs 19
|
||
;; (global-set-key [(meta button1)] 'ffap-at-mouse) ; XEmacs
|
||
;; (and window-system ; Emacs 18 (from .emacs)
|
||
;; (setq window-setup-hook
|
||
;; '(lambda nil (define-key mouse-map x-button-s-left
|
||
;; 'ffap-at-mouse))))
|
||
;;
|
||
;; ;; Use Netscape instead of w3 to fetch URL's. Mosaic is very similar.
|
||
;; (if (eq window-system 'x)
|
||
;; (progn
|
||
;; ;; Get browse-url at http://wombat.doc.ic.ac.uk/emacs/browse-url.el,
|
||
;; ;; or get a (probably out of date) copy from the ftp site above.
|
||
;; (autoload 'browse-url-netscape "browse-url" nil t)
|
||
;; (setq ffap-url-fetcher 'browse-url-netscape)))
|
||
;; ;; Or for a hairier ffap-url-fetcher, get ffap-url.el (same ftp site).
|
||
;;
|
||
;; ;; Support for gnus, vm, rmail (see hook definitions for bindings):
|
||
;; (add-hook 'gnus-summary-mode-hook 'ffap-gnus-hook)
|
||
;; (add-hook 'gnus-article-mode-hook 'ffap-gnus-hook)
|
||
;; (add-hook 'vm-mode-hook 'ffap-ro-mode-hook)
|
||
;; (add-hook 'rmail-mode-hook 'ffap-ro-mode-hook)
|
||
|
||
|
||
;;; Related packages:
|
||
;;
|
||
;; If you have hyperbole, you may not need this package, although ffap
|
||
;; is smaller and smarter at this particular task. Also note that w3
|
||
;; (ftp.cs.indiana.edu:/pub/elisp/w3/README) offers a similar command
|
||
;; w3-follow-url-at-point.
|
||
;;
|
||
;; The browse-url package (above) notices URL's and hands them off to
|
||
;; w3 or an external WWW browser. Package |~/misc/goto-address.el.gz|
|
||
;; by Eric J. Ding <ericding@mit.edu> notices URL's and mail
|
||
;; addresses, and can pre-fontify a buffer to highlight them. Gnus5
|
||
;; (ding) and vm also provide similar support in their messages.
|
||
|
||
|
||
;;; Examples:
|
||
;;
|
||
;; Try M-x find-file-at-point (maybe {C-x C-f}) on these examples.
|
||
;; These local file examples use ordinary find-file:
|
||
;;
|
||
;; ffap.el, /etc/motd, $MAIL -- find local or absolute files
|
||
;; .emacs book.sty info/cl pwd.h -- search paths depending on filename
|
||
;; (require 'rmail) -- search paths depending on major-mode
|
||
;; file:/etc/motd -- depends on `ffap-url-unwrap-local'
|
||
;;
|
||
;; These remote file examples work if you have ange-ftp or efs:
|
||
;;
|
||
;; ftp:/pub -- no ping (always works)
|
||
;; ftp.x.org:README -- no ping, a nice recursive example
|
||
;; anonymous@ftp.x.org:/README -- synonym
|
||
;; ftp.x.org://README -- synonym
|
||
;; ftp://ftp.x.org/README -- depends on `ffap-url-unwrap-remote'
|
||
;; ftp.mathcs.emory.edu -- depends on `ffap-machine-p-known'
|
||
;; mic@ftp:/ -- depends on `ffap-machine-p-local'
|
||
;; ftp.mathcs.emory.edu:/ -- depends on `ffap-ftp-sans-slash-regexp'
|
||
;;
|
||
;; These URL examples use `ffap-url-fetcher' (default w3-fetch):
|
||
;;
|
||
;; http://www.cc.emory.edu
|
||
;; http://www.cs.indiana.edu/elisp/w3/docs.html
|
||
;; http://info.cern.ch/default.html
|
||
;; news:news.newusers.questions
|
||
;; mailto:mic@mathcs.emory.edu
|
||
;; mic@mathcs.emory.edu -- same as previous
|
||
;; <mic@mathcs.emory.edu> -- same as previous
|
||
;; <root> -- mailto:root
|
||
;; <mic.9@mathcs.emory.edu> -- see `ffap-foo@bar-prefix'
|
||
;; file:/etc/motd -- see `ffap-url-unwrap-local'
|
||
;; ftp://ftp.x.org/README -- see `ffap-url-unwrap-remote'
|
||
;;
|
||
;; Multiline gopher blocks (as in .gopherrc and usenet of yesteryear):
|
||
;;
|
||
;; Type=1
|
||
;; Name=Electronic Texts (ffap ignores this)
|
||
;; Path=
|
||
;; Host=etext.archive.umich.edu
|
||
;; Port=70
|
||
|
||
|
||
;;; Code:
|
||
|
||
(provide 'ffap)
|
||
|
||
;;; User Variables:
|
||
|
||
;; This function is used inside defvars:
|
||
(defun ffap-soft-value (name &optional default)
|
||
;; Avoid interning. Bug: (ffap-soft-value "nil" 5) --> 5
|
||
(let ((sym (intern-soft name)))
|
||
(if (and sym (boundp sym)) (symbol-value sym) default)))
|
||
|
||
|
||
(defvar ffap-ftp-regexp
|
||
(and
|
||
(or (featurep 'ange-ftp)
|
||
(featurep 'efs)
|
||
(and (boundp 'file-name-handler-alist) ; v19
|
||
(or (rassq 'ange-ftp-hook-function file-name-handler-alist)
|
||
(rassq 'efs-file-handler-function file-name-handler-alist))))
|
||
;; Apparently this is good enough for both ange-ftp and efs:
|
||
"\\`/[^/:]+:")
|
||
"*Treat paths matching this as remote ftp paths. Nil to disable.
|
||
Nil also disables the generation of such paths by ffap.")
|
||
|
||
(defvar ffap-url-unwrap-local t
|
||
"*If set, convert local \"file:\" URL to path before prompting.")
|
||
|
||
(defvar ffap-url-unwrap-remote t
|
||
"*Convert remote \"file:\" or \"ftp:\" URL to path before prompting.
|
||
This is ignored if `ffap-ftp-regexp' is nil.")
|
||
|
||
(defvar ffap-ftp-default-user
|
||
(if (or (equal (ffap-soft-value "ange-ftp-default-user") "anonymous")
|
||
(equal (ffap-soft-value "efs-default-user") "anonymous"))
|
||
nil
|
||
"anonymous")
|
||
"*User name in ftp paths generated by ffap (see host-to-ftp-path).
|
||
Nil to fall back on `efs-default-user' or `ange-ftp-default-user'.")
|
||
|
||
(defvar ffap-rfs-regexp
|
||
;; Remote file access built into file system? HP rfa or Andrew afs:
|
||
"\\`/\\(afs\\|net\\)/."
|
||
;; afs only: (and (file-exists-p "/afs") "\\`/afs/.")
|
||
"*Paths matching this are remote file-system paths. Nil to disable.")
|
||
|
||
(defvar ffap-url-regexp
|
||
;; Could just use `url-nonrelative-link' of w3, if loaded.
|
||
;; This regexp is not exhaustive, it just matches common cases.
|
||
(concat
|
||
"\\`\\("
|
||
"news\\(post\\)?:\\|mailto:\\|file:" ; no host ok
|
||
"\\|"
|
||
"\\(ftp\\|http\\|telnet\\|gopher\\|www\\|wais\\)://" ; needs host
|
||
"\\)." ; require one more character
|
||
)
|
||
"Regexp matching URL's, or nil to disable.")
|
||
|
||
(defvar ffap-foo@bar-prefix "mailto"
|
||
"*Presumed url prefix type of strings like \"<foo.9z@bar>\".
|
||
Sensible values are nil, \"news\", or \"mailto\".")
|
||
|
||
|
||
;;; Peanut Gallery:
|
||
|
||
;; Users of ffap occasionally suggest new features. If I consider
|
||
;; those features interesting but not clear winners (a matter of
|
||
;; personal taste) I try to leave options to enable them. Read
|
||
;; through this section, and for any features you like, put an
|
||
;; appropriate form in your ~/.emacs file.
|
||
|
||
(defvar ffap-dired-wildcards nil ; "[*?][^/]*$"
|
||
;; From RHOGEE, 07 Jul 1994.
|
||
;; Disabled: dired is still available by "C-x C-d <pattern>", and
|
||
;; valid filenames may contain wildcard characters.
|
||
"*A regexp matching filename wildcard characters, or nil.
|
||
If find-file-at-point gets a filename matching this pattern,
|
||
it passes it on to dired instead of find-file.")
|
||
|
||
(defvar ffap-newfile-prompt nil ; t
|
||
;; From RHOGEE, 11 Jul 1994.
|
||
;; Disabled: this is better handled by `find-file-not-found-hooks'.
|
||
"*Whether find-file-at-point prompts about a nonexistent file.")
|
||
|
||
(defvar ffap-require-prefix nil
|
||
;; From RHOGEE, 20 Oct 1994.
|
||
;; This is nil so that neophytes notice ffap. Experts instead may
|
||
;; prefer to disable ffap most of the time.
|
||
"*If set, reverses the prefix argument to find-file-at-point.")
|
||
|
||
(defvar ffap-file-finder
|
||
;; From RHOGEE, 20 Oct 1994.
|
||
;; This allows compatibility with ff-paths version < 3.00.
|
||
;; For ff-paths version >= 3.00, just load it after ffap.
|
||
(if (commandp 'find-file-using-paths)
|
||
'find-file-using-paths
|
||
;; Try to overcome load-order dependency:
|
||
(eval-after-load
|
||
"ff-paths"
|
||
'(and (commandp 'find-file-using-paths)
|
||
(setq ffap-file-finder find-file-using-paths)))
|
||
'find-file)
|
||
"*The command symbol called by find-file-at-point to find a file.
|
||
Probably find-file, or find-file-using-paths if you use ff-paths
|
||
with version < 3.00.")
|
||
(put 'ffap-file-finder 'risky-local-variable t)
|
||
|
||
(defvar ffap-url-fetcher 'w3-fetch
|
||
"*A function of one argument, called by ffap to fetch URL's.
|
||
The default is w3-fetch from the w3 package. If you prefer Mosaic or
|
||
Netscape, install http://wombat.doc.ic.ac.uk/emacs/browse-url.el, and
|
||
add one of the following lines to your setup:
|
||
|
||
\(setq ffap-url-fetcher 'browse-url-netscape\)
|
||
\(setq ffap-url-fetcher 'browse-url-mosaic\)
|
||
|
||
Or for something hairier \(choose fetch method based on url type and
|
||
prompting\) get ffap-url.el wherever you ffap.el."
|
||
;; Big old `lambda' examples deleted. Some remote-control references:
|
||
;; http://www.ncsa.uiuc.edu/SDG/Software/XMosaic/remote-control.html
|
||
;; http://home.netscape.com/newsref/std/x-remote.html
|
||
)
|
||
(put 'ffap-url-fetcher 'risky-local-variable t)
|
||
|
||
|
||
;;; Command ffap-next:
|
||
;;
|
||
;; Original ffap-next-url (URL's only) from RPECK 30 Mar 1995.
|
||
;; Since then, broke up into ffap-next-guess (noninteractive) and
|
||
;; ffap-next (a command), now work on files as well as url's.
|
||
|
||
(defvar ffap-next-regexp
|
||
;; If you want ffap-next to find URL's only, try this:
|
||
;; (and ffap-url-regexp (string-match "\\\\`" ffap-url-regexp)
|
||
;; (concat "\\<" (substring ffap-url-regexp 2))))
|
||
;;
|
||
;; It pays to put a big fancy regexp here, since ffap-guesser is
|
||
;; much more time-consuming than regexp searching:
|
||
"[/:.~a-zA-Z]/\\|@[a-zA-Z][-a-zA-Z0-9]*\\."
|
||
"*Regular expression governing search of ffap-next.")
|
||
|
||
(defvar ffap-next-guess nil "Last value returned by `ffap-next-guess'.")
|
||
(defun ffap-next-guess (&optional back lim)
|
||
"Move point to next file or url, and return it as a string.
|
||
If nothing found, leaves point at limit and returns nil.
|
||
Optional BACK argument makes search backwards.
|
||
Optional LIM argument limits the search.
|
||
Only considers strings that match `ffap-next-regexp'."
|
||
(or lim (setq lim (if back (point-min) (point-max))))
|
||
(let (guess)
|
||
(while (not (or guess (eq (point) lim)))
|
||
(funcall (if back 're-search-backward 're-search-forward)
|
||
ffap-next-regexp lim 'move)
|
||
(setq guess (ffap-guesser)))
|
||
;; Go to end, so we do not get same guess twice:
|
||
(goto-char (nth (if back 0 1) ffap-string-at-point-region))
|
||
(setq ffap-next-guess guess)))
|
||
|
||
;;;###autoload
|
||
(defun ffap-next (&optional back wrap)
|
||
"Search buffer for next file or url, and run ffap.
|
||
Optional argument BACK says to search backwards.
|
||
Optional argument WRAP says to try wrapping around if necessary.
|
||
Interactively: use a single prefix to search backwards,
|
||
double prefix to wrap forward, triple to wrap backwards.
|
||
Actual search is done by ffap-next-guess."
|
||
(interactive
|
||
(cdr (assq (prefix-numeric-value current-prefix-arg)
|
||
'((1) (4 t) (16 nil t) (64 t t)))))
|
||
(let ((pt (point))
|
||
(guess (ffap-next-guess back)))
|
||
;; Try wraparound if necessary:
|
||
(and (not guess) wrap
|
||
(goto-char (if back (point-max) (point-min)))
|
||
(setq guess (ffap-next-guess back pt)))
|
||
(if guess
|
||
(progn
|
||
(sit-for 0) ; display point movement
|
||
(find-file-at-point (ffap-prompter guess)))
|
||
(goto-char pt) ; restore point
|
||
(message "No %sfiles or URL's found."
|
||
(if wrap "" "more ")))))
|
||
|
||
(defun ffap-next-url (&optional back wrap)
|
||
"Just like ffap-next, but searches with `ffap-url-regexp'."
|
||
(interactive)
|
||
(let ((ffap-next-regexp ffap-url-regexp))
|
||
(if (interactive-p)
|
||
(call-interactively 'ffap-next)
|
||
(ffap-next back wrap))))
|
||
|
||
|
||
;;; Hooks for GNUS, VM, Rmail:
|
||
;;
|
||
;; See "Installation" above for suggested use of these hooks.
|
||
;; If you do not like these bindings, just write hooks with
|
||
;; whatever bindings you would prefer.
|
||
;;
|
||
;; Any suggestions of more "memorable" bindings? -- Mic
|
||
|
||
(defun ffap-ro-mode-hook nil
|
||
"Binds ffap-gnus-next and ffap-gnus-menu to M-l and M-m, resp."
|
||
(local-set-key "\M-l" 'ffap-next)
|
||
(local-set-key "\M-m" 'ffap-menu)
|
||
)
|
||
|
||
(defun ffap-gnus-hook nil
|
||
"Binds ffap-gnus-next and ffap-gnus-menu to L and M, resp."
|
||
(set (make-local-variable 'ffap-foo@bar-prefix) "news") ; message-id's
|
||
;; Note lowercase l and m are taken:
|
||
(local-set-key "L" 'ffap-gnus-next)
|
||
(local-set-key "M" 'ffap-gnus-menu))
|
||
|
||
(defun ffap-gnus-wrapper (form) ; used by both commands below
|
||
(and (eq (current-buffer) (get-buffer gnus-summary-buffer))
|
||
(gnus-summary-select-article)) ; get article of current line
|
||
;; Preserve selected buffer, but do not do save-window-excursion,
|
||
;; since we want to see any window created by form. Temporarily
|
||
;; select the article buffer, so we see any point movement.
|
||
(let ((sb (window-buffer (selected-window))))
|
||
(gnus-configure-windows 'article)
|
||
(pop-to-buffer gnus-article-buffer)
|
||
(widen)
|
||
;; Skip headers at first, for ffap-gnus-next (which wraps around)
|
||
(if (eq (point) (point-min)) (search-forward "\n\n" nil t))
|
||
(unwind-protect
|
||
(eval form)
|
||
(pop-to-buffer sb))))
|
||
|
||
(defun ffap-gnus-next nil
|
||
"Run ffap-next in the GNUS article buffer."
|
||
(interactive) (ffap-gnus-wrapper '(ffap-next nil t)))
|
||
|
||
(defun ffap-gnus-menu nil
|
||
"Run ffap-menu in the GNUS article buffer."
|
||
(interactive) (ffap-gnus-wrapper '(ffap-menu)))
|
||
|
||
|
||
;;; Remote machines and paths:
|
||
|
||
(fset 'ffap-replace-path-component
|
||
(if (or (featurep 'efs)
|
||
(and
|
||
(boundp 'file-name-handler-alist) ; v19
|
||
(rassq 'efs-file-handler-function file-name-handler-alist)))
|
||
'efs-replace-path-component
|
||
'ange-ftp-replace-name-component))
|
||
|
||
(defun ffap-file-exists-string (file)
|
||
;; With certain packages (ange-ftp, jka-compr?) file-exists-p
|
||
;; sometimes returns a nicer string than it is given. Otherwise, it
|
||
;; just returns nil or t.
|
||
"Return FILE \(maybe modified\) if it exists, else nil."
|
||
(let ((exists (file-exists-p file)))
|
||
(and exists (if (stringp exists) exists file))))
|
||
|
||
;; I cannot decide a "best" strategy here, so these are variables. In
|
||
;; particular, if `Pinging...' is broken or takes too long on your
|
||
;; machine, try setting these all to accept or reject.
|
||
(defvar ffap-machine-p-local 'reject ; this happens often
|
||
"A symbol, one of: ping, accept, reject.
|
||
This is what ffap-machine-p does with hostnames that have no domain.")
|
||
(defvar ffap-machine-p-known 'ping ; 'accept for speed
|
||
"A symbol, one of: ping, accept, reject.
|
||
This is what ffap-machine-p does with hostnames that have a known domain
|
||
\(see lisp/mail-extr.el for the list of known domains\).")
|
||
(defvar ffap-machine-p-unknown 'reject
|
||
"A symbol, one of: ping, accept, reject.
|
||
This is what ffap-machine-p does with hostnames that have an unknown domain
|
||
\(see lisp/mail-extr.el for the list of known domains\).")
|
||
|
||
(defvar ffap-machine-p-known-domains
|
||
'("com" "edu" "net" "org" "mil" "gov" "us" "arpa") ; USA USA...
|
||
;; This variable is mainly for emacs18.
|
||
"Top-level domains known to ffap. Ignored if mail-extr is loadable.")
|
||
|
||
(defun ffap-machine-p (host &optional service quiet)
|
||
"Indicate whether HOST is the name of a real machine.
|
||
The variables ffap-machine-p-local, ffap-machine-p-known, and ffap-machine-p-unknown
|
||
control ffap-machine-p depending on HOST's domain \(none/known/unknown\).
|
||
Pinging is done using open-network-stream to decide HOST existence.
|
||
Optional SERVICE specifies the service used \(default \"discard\"\).
|
||
Optional QUIET flag suppresses the \"Pinging...\" message.
|
||
Returned values:
|
||
A t value means that HOST answered.
|
||
A symbol \(accept\) means the relevant variable told us to accept.
|
||
A string means the machine exists, but does not respond for some reason."
|
||
;; Try some:
|
||
;; (ffap-machine-p "ftp")
|
||
;; (ffap-machine-p "nonesuch")
|
||
;; (ffap-machine-p "ftp.mathcs.emory.edu")
|
||
;; (ffap-machine-p "foo.bonk")
|
||
;; (ffap-machine-p "foo.bonk.com")
|
||
;; (ffap-machine-p "cs" 5678)
|
||
;; (ffap-machine-p "gopher.house.gov")
|
||
;; Not known to 19.28
|
||
;; (ffap-
|
||
(if (or (string-match "[^-a-zA-Z0-9.]" host) ; Illegal chars (?)
|
||
(not (string-match "[^0-9]" host))) ; all numeric! reject it
|
||
nil
|
||
(let* ((domain
|
||
(and (string-match "\\.[^.]*$" host)
|
||
(downcase (substring host (1+ (match-beginning 0))))))
|
||
(domain-name ; t, "Country", "Local", or nil
|
||
(cond
|
||
((not domain) "Local")
|
||
;; common non-country domains (some imply US though):
|
||
;; t)
|
||
(t
|
||
;; Use domain-name properties from v19 lisp/mail-extr.el;
|
||
;; bbdb/mail-extr also puts this in `all-top-level-domains'.
|
||
(if (or (featurep 'mail-extr)
|
||
(and (load "mail-extr" t t)
|
||
;; It became a feature between 19.22 and 19.28
|
||
(provide 'mail-extr)))
|
||
(get (intern-soft
|
||
domain
|
||
(condition-case nil
|
||
mail-extr-all-top-level-domains
|
||
;; Before 19.28, the symbols were in `obarray':
|
||
(error obarray)))
|
||
'domain-name)
|
||
;; Emacs18 does not have mail-extr:
|
||
(and (member domain ffap-machine-p-known-domains) t))
|
||
)))
|
||
(strategy
|
||
(cond ((not domain) ffap-machine-p-local)
|
||
((not domain-name) ffap-machine-p-unknown)
|
||
(ffap-machine-p-known))))
|
||
(cond
|
||
((eq strategy 'accept) 'accept)
|
||
((eq strategy 'reject) nil)
|
||
;; assume (eq strategy 'ping)
|
||
(t
|
||
(or quiet
|
||
(if (stringp domain-name)
|
||
(message "Pinging %s (%s)..." host domain-name)
|
||
(message "Pinging %s ..." host)))
|
||
(condition-case error
|
||
(progn
|
||
(delete-process
|
||
(open-network-stream
|
||
"ffap-machine-p" nil host (or service "discard")))
|
||
t)
|
||
(error
|
||
(let ((mesg (car (cdr error))))
|
||
(cond
|
||
;; v18:
|
||
((string-match "^Unknown host" mesg) nil)
|
||
((string-match "not responding$" mesg) mesg)
|
||
;; v19:
|
||
;; (file-error "connection failed" "permission denied"
|
||
;; "nonesuch" "ffap-machine-p")
|
||
;; (file-error "connection failed" "host is unreachable"
|
||
;; "gopher.house.gov" "ffap-machine-p")
|
||
;; (file-error "connection failed" "address already in use"
|
||
;; "ftp.uu.net" "ffap-machine-p")
|
||
((equal mesg "connection failed")
|
||
(if (equal (nth 2 error) "permission denied")
|
||
nil ; host does not exist
|
||
;; Other errors mean host exists:
|
||
(nth 2 error)))
|
||
;; Could be "Unknown service":
|
||
(t (signal (car error) (cdr error))))))))))))
|
||
|
||
(defun ffap-file-remote-p (filename)
|
||
"If FILENAME looks remote, return it \(maybe slightly improved\)."
|
||
;; (ffap-file-remote-p "/user@foo.bar.com:/pub")
|
||
;; (ffap-file-remote-p "/foo.dom://path")
|
||
(or (and ffap-ftp-regexp
|
||
(string-match ffap-ftp-regexp filename)
|
||
;; Convert "/host://path" to "/host:/path", to handle a dying
|
||
;; practice of advertising ftp paths as "host.dom://path".
|
||
(if (string-match "//" filename)
|
||
(concat (substring filename 0 (match-beginning 0))
|
||
(substring filename (1- (match-end 0))))
|
||
filename))
|
||
(and ffap-rfs-regexp
|
||
(string-match ffap-rfs-regexp filename)
|
||
filename)))
|
||
|
||
(defun ffap-machine-at-point nil
|
||
"Return machine name from around point if it exists, or nil."
|
||
(let ((mach (ffap-string-at-point "-a-zA-Z0-9." nil ".")))
|
||
(and (ffap-machine-p mach) mach)))
|
||
|
||
(defun ffap-fixup-machine (mach)
|
||
;; Convert a machine into an URL, an ftp path, or nil.
|
||
(cond
|
||
((not (and ffap-url-regexp (stringp mach))) nil)
|
||
((string-match "\\`gopher[-.]" mach) ; or "info"?
|
||
(concat "gopher://" mach "/"))
|
||
((and (string-match "\\`w\\(ww\\|eb\\)[-.]" mach))
|
||
(concat "http://" mach "/"))
|
||
;; More cases? Maybe "telnet:" for archie?
|
||
(ffap-ftp-regexp (ffap-host-to-path mach))
|
||
))
|
||
|
||
(defun ffap-host-to-path (host)
|
||
"Convert \"HOST\" to \"/anonymous@HOST:\" (or \"\" for \"localhost\").
|
||
Variable `ffap-ftp-default-user' overrides or suppresses \"anonymous\"."
|
||
(if (equal host "localhost")
|
||
""
|
||
(if ffap-ftp-default-user
|
||
(concat "/" ffap-ftp-default-user "@" host ":")
|
||
(concat "/" host ":"))))
|
||
|
||
(defun ffap-newsgroup-p (string)
|
||
"Return STRING if it looks like a newsgroup name, else nil."
|
||
(and
|
||
(string-match ffap-newsgroup-regexp string)
|
||
(let ((htbs '(gnus-active-hashtb gnus-newsrc-hashtb gnus-killed-hashtb))
|
||
(heads ffap-newsgroup-heads)
|
||
htb ret)
|
||
(while htbs
|
||
(setq htb (car htbs) htbs (cdr htbs))
|
||
(condition-case nil
|
||
(progn
|
||
;; errs: htb symbol may be unbound, or not a hash-table.
|
||
;; gnus-gethash is just a macro for intern-soft.
|
||
(and (intern-soft string (symbol-value htb))
|
||
(setq ret string htbs nil))
|
||
;; If we made it this far, GNUS is running, so ignore "heads":
|
||
(setq heads nil))
|
||
(error nil)))
|
||
(or ret (not heads)
|
||
(let ((head (string-match "\\`\\([a-z]+\\)\\." string)))
|
||
(and head (setq head (substring string 0 (match-end 1)))
|
||
(member head heads)
|
||
(setq ret string))))
|
||
;; Ever any need to modify string as a newsgroup name?
|
||
ret)))
|
||
(defvar ffap-newsgroup-regexp "^[a-z]+\\.[-+a-z_0-9.]+$"
|
||
"ffap-newsgroup-p quickly rejects strings that do not match this.")
|
||
(defvar ffap-newsgroup-heads ; entirely inadequate
|
||
'("alt" "comp" "gnu" "misc" "news" "sci" "soc" "talk")
|
||
"Used by ffap-newsgroup-p if GNUS is not running.")
|
||
|
||
(defun ffap-url-p (string)
|
||
"If STRING looks like an URL, return it (maybe improved), else nil."
|
||
;; Does it look like an URL? Ignore case.
|
||
(let ((case-fold-search t))
|
||
(and ffap-url-regexp (string-match ffap-url-regexp string)
|
||
;; I lied, no improvement:
|
||
string)))
|
||
|
||
;; Broke these two out of ffap-fixup-url, for sake of ffap-url package.
|
||
(defun ffap-url-unwrap-local (url)
|
||
"Return unwrapped local file URL, or nil. Ignores ffap-* variables."
|
||
(and (string-match "\\`\\(file\\|ftp\\):/?\\([^/]\\|\\'\\)" url)
|
||
(substring url (1+ (match-end 1)))))
|
||
(defun ffap-url-unwrap-remote (url)
|
||
"Return unwrapped remote file URL, or nil. Ignores ffap-* variables."
|
||
(and (string-match "\\`\\(ftp\\|file\\)://\\([^:/]+\\):?\\(/.*\\)" url)
|
||
(concat
|
||
(ffap-host-to-path (substring url (match-beginning 2) (match-end 2)))
|
||
(substring url (match-beginning 3) (match-end 3)))))
|
||
|
||
(defun ffap-fixup-url (url)
|
||
"Given URL, clean it up and return it. May become a file name."
|
||
(cond
|
||
((not (stringp url)) nil)
|
||
((and ffap-url-unwrap-local (ffap-url-unwrap-local url)))
|
||
((and ffap-url-unwrap-remote ffap-ftp-regexp
|
||
(ffap-url-unwrap-remote url)))
|
||
;; Do not load w3 just for this:
|
||
(t (let ((normal (and (fboundp 'url-normalize-url)
|
||
(url-normalize-url url))))
|
||
;; In case url-normalize-url is confused:
|
||
(or (and normal (not (zerop (length normal))) normal)
|
||
url)))))
|
||
|
||
|
||
;;; `ffap-alist':
|
||
;;
|
||
;; Search actions depending on the major-mode or extensions of the
|
||
;; current name. Note all the little defun's could be broken out, at
|
||
;; some loss of locality. I have had a vote for eliminating this
|
||
;; from ffap (featuritis)
|
||
|
||
;; First, some helpers for functions in `ffap-alist':
|
||
|
||
(defun ffap-list-env (env &optional empty)
|
||
;; Replace this with parse-colon-path (lisp/files.el)?
|
||
"Directory list parsed from \":\"-separated ENVironment variable.
|
||
Optional EMPTY is default if (getenv ENV) is undefined, and is also
|
||
substituted for the first empty-string component, if there is one."
|
||
;; Derived from psg-list-env in RHOGEE's ff-paths and
|
||
;; bib-cite packages. The `empty' argument is intended to mimic
|
||
;; the semantics of TeX/BibTeX variables, it is substituted for
|
||
;; any empty string entry.
|
||
(if (or empty (getenv env)) ; should return something
|
||
(let ((start 0) match dir ret)
|
||
(setq env (concat (getenv env) path-separator)) ; note undefined -> ":"
|
||
(while (setq match (string-match path-separator env start))
|
||
(setq dir (substring env start match) start (1+ match))
|
||
;;(and (file-directory-p dir) (not (member dir ret)) ...)
|
||
(setq ret (cons dir ret)))
|
||
(setq ret (nreverse ret))
|
||
(and empty (setq match (member "" ret))
|
||
(progn
|
||
(setcdr match (append (cdr-safe empty) (cdr match)))
|
||
(setcar match (or (car-safe empty) empty))))
|
||
ret)))
|
||
|
||
(defun ffap-reduce-path (path)
|
||
"Remove duplicates or non-dirs from PATH."
|
||
(let (ret tem)
|
||
(while path
|
||
(setq tem path path (cdr path))
|
||
(or (member (car tem) ret)
|
||
(not (file-directory-p (car tem)))
|
||
(progn (setcdr tem ret) (setq ret tem))))
|
||
(nreverse ret)))
|
||
|
||
(defun ffap-add-subdirs (path)
|
||
"Return PATH augmented with its immediate subdirectories."
|
||
;; (ffap-add-subdirs '("/notexist" "~"))
|
||
(let (ret subs)
|
||
(while path
|
||
(mapcar
|
||
(function
|
||
(lambda (f) (and (file-directory-p f) (setq ret (cons f ret)))))
|
||
(condition-case nil
|
||
(directory-files (car path) t "[^.]")
|
||
(error nil)))
|
||
(setq ret (cons (car path) ret)
|
||
path (cdr path)))
|
||
(nreverse ret)))
|
||
|
||
(defvar ffap-locate-jka-suffixes t
|
||
"List of compression suffixes that ffap-locate-file tries.
|
||
If not a list, it will be initialized by ffap-locate-file,
|
||
and it will become nil unless you are using jka-compr.
|
||
You might set this to nil or a list like '(\".gz\" \".z\" \".Z\").")
|
||
|
||
(defun ffap-locate-file (file &optional nosuffix path)
|
||
;; If this package is only working in v19 now, maybe should
|
||
;; replace this with a quiet version of locate-library.
|
||
"A generic path-searching function, defaults mimic `load' behavior.
|
||
Returns path of an existing FILE that (load FILE) would load, or nil.
|
||
Optional second argument NOSUFFIX, if t, is like the fourth argument
|
||
for load, i.e. don't try adding suffixes \".elc\" and \".el\".
|
||
If a list, it is taken as a list of suffixes to try instead.
|
||
Optional third argument PATH specifies a different search path, it
|
||
defaults to `load-path'."
|
||
(or path (setq path load-path))
|
||
(if (file-name-absolute-p file)
|
||
(setq path (list (file-name-directory file))
|
||
file (file-name-nondirectory file)))
|
||
(let ((suffixes-to-try
|
||
(cond
|
||
((consp nosuffix) nosuffix)
|
||
(nosuffix '(""))
|
||
(t '(".elc" ".el" "")))))
|
||
;; Compensate for modern (19.28) jka-compr, that no longer searches
|
||
;; for foo.gz when you asked for foo:
|
||
(or (listp ffap-locate-jka-suffixes)
|
||
(setq ffap-locate-jka-suffixes
|
||
(and (featurep 'jka-compr) ; an early version was jka-compr19
|
||
(not (featurep 'jka-aux))
|
||
jka-compr-file-name-handler-entry
|
||
(not (string-match
|
||
(car jka-compr-file-name-handler-entry)
|
||
"foo"))
|
||
;; Hard to do cleverly across various jka-compr versions:
|
||
'(".gz" ".Z"))))
|
||
(if ffap-locate-jka-suffixes
|
||
(setq suffixes-to-try
|
||
(apply
|
||
'nconc
|
||
(mapcar
|
||
(function
|
||
(lambda (suf)
|
||
(cons suf
|
||
(mapcar
|
||
(function (lambda (x) (concat suf x)))
|
||
ffap-locate-jka-suffixes))))
|
||
suffixes-to-try))))
|
||
(let (found suffixes)
|
||
(while (and path (not found))
|
||
(setq suffixes suffixes-to-try)
|
||
(while (and suffixes (not found))
|
||
(let ((try (expand-file-name
|
||
(concat file (car suffixes))
|
||
(car path))))
|
||
(if (and (file-exists-p try) (not (file-directory-p try)))
|
||
(setq found try)))
|
||
(setq suffixes (cdr suffixes)))
|
||
(setq path (cdr path)))
|
||
found)))
|
||
|
||
(defvar ffap-alist
|
||
;; A big mess! Parts are probably useless.
|
||
(list
|
||
(cons "\\.info\\'"
|
||
(defun ffap-info (name)
|
||
(ffap-locate-file
|
||
name '("" ".info")
|
||
(or (ffap-soft-value "Info-directory-list")
|
||
(ffap-soft-value "Info-default-directory-list")
|
||
;; v18:
|
||
(list (ffap-soft-value "Info-directory" "~/info/"))))))
|
||
;; Since so many info files do not have .info extension, also do this:
|
||
(cons "\\`info/"
|
||
(defun ffap-info-2 (name) (ffap-info (substring name 5))))
|
||
(cons "\\`[-a-z]+\\'"
|
||
;; This ignores the node! "(emacs)Top" same as "(emacs)Intro"
|
||
(defun ffap-info-3 (name)
|
||
(and (equal (ffap-string-around) "()") (ffap-info name))))
|
||
(cons "\\.elc?\\'"
|
||
(defun ffap-el (name) (ffap-locate-file name t)))
|
||
(cons 'emacs-lisp-mode
|
||
(defun ffap-el-mode (name)
|
||
;; We do not bother with "" here, since it was considered above.
|
||
;; Also ignore "elc", for speed (who else reads elc files?)
|
||
(and (not (string-match "\\.el\\'" name))
|
||
(ffap-locate-file name '(".el")))))
|
||
'(finder-mode . ffap-el-mode) ; v19: {C-h p}
|
||
'(help-mode . ffap-el-mode) ; v19.29
|
||
(cons 'c-mode
|
||
(progn
|
||
;; Need better default here:
|
||
(defvar ffap-c-path '("/usr/include" "/usr/local/include"))
|
||
(defun ffap-c-mode (name)
|
||
(ffap-locate-file name t ffap-c-path))))
|
||
'(c++-mode . ffap-c-mode)
|
||
'(cc-mode . ffap-c-mode)
|
||
'("\\.\\([chCH]\\|cc\\|hh\\)\\'" . ffap-c-mode)
|
||
(cons 'tex-mode
|
||
;; Complicated because auctex may not be loaded yet.
|
||
(progn
|
||
(defvar ffap-tex-path
|
||
(ffap-reduce-path
|
||
(append
|
||
(list ".")
|
||
(ffap-list-env "TEXINPUTS")
|
||
;; (ffap-list-env "BIBINPUTS")
|
||
(ffap-add-subdirs
|
||
(ffap-list-env "TEXINPUTS_SUBDIR"
|
||
(ffap-soft-value
|
||
"TeX-macro-global"
|
||
'("/usr/local/lib/tex/macros"
|
||
"/usr/local/lib/tex/inputs")
|
||
)))))
|
||
"*Where ffap-tex-mode looks for tex files.")
|
||
(defun ffap-tex-mode (name)
|
||
(ffap-locate-file name '(".tex" "") ffap-tex-path))))
|
||
(cons 'latex-mode
|
||
(defun ffap-latex-mode (name)
|
||
;; Any real need for "" here?
|
||
(ffap-locate-file name '(".sty" ".tex" "") ffap-tex-path)))
|
||
(cons "\\.\\(tex\\|sty\\|doc\\)\\'"
|
||
(defun ffap-tex (name)
|
||
(ffap-locate-file name t ffap-tex-path)))
|
||
(cons "\\.bib\\'"
|
||
(defun ffap-bib (name)
|
||
(ffap-locate-file
|
||
name t
|
||
(ffap-list-env "BIBINPUTS" '("/usr/local/lib/tex/macros/bib")))))
|
||
(cons 'math-mode
|
||
(defun ffap-math-mode (name)
|
||
(while (string-match "`" name)
|
||
(setq name (concat (substring name 0 (match-beginning 0))
|
||
"/"
|
||
(substring name (match-end 0)))))
|
||
(ffap-locate-file
|
||
name '(".m" "") (ffap-soft-value "Mathematica-search-path"))))
|
||
(cons "\\`\\." (defun ffap-home (name) (ffap-locate-file name t '("~"))))
|
||
(cons "\\`~/"
|
||
;; Maybe a "Lisp Code Directory" reference:
|
||
(defun ffap-lcd (name)
|
||
(and
|
||
(or
|
||
;; lisp-dir-apropos output buffer:
|
||
(string-match "Lisp Code Dir" (buffer-name))
|
||
;; Inside an LCD entry like |~/misc/ffap.el.Z|,
|
||
;; or maybe the holy LCD-Datafile itself:
|
||
(member (ffap-string-around) '("||" "|\n")))
|
||
(concat
|
||
;; lispdir.el may not be loaded yet:
|
||
(ffap-host-to-path
|
||
(ffap-soft-value "elisp-archive-host"
|
||
"archive.cis.ohio-state.edu"))
|
||
(file-name-as-directory
|
||
(ffap-soft-value "elisp-archive-directory"
|
||
"/pub/gnu/emacs/elisp-archive/"))
|
||
(substring name 2)))))
|
||
(cons "^[Rr][Ff][Cc][- #]?\\([0-9]+\\)" ; no $
|
||
(progn
|
||
(defvar ffap-rfc-path
|
||
(concat (ffap-host-to-path "ds.internic.net") "/rfc/rfc%s.txt"))
|
||
(defun ffap-rfc (name)
|
||
(format ffap-rfc-path
|
||
(substring name (match-beginning 1) (match-end 1))))))
|
||
)
|
||
"Alist of \(KEY . FUNCTION\), applied to text around point.
|
||
|
||
If ffap-file-at-point has a string NAME (maybe \"\") which is not an
|
||
existing filename, it looks for pairs with a matching KEY:
|
||
* if KEY is a symbol, it should equal `major-mode'.
|
||
* if KEY is a string, it should match NAME as a regular expression.
|
||
If KEY matches, ffap-file-at-point calls \(FUNCTION NAME\).
|
||
FUNCTION should return a file, url, or nil \(nil means keep looking
|
||
for more KEY matches\). Note URL's are ok despite the function name.")
|
||
(put 'ffap-alist 'risky-local-variable t)
|
||
|
||
|
||
;;; At-Point Functions:
|
||
|
||
(defvar ffap-string-at-point-mode-alist
|
||
'(
|
||
;; Slightly controversial decisions:
|
||
;; * strip trailing "@" and ":"
|
||
;; * no commas (good for latex)
|
||
(t "--:$+<>@-Z_a-z~" "<@" "@>;.,!?:")
|
||
(math-mode ",-:$+<>@-Z_a-z~`" "<" "@>;.,!?`:") ; allow backquote
|
||
;; Note: you are better off using "C-c C-c" in compilation buffers:
|
||
;; Maybe handle "$HOME", or "$(HOME)/bin/foo" in makefile-mode?
|
||
)
|
||
"Alist of \(MODE CHARS BEG END\), where MODE is a major-mode or t.
|
||
The data are arguments to ffap-string-at-point, used to guess the
|
||
filename at point. The `t' entry is the default.")
|
||
|
||
(defvar ffap-string-at-point-region '(1 1)
|
||
"List (BEG END), last region returned by ffap-string-at-point.")
|
||
|
||
(defvar ffap-string-at-point nil
|
||
;; Added at suggestion of RHOGEE (for ff-paths), 7/24/95.
|
||
"Last string returned by ffap-string-at-point.")
|
||
(defun ffap-string-at-point (&optional chars begpunct endpunct)
|
||
"Return maximal string of CHARS (a string) around point.
|
||
Optional BEGPUNCT chars before point are stripped from the beginning;
|
||
Optional ENDPUNCT chars after point are stripped from the end.
|
||
Without arguments, uses `ffap-string-at-point-mode-alist'.
|
||
Also sets `ffap-string-at-point' and `ffap-string-at-point-region'."
|
||
(if chars
|
||
(let* ((pt (point))
|
||
(str
|
||
(buffer-substring
|
||
(save-excursion
|
||
(skip-chars-backward chars)
|
||
(and begpunct (skip-chars-forward begpunct pt))
|
||
(setcar ffap-string-at-point-region (point)))
|
||
(save-excursion
|
||
(skip-chars-forward chars)
|
||
(and endpunct (skip-chars-backward endpunct pt))
|
||
(setcar (cdr ffap-string-at-point-region) (point))))))
|
||
(set-text-properties 0 (length str) nil str)
|
||
(setq ffap-string-at-point str))
|
||
;; Get default args from `ffap-string-at-point-mode-alist'
|
||
(apply 'ffap-string-at-point
|
||
(cdr (or (assq major-mode ffap-string-at-point-mode-alist)
|
||
(assq t ffap-string-at-point-mode-alist)
|
||
;; avoid infinite loop!
|
||
(error "ffap-string-at-point: bad alist")
|
||
)))))
|
||
|
||
(defun ffap-string-around nil
|
||
;; Sometimes useful to decide how to treat a string.
|
||
"Return string of two characters around last ffap-string-at-point."
|
||
(save-excursion
|
||
(format "%c%c"
|
||
(progn
|
||
(goto-char (car ffap-string-at-point-region))
|
||
(preceding-char)) ; maybe 0
|
||
(progn
|
||
(goto-char (nth 1 ffap-string-at-point-region))
|
||
(following-char)) ; maybe 0
|
||
)))
|
||
|
||
(defun ffap-url-at-point nil
|
||
"Return URL from around point if it exists, or nil."
|
||
;; Could use url-get-url-at-point instead ... how do they compare?
|
||
;; Both handle "URL:", ignore non-relative links, trim punctuation.
|
||
;; The other will actually look back if point is in whitespace, but
|
||
;; I would rather ffap be non-rabid in such situations.
|
||
(and
|
||
ffap-url-regexp
|
||
(or
|
||
;; In a w3 buffer button zone?
|
||
(let (tem)
|
||
(and (eq major-mode 'w3-mode)
|
||
;; assume: (boundp 'w3-zone-at) (boundp 'w3-zone-data)
|
||
(setq tem (w3-zone-at (point)))
|
||
(consp (setq tem (w3-zone-data tem)))
|
||
(nth 2 tem)))
|
||
;; Is there a reason not to strip trailing colon?
|
||
(let ((name (ffap-string-at-point
|
||
;; Allow leading digits for email/news id's:
|
||
"--:?$+@-Z_a-z~#,%" "^A-Za-z0-9" ":;.,!?")))
|
||
;; (case-fold-search t), why?
|
||
(cond
|
||
((string-match "^url:" name) (setq name (substring name 4)))
|
||
((and (string-match "\\`[^:</>@]+@[^:</>@]+[a-zA-Z]\\'" name)
|
||
;; "foo@bar": could be "mailto" or "news" (a Message-ID).
|
||
;; If not adorned with "<>", it must be "mailto".
|
||
;; Otherwise could be either, so consult `ffap-foo@bar-prefix'.
|
||
(let ((prefix (if (and (equal (ffap-string-around) "<>")
|
||
;; At least a couple of odd characters:
|
||
(string-match "[$.0-9].*[$.0-9].*@" name))
|
||
;; Could be news:
|
||
ffap-foo@bar-prefix
|
||
"mailto")))
|
||
(and prefix (setq name (concat prefix ":" name))))))
|
||
((ffap-newsgroup-p name) (setq name (concat "news:" name)))
|
||
((and (string-match "\\`[a-z0-9]+\\'" name) ; <mic> <root> <nobody>
|
||
(equal (ffap-string-around) "<>")
|
||
;; (ffap-user-p name):
|
||
(not (string-match "~" (expand-file-name (concat "~" name))))
|
||
)
|
||
(setq name (concat "mailto:" name)))
|
||
)
|
||
(and (ffap-url-p name) name)
|
||
))))
|
||
|
||
(defvar ffap-gopher-regexp
|
||
"^.*\\<\\(Type\\|Name\\|Path\\|Host\\|Port\\) *= *\\(.*\\) *$"
|
||
"Regexp Matching a line in a gopher bookmark (maybe indented).
|
||
Two subexpressions are the KEY and VALUE.")
|
||
|
||
(defun ffap-gopher-at-point nil
|
||
"If point is inside a gopher bookmark block, return its url."
|
||
;; We could use gopher-parse-bookmark from gopher.el, but it is not
|
||
;; so robust, and w3 users are better off without gopher.el anyway.
|
||
(save-excursion
|
||
(beginning-of-line)
|
||
(if (looking-at ffap-gopher-regexp)
|
||
(progn
|
||
(while (and (looking-at ffap-gopher-regexp) (not (bobp)))
|
||
(forward-line -1))
|
||
(or (looking-at ffap-gopher-regexp) (forward-line 1))
|
||
(let ((type "1") name path host (port "70"))
|
||
(while (looking-at ffap-gopher-regexp)
|
||
(let ((var (intern
|
||
(downcase
|
||
(buffer-substring (match-beginning 1)
|
||
(match-end 1)))))
|
||
(val (buffer-substring (match-beginning 2)
|
||
(match-end 2))))
|
||
(set var val)
|
||
(forward-line 1)))
|
||
(if (and path (string-match "^ftp:.*@" path))
|
||
(concat "ftp://"
|
||
(substring path 4 (1- (match-end 0)))
|
||
(substring path (match-end 0)))
|
||
(and (= (length type) 1)
|
||
host;; (ffap-machine-p host)
|
||
(concat "gopher://" host
|
||
(if (equal port "70") "" (concat ":" port))
|
||
"/" type path))))))))
|
||
|
||
(defvar ffap-ftp-sans-slash-regexp
|
||
(and
|
||
ffap-ftp-regexp
|
||
;; Note: by now, we know it is not an URL.
|
||
;; Icky regexp avoids: default: 123: foo::bar cs:pub
|
||
;; It does match on: mic@cs: cs:/pub mathcs.emory.edu: (point at end)
|
||
;; Todo: handle foo.com://path
|
||
"\\`\\([^:@]+@[^:@]+:\\|[^@.:]+\\.[^@:]+:\\|[^:]+:[~/]\\)\\([^:]\\|\\'\\)")
|
||
"Strings matching this are coerced to ftp paths by ffap.
|
||
That is, ffap just prepends \"/\". Set to nil to disable.")
|
||
|
||
(defun ffap-file-at-point nil
|
||
"Return filename from around point if it exists, or nil.
|
||
Existence test is skipped for names that look remote.
|
||
If the filename is not obvious, it also tries `ffap-alist',
|
||
which may actually result in an URL rather than a filename."
|
||
;; Note: this function does not need to look for URL's, just
|
||
;; filenames. On the other hand, it is responsible for converting
|
||
;; a pseudo-URL "site.dom://path" to an ftp path "/site.dom:/path"
|
||
(let* ((case-fold-search t) ; url prefixes are case-insensitive
|
||
(data (match-data))
|
||
(string (ffap-string-at-point)) ; use its mode-alist
|
||
(name
|
||
(condition-case nil
|
||
(substitute-in-file-name string)
|
||
(error string)))
|
||
(abs (file-name-absolute-p name))
|
||
(default-directory default-directory))
|
||
(unwind-protect
|
||
(cond
|
||
;; Immediate rejects (/ and // are too common in C++):
|
||
((member name '("" "/" "//")) nil)
|
||
;; Immediately test local filenames. If default-directory is
|
||
;; remote, you probably already have a connection.
|
||
((and (not abs) (ffap-file-exists-string name)))
|
||
;; Accept remote names without actual checking (too slow):
|
||
((if abs
|
||
(ffap-file-remote-p name)
|
||
;; Try adding a leading "/" (common omission in ftp paths):
|
||
(and
|
||
ffap-ftp-sans-slash-regexp
|
||
(string-match ffap-ftp-sans-slash-regexp name)
|
||
(ffap-file-remote-p (concat "/" name)))))
|
||
;; Ok, not remote, try the existence test even if it is absolute:
|
||
((and abs (ffap-file-exists-string name)))
|
||
;; File does not exist, try the alist:
|
||
((let ((alist ffap-alist) tem try case-fold-search)
|
||
(while (and alist (not try))
|
||
(setq tem (car alist) alist (cdr alist))
|
||
(if (or (eq major-mode (car tem))
|
||
(and (stringp (car tem))
|
||
(string-match (car tem) name)))
|
||
(and (setq try (funcall (cdr tem) name))
|
||
(setq try (or
|
||
(ffap-url-p try) ; not a file!
|
||
(ffap-file-remote-p try)
|
||
(ffap-file-exists-string try))))))
|
||
try))
|
||
;; Alist failed? Try to guess an active remote connection
|
||
;; from buffer variables, and try once more, both as an
|
||
;; absolute and relative path on that remote host.
|
||
((let* (ffap-rfs-regexp ; suppress
|
||
(remote-dir
|
||
(cond
|
||
((ffap-file-remote-p default-directory))
|
||
((and (eq major-mode 'internal-ange-ftp-mode)
|
||
(string-match "^\\*ftp \\(.*\\)@\\(.*\\)\\*$"
|
||
(buffer-name)))
|
||
(concat "/" (substring (buffer-name) 5 -1) ":"))
|
||
;; This is too often a bad idea:
|
||
;;((and (eq major-mode 'w3-mode)
|
||
;; (stringp url-current-server))
|
||
;; (host-to-ange-path url-current-server))
|
||
)))
|
||
(and remote-dir
|
||
(or
|
||
(and (string-match "\\`\\(/?~?ftp\\)/" name)
|
||
(ffap-file-exists-string
|
||
(ffap-replace-path-component
|
||
remote-dir (substring name (match-end 1)))))
|
||
(ffap-file-exists-string
|
||
(ffap-replace-path-component remote-dir name))))))
|
||
)
|
||
(store-match-data data))))
|
||
|
||
|
||
;;; ffap-read-file-or-url:
|
||
;;
|
||
;; Want to read filenames with completion as in read-file-name, but
|
||
;; also allow URL's which read-file-name-internal would truncate at
|
||
;; the "//" string. Solution here is to replace read-file-name-internal
|
||
;; with another function that does not attempt to complete url's.
|
||
|
||
;; We implement a pretty clean completion semantics to work with
|
||
;; packages like complete.el and exit-minibuffer.el. Even for
|
||
;; complete.el (v19.22), we still need to make a small patch (it has a
|
||
;; hardwired list of `minibuffer-completion-table' values which it
|
||
;; considers to deal with filenames, this ought to be a variable).
|
||
|
||
(defun ffap-read-file-or-url (prompt guess)
|
||
"Read a file or url from minibuffer, with PROMPT and initial GUESS."
|
||
(or guess (setq guess default-directory))
|
||
(let ((filep (not (ffap-url-p guess))) dir)
|
||
;; Tricky: guess may have or be a local directory, like "w3/w3.elc"
|
||
;; or "w3/" or "../el/ffap.el" or "../../../"
|
||
(if filep
|
||
(progn
|
||
(or (ffap-file-remote-p guess)
|
||
(setq guess (abbreviate-file-name (expand-file-name guess))))
|
||
(setq dir (file-name-directory guess))))
|
||
(apply
|
||
'completing-read
|
||
prompt
|
||
'ffap-read-file-or-url-internal
|
||
dir
|
||
nil
|
||
(if (and dir) (cons guess (length dir)) guess)
|
||
(list 'file-name-history)
|
||
)))
|
||
|
||
(defvar url-global-history-completion-list nil) ; variable in w3/url.el
|
||
|
||
(defun ffap-read-url-internal (string dir action)
|
||
;; Complete URL's from history, always treat given url as acceptable.
|
||
(let ((hist url-global-history-completion-list))
|
||
(cond
|
||
((not action)
|
||
(or (try-completion string hist) string))
|
||
((eq action t)
|
||
(or (all-completions string hist) (list string)))
|
||
;; lambda?
|
||
(t string))))
|
||
|
||
(defun ffap-read-file-or-url-internal (string dir action)
|
||
(if (ffap-url-p string)
|
||
(ffap-read-url-internal string dir action)
|
||
(read-file-name-internal string dir action)))
|
||
|
||
;; Unfortunately, for complete.el to work correctly, we need to vary
|
||
;; the value it sees of minibuffer-completion-table, depending on the
|
||
;; current minibuffer contents! It would be nice if it were written a
|
||
;; little more easily. I consider this a bug in complete.el, since
|
||
;; the builtin emacs functions do not have this problem.
|
||
(and
|
||
(featurep 'complete)
|
||
(require 'advice)
|
||
(defadvice PC-do-completion (around ffap-fix act)
|
||
"Work with ffap.el."
|
||
(let ((minibuffer-completion-table minibuffer-completion-table)
|
||
;; (minibuffer-completion-predicate minibuffer-completion-predicate)
|
||
)
|
||
(and (eq minibuffer-completion-table 'ffap-read-file-or-url-internal)
|
||
(setq minibuffer-completion-table
|
||
(if (ffap-url-p (buffer-string))
|
||
;; List would work better with icomplete ...
|
||
'ffap-read-url-internal
|
||
'read-file-name-internal)))
|
||
ad-do-it)))
|
||
|
||
|
||
;;; Highlighting:
|
||
;;
|
||
;; Based on overlay highlighting in Emacs 19.28 isearch.el.
|
||
|
||
(defvar ffap-highlight (and window-system t)
|
||
"If non-nil, ffap highlights the current buffer substring.")
|
||
|
||
(defvar ffap-overlay nil "Overlay used by ffap-highlight.")
|
||
|
||
(defun ffap-highlight (&optional remove)
|
||
"If `ffap-highlight' is set, highlight the guess in the buffer.
|
||
That is, the last buffer substring found by ffap-string-at-point.
|
||
Optional argument REMOVE means to remove any such highlighting.
|
||
Uses the face `ffap' if it is defined, else `highlight'."
|
||
(cond
|
||
(remove (and ffap-overlay (delete-overlay ffap-overlay)))
|
||
((not ffap-highlight) nil)
|
||
(ffap-overlay
|
||
(move-overlay ffap-overlay
|
||
(car ffap-string-at-point-region)
|
||
(nth 1 ffap-string-at-point-region)
|
||
(current-buffer)))
|
||
(t
|
||
(setq ffap-overlay (apply 'make-overlay ffap-string-at-point-region))
|
||
(overlay-put ffap-overlay 'face
|
||
(if (internal-find-face 'ffap nil)
|
||
'ffap 'highlight)))))
|
||
|
||
;;; The big enchilada:
|
||
|
||
(defun ffap-guesser nil
|
||
"Return file or URL or nil, guessed from text around point."
|
||
(or (and ffap-url-regexp
|
||
(ffap-fixup-url (or (ffap-url-at-point)
|
||
(ffap-gopher-at-point))))
|
||
(ffap-file-at-point) ; may yield url!
|
||
(ffap-fixup-machine (ffap-machine-at-point))))
|
||
|
||
(defun ffap-prompter (&optional guess)
|
||
;; Does guess and prompt step for find-file-at-point.
|
||
;; Extra complication just to do the temporary highlighting.
|
||
(unwind-protect
|
||
(ffap-read-file-or-url
|
||
(if ffap-url-regexp "Find file or URL: " "Find file: ")
|
||
(prog1
|
||
(setq guess (or guess (ffap-guesser)))
|
||
(and guess (ffap-highlight))))
|
||
(ffap-highlight t)))
|
||
|
||
;;;###autoload
|
||
(defun find-file-at-point (&optional filename)
|
||
"Find FILENAME (or url), guessing default from text around point.
|
||
If `ffap-dired-wildcards' is set, wildcard patterns are passed to dired.
|
||
See also the functions ffap-file-at-point, ffap-url-at-point.
|
||
With a prefix, this command behaves *exactly* like `ffap-file-finder'.
|
||
If `ffap-require-prefix' is set, the prefix meaning is reversed.
|
||
|
||
See ftp://ftp.mathcs.emory.edu/pub/mic/emacs/ for most recent version."
|
||
(interactive)
|
||
(if (and (interactive-p)
|
||
(if ffap-require-prefix (not current-prefix-arg)
|
||
current-prefix-arg))
|
||
;; Do exactly the ffap-file-finder command, even the prompting:
|
||
(call-interactively ffap-file-finder)
|
||
(or filename (setq filename (ffap-prompter)))
|
||
(cond
|
||
((ffap-url-p filename)
|
||
(funcall ffap-url-fetcher filename))
|
||
;; This junk more properly belongs in a modified ffap-file-finder:
|
||
((and ffap-dired-wildcards (string-match ffap-dired-wildcards filename))
|
||
(dired filename))
|
||
((or (not ffap-newfile-prompt)
|
||
(file-exists-p filename)
|
||
(y-or-n-p "File does not exist, create buffer? "))
|
||
(funcall ffap-file-finder
|
||
;; expand-file-name fixes "~/~/.emacs" bug sent by CHUCKR.
|
||
(expand-file-name filename)))
|
||
;; User does not want to find a non-existent file:
|
||
((signal 'file-error (list "Opening file buffer"
|
||
"no such file or directory"
|
||
filename))))))
|
||
|
||
;; M-x shortcut:
|
||
(fset 'ffap 'find-file-at-point)
|
||
|
||
|
||
;;; Menu support:
|
||
;;
|
||
;; Bind ffap-menu to a key if you want, since it also works in tty mode.
|
||
;; Or just use it through the ffap-at-mouse binding (next section).
|
||
|
||
(defvar ffap-menu-regexp nil
|
||
"*If non-nil, overrides `ffap-next-regexp' during ffap-menu.
|
||
Make this more restrictive for faster menu building.
|
||
For example, try \":/\" for url (and some ftp) references.")
|
||
|
||
(defvar ffap-menu-alist nil
|
||
"Buffer local menu of files and urls cached by ffap-menu.")
|
||
(make-variable-buffer-local 'ffap-menu-alist)
|
||
|
||
;;;###autoload
|
||
(defun ffap-menu (&optional rescan)
|
||
"Puts up a menu of files and urls mentioned in the buffer.
|
||
Sets mark, jumps to choice, and tries to fetch it.
|
||
Menu is cached in `ffap-menu-alist', but will always be rebuilt
|
||
with the optional RESCAN argument (a prefix interactively).
|
||
Searches buffer with `ffap-menu-regexp' (see `ffap-next-regexp')."
|
||
(interactive "P")
|
||
;; (require 'imenu) -- no longer used, but roughly emulated
|
||
(if (or (not ffap-menu-alist) rescan
|
||
;; or if the first entry is wrong:
|
||
(and ffap-menu-alist
|
||
(let ((first (car ffap-menu-alist)))
|
||
(save-excursion
|
||
(goto-char (cdr first))
|
||
(not (equal (car first) (ffap-guesser)))))))
|
||
(ffap-menu-rescan))
|
||
;; Tail recursive:
|
||
(ffap-menu-ask
|
||
(if ffap-url-regexp "Find file or URL" "Find file")
|
||
(cons (cons "*Rescan Buffer*" -1) ffap-menu-alist)
|
||
'ffap-menu-cont))
|
||
|
||
(defun ffap-menu-cont (choice) ; continuation of ffap-menu
|
||
(if (< (cdr choice) 0)
|
||
(ffap-menu t) ; *Rescan*
|
||
(push-mark)
|
||
(goto-char (cdr choice))
|
||
;; Momentary highlight:
|
||
(unwind-protect
|
||
(progn
|
||
(and ffap-highlight (ffap-guesser) (ffap-highlight))
|
||
(sit-for 0) ; display
|
||
(find-file-at-point (car choice)))
|
||
(ffap-highlight t))))
|
||
|
||
(defun ffap-menu-ask (title alist cont)
|
||
"Prompt from a menu of choices, and then apply some action.
|
||
Arguments are TITLE, ALIST, and CONT (a continuation).
|
||
This uses either a menu or the minibuffer depending on invocation.
|
||
The TITLE string is used as either the prompt or menu title.
|
||
Each (string . data) entry in ALIST defines a choice (data is ignored).
|
||
Once the user makes a choice, function CONT is applied to the entry.
|
||
Always returns nil."
|
||
;; Bug: minibuffer prompting assumes the strings are unique.
|
||
;; Todo: break up long menus into multiple panes (like imenu).
|
||
(let ((choice
|
||
(if (and (fboundp 'x-popup-menu) ; 19 or XEmacs 19.13
|
||
(boundp 'last-nonmenu-event) ; not in XEmacs 19.13
|
||
(listp last-nonmenu-event))
|
||
(x-popup-menu
|
||
t
|
||
(list ""
|
||
(cons title
|
||
(mapcar
|
||
(function (lambda (i) (cons (car i) i)))
|
||
alist))))
|
||
;; Automatically popup completion help, one way or another:
|
||
(let ((minibuffer-setup-hook 'minibuffer-completion-help)
|
||
(unread-command-char -1))
|
||
;; BUG: this code assumes that "" is not a valid choice
|
||
(completing-read
|
||
(format "%s (default %s): " title (car (car alist)))
|
||
alist nil t
|
||
;; Let first be default:
|
||
;; (if ffap-v18 (car (car alist))
|
||
;; (cons (car (car alist)) 0))
|
||
;; No, then you do not get all completions!
|
||
nil
|
||
)))))
|
||
;; Defaulting: convert "" to (car (car alist))
|
||
(and (equal choice "") (setq choice (car (car alist))))
|
||
(and (stringp choice) (setq choice (assoc choice alist)))
|
||
(if choice (funcall cont choice) (message "No choice made!")))
|
||
nil) ; return nothing
|
||
|
||
(defun ffap-menu-rescan nil
|
||
(interactive)
|
||
(let ((ffap-next-regexp (or ffap-menu-regexp ffap-next-regexp))
|
||
(range (- (point-max) (point-min))) item)
|
||
(setq ffap-menu-alist nil)
|
||
(save-excursion
|
||
(goto-char (point-min))
|
||
(while (setq item (ffap-next-guess))
|
||
(setq ffap-menu-alist (cons (cons item (point)) ffap-menu-alist))
|
||
(message "Scanning...%2d%% <%s>"
|
||
(/ (* 100 (- (point) (point-min))) range) item))))
|
||
(message "Scanning...done")
|
||
;; Remove duplicates.
|
||
(setq ffap-menu-alist ; sort by item
|
||
(sort ffap-menu-alist
|
||
(function
|
||
(lambda (a b) (string-lessp (car a) (car b))))))
|
||
(let ((ptr ffap-menu-alist))
|
||
(while (cdr ptr)
|
||
(if (equal (car (car ptr)) (car (car (cdr ptr))))
|
||
(setcdr ptr (cdr (cdr ptr)))
|
||
(setq ptr (cdr ptr)))))
|
||
(setq ffap-menu-alist ; sort by position
|
||
(sort ffap-menu-alist
|
||
(function
|
||
(lambda (a b) (< (cdr a) (cdr b)))))))
|
||
|
||
|
||
;;; Mouse Support:
|
||
;;
|
||
;; I suggest a mouse binding, something like:
|
||
;; (global-set-key [S-mouse-1] 'ffap-at-mouse)
|
||
|
||
(defvar ffap-at-mouse-fallback 'ffap-menu
|
||
"Invoked by ffap-at-mouse if no file or url found at point.
|
||
A command symbol, or nil for nothing.")
|
||
(put 'ffap-at-mouse-fallback 'risky-local-variable t)
|
||
|
||
(defun ffap-at-mouse (e)
|
||
"Find file or URL guessed from text around mouse point.
|
||
If none is found, call `ffap-at-mouse-fallback'."
|
||
(interactive "e")
|
||
(let ((guess
|
||
;; Maybe less surprising without the save-excursion?
|
||
(save-excursion
|
||
(mouse-set-point e)
|
||
;; Would like to do nothing unless click was *on* text. How?
|
||
;; (cdr (posn-col-row (event-start e))) is always same as
|
||
;; current column. For posn-x-y, need pixel-width!
|
||
(ffap-guesser))))
|
||
(cond
|
||
(guess
|
||
(ffap-highlight)
|
||
(unwind-protect
|
||
(progn
|
||
(sit-for 0) ; display
|
||
(message "Guessing `%s'" guess)
|
||
(find-file-at-point guess))
|
||
(ffap-highlight t)))
|
||
((and (interactive-p)
|
||
ffap-at-mouse-fallback)
|
||
(call-interactively ffap-at-mouse-fallback))
|
||
((message "No file or URL found at mouse click.")))))
|
||
|
||
|
||
;;; ffap-other-* commands
|
||
;; Suggested by KPC. Possible bindings for C-x 4 C-f, C-x 5 C-f.
|
||
|
||
(defun ffap-other-window nil
|
||
"Like ffap, but put buffer in another window."
|
||
(interactive)
|
||
(switch-to-buffer-other-window
|
||
(save-window-excursion (call-interactively 'ffap) (current-buffer))))
|
||
|
||
(defun ffap-other-frame nil
|
||
"Like ffap, but put buffer in another frame."
|
||
(interactive)
|
||
(switch-to-buffer-other-frame
|
||
(save-window-excursion (call-interactively 'ffap) (current-buffer))))
|
||
|
||
|
||
;;; ffap-bug:
|
||
(defun ffap-bug nil
|
||
;; Tested with Emacs 19.28 reporter.el
|
||
"Submit a bug report for ffap."
|
||
(interactive)
|
||
(require 'reporter)
|
||
(let ((reporter-prompt-for-summary-p t))
|
||
(reporter-submit-bug-report
|
||
"mic@mathcs.emory.edu" "ffap "
|
||
(mapcar 'intern (all-completions "ffap-" obarray 'boundp))
|
||
)))
|
||
(fset 'ffap-submit-bug 'ffap-bug) ; another likely name
|
||
|
||
|
||
;;; Todo, End.
|
||
;;
|
||
;; * w3 may eventually make URL's part of the filesystem!
|
||
;; this package (prompt & completion) could become much simpler
|
||
;; * improve minibuffer-completion-help display of long completions
|
||
;; * notice "machine.dom blah blah blah path/file" (how?)
|
||
;; * check X selections (x-get-selection PRIMARY/SECONDARY LENGTH/TEXT)
|
||
;; * let "/path/file#key" jump to key (anchor or regexp) in /path/file
|
||
;; * notice node in "(dired)Virtual Dired" (how to handle space?)
|
||
;; * try find-tag on symbol if TAGS is loaded (need above)
|
||
;;
|
||
;; For information on URL/URI syntax, try:
|
||
;; <http://ds.internic.net/rfc/rfc1630.txt>
|
||
;; <http://www.w3.org/hypertext/WWW/Protocols/Overview.html>
|
||
;; <http://info.cern.ch/hypertext/WWW/Addressing/Addressing.html>
|
||
|
||
;; Local Variables?
|
||
;; foo: bar
|
||
;; End:
|
||
|
||
|
||
;;; ffap.el ends here
|