emacs: lisp/ffap.el comparison

comparison lisp/ffap.el @ 18291:130a48e6cc13

(ffap-soft-value): Make this a function again; the macro version does intern-soft too early. Deleted XEmacs-specific code. (ffap-string-at-point-mode-alist): added "=" and "&" to the url syntax, as suggested by SJE. (ffap-read-file-or-url): fixed the HIST argument to completing-read (only visible in XEmacs?), as reported by Christoph Wedler <wedler@fmi.uni-passau.de>. (ffap-kpathsea-expand-path) New func, replaces ffap-add-subdirs, a first attempt at kpathsea emulation. Also convert "" to "." in path lists, for XEmacs. Suggestions from SJE. Added mouse-track support (but no binding), as suggested by MDB. Moved Emacs mouse bindings from "down-mouse" events to ordinary mouse events. (ffap-alist): added ffap-fortran-mode, as requested by MDB. Rewrote and merged XEmacs support, eliminating file ffap-xe.el. Modified ffap-other-frame to work in dedicated frames, fixing a bug reported by JENS. (ffap-menu-rescan): avoid modifying the buffer. Two bugs reported by Christoph Wedler <wedler@fmi.uni-passau.de>: (ffap-fixup-url): avoid autoloading through url-normalize-url. (ffap-read-file-or-url): for XEmacs, give extra HACK-HOMEDIR arg to `abbreviate-file-name'. (ffap-file-at-point): suppress errors from `ffap-alist'. (ffap-url-at-point): modified regexp to accept mail hostnames ending with a digit. Fixes bug report of SJE. (ffap-url-at-point): use higher level function (w3-view-this-url t) suggested by wmperry, instead of w3-zone-at/w3-zone-data or widget-at/widget-get. (ffap-url-at-point): modified to work with w3-version "WWW 2.3.64 1996/06/02 06:20:23" alpha, which uses the 'widget package rather than the old w3-zone-at. Bug was reported by JENS. Adopted comments and doc strings to Emacs coding conventions. Reorganized. Retired v18 support. (ffap-bindings): Offers a default installation. (ffap-string-at-point): Modified arguments. (ffap-gnus-hook): Updated for Gnus 5. (ffap-tex-init): Delayed initialization of `ffap-tex-path'. (ffap-dired): New entry in `ffap-alist'. (ffap-menu-rescan): May fontify the choices in buffer. (ffap-read-file-or-url): `PC-completion-as-file-name-predicate' used if available, to work with complete.el.

author	Karl Heuer <kwzh@gnu.org>
date	Wed, 18 Jun 1997 04:24:37 +0000
parents	fcbe987b332a
children	83ff1ecdb0e3

comparison

equal deleted inserted replaced

-:d87d578b953d
+:130a48e6cc13
-;;; ffap.el --- find file or URL at point
+;;; ffap.el --- find file (or url) at point
+;;
 ;; Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
+;;
 ;; Author: Michelangelo Grigni <mic@mathcs.emory.edu>
 ;; Created: 29 Mar 1993
 ;; Keywords: files, hypermedia, matching, mouse
-;; X-Latest: ftp://ftp.mathcs.emory.edu:/pub/mic/emacs/
+;; X-URL: ftp://ftp.mathcs.emory.edu:/pub/mic/emacs/
 ;; 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
 ;;
 ;; C-x C-f       find-file-at-point (abbreviated as ffap)
 ;; C-x 4 f       ffap-other-window
 ;; C-x 5 f       ffap-other-frame
 ;; S-mouse-3     ffap-at-mouse
+;; C-S-mouse-3   ffap-menu
 ;;
 ;; ffap-bindings also adds hooks to make the following local bindings
 ;; in vm, gnus, and rmail:
 ;;
-;; M-l         ffap-next, or ffap-gnus-next in gnus
+;; M-l         ffap-next, or ffap-gnus-next in gnus (l == "link")
-;; M-m         ffap-menu, or ffap-gnus-menu in gnus
+;; M-m         ffap-menu, or ffap-gnus-menu in gnus (m == "menu")
 ;;
 ;; If you do not like these bindings, modify the variable
 ;; `ffap-bindings', or write your own.
 ;;
 ;; If you use ange-ftp, browse-url, complete, efs, or w3, it is best
 ;; ffap uses w3 (if found) or else browse-url to fetch URL's.  For
 ;; a hairier `ffap-url-fetcher', try ffap-url.el (same ftp site).
 ;; Also, you can add `ffap-menu-rescan' to various hooks to fontify
 ;; the file and URL references within a buffer.
+;;; Change Log:
+;;
+;; The History and Contributors moved to ffap.LOG (same ftp site),
+;; which also has some old examples and commentary from ffap 1.5.
 ;;; Todo list:
-;; * recognize paths inside /usr/bin:/bin:/etc, ./ffap.el:80:
+;; * use kpsewhich
-;; * let "/path/file#key" jump to key (offset or regexp) in /path/file
+;; * let "/path/file#key" jump to key (tag or regexp) in /path/file
 ;; * find file of symbol if TAGS is loaded (like above)
-;; * break up long menus into multiple panes (like imenu?)
+;; * break long menus into multiple panes (like imenu?)
-;; * notice node in "(dired)Virtual Dired" (handle the space?)
+;; * notice node in "(dired)Virtual Dired" (quotes, parentheses, whitespace)
 ;; * notice "machine.dom blah blah blah path/file" (how?)
-;; * if w3 becomes standard, could rewrite to use its functions
+;; * as w3 becomes standard, rewrite to rely more on its functions
 ;; * regexp options for ffap-string-at-point, like font-lock (MCOOK)
 ;; * v19: could replace `ffap-locate-file' with a quieter `locate-library'
-;; * support for custom.el
+;; * handle "$(VAR)" in Makefiles
-;; + handle "$(HOME)" in Makefiles?
+;; * use the font-lock machinery
-;; + modify `font-lock-keywords' to do fontification
 ;;; Code:
 (provide 'ffap)
-;; Versions: This file is tested with Emacs 19.30.  It mostly works
+;; The code is organized in pages, separated by formfeed characters.
-;; with XEmacs, but get ffap-xe.el for the popup menu.  Emacs 18 is
+;; See the next two pages for standard customization ideas.
-;; now abandoned (get ffap-15.el instead).
-(defvar ffap-xemacs (and (string-match "X[Ee]macs" emacs-version) t)
-"Whether ffap thinks it is running under XEmacs.")
 ;;; User Variables:
 (defgroup ffap nil
 "Find file or URL at point."
 :group 'matching)
-;; This function is used inside defvars:
+(defun ffap-soft-value (name &optional default)
-(defmacro ffap-soft-value (name &optional default)
 "Return value of symbol with NAME, if it is interned.
 Otherwise return nil (or the optional DEFAULT value)."
 ;; Bug: (ffap-soft-value "nil" 5) --> 5
 (let ((sym (intern-soft name)))
-(if (and sym (boundp sym))
+(if (and sym (boundp sym)) (symbol-value sym) default)))
-	sym
-`(quote ,default))))
 (defcustom ffap-ftp-regexp
-(and
+;; This used to test for ange-ftp or efs being present, but it should be
-(or (featurep 'ange-ftp)
+;; harmless (and simpler) to give it this value unconditionally.
-(featurep 'efs)
+"\\`/[^/:]+:"
-(and (boundp 'file-name-handler-alist) ; v19
+"*Paths matching this regexp are treated as remote ftp paths by ffap.
-	    (or (rassq 'ange-ftp-hook-function file-name-handler-alist)
+If nil, ffap neither recognizes nor generates such paths."
-		(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."
 :type '(choice (const :tag "Disable" nil)
+		 (const :tag "Standard" "\\`/[^/:]+:")
 		 regexp)
 :group 'ffap)
 (defcustom ffap-url-unwrap-local t
-"*If non-nil, convert \"file:\" URL to local path before prompting."
+"*If non-nil, convert \"file:\" url to local path before prompting."
 :type 'boolean
 :group 'ffap)
 (defcustom ffap-url-unwrap-remote t
-"*If non-nil, convert \"ftp:\" URL to remote path before prompting.
+"*If non-nil, convert \"ftp:\" url to remote path before prompting.
 This is ignored if `ffap-ftp-regexp' is nil."
 :type 'boolean
 :group 'ffap)
-(defcustom ffap-ftp-default-user
+(defcustom ffap-ftp-default-user "anonymous"
-"anonymous"
 "*User name in ftp paths generated by `ffap-host-to-path'.
-nil to rely on `efs-default-user' or `ange-ftp-default-user'."
+Note this name may be omitted if it equals the default
-:type '(choice (const :tag "Default" nil)
+\(either `efs-default-user' or `ange-ftp-default-user'\)."
-		 string)
+:type 'string
 :group 'ffap)
 (defcustom ffap-rfs-regexp
 ;; Remote file access built into file system?  HP rfa or Andrew afs:
 "\\`/\\(afs\\|net\\)/."
 "Regexp matching URL's.  nil to disable URL features in ffap.")
 (defcustom ffap-foo-at-bar-prefix "mailto"
 "*Presumed URL prefix type of strings like \"<foo.9z@bar>\".
 Sensible values are nil, \"news\", or \"mailto\"."
-:type 'string
+:type '(choice (const "mailto")
+		 (const "news")
+		 (const :tag "Disable" nil)
+		 ;; string -- possible, but not really useful
+		 )
 :group 'ffap)
-;;; Peanut Gallery:
+;;; Peanut Gallery (More User Variables):
 ;;
 ;; 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 for features that you like, put an appropriate
 ;; enabler in your .emacs file.
-(defcustom ffap-dired-wildcards nil	; "[*?][^/]*$"
+(defcustom ffap-dired-wildcards nil
 ;; Suggestion from RHOGEE, 07 Jul 1994.  Disabled, dired is still
 ;; available by "C-x C-d <pattern>", and valid filenames may
 ;; sometimes 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'."
-:type '(choice (const :tag "off" nil)
+:type '(choice (const :tag "Disable" nil)
-		 regexp)
+		 (const :tag "Enable" "[*?][^/]*\\'")
+		 ;; regexp -- probably not useful
+		 )
 :group 'ffap)
-(defcustom ffap-newfile-prompt nil		; t
+(defcustom ffap-newfile-prompt nil
 ;; Suggestion from RHOGEE, 11 Jul 1994.  Disabled, I think this is
 ;; better handled by `find-file-not-found-hooks'.
 "*Whether `find-file-at-point' prompts about a nonexistent file."
 :type 'boolean
 :group 'ffap)
 ;; http://www.ncsa.uiuc.edu/SDG/Software/XMosaic/remote-control.html
 ;; http://home.netscape.com/newsref/std/x-remote.html
 "*A function of one argument, called by ffap to fetch an URL.
 Reasonable choices are `w3-fetch' or `browse-url-netscape'.
 For a fancier alternative, get ffap-url.el."
-:type 'function
+:type '(choice (const w3-fetch)
+		 (const browse-url-netscape)
+		 (const browse-url-mosaic)
+		 function)
 :group 'ffap)
 (put 'ffap-url-fetcher 'risky-local-variable t)
-;;; Command ffap-next:
+;;; Compatibility (XEmacs code suppressed in this version):
+(progn
+(defalias 'ffap-make-overlay 'make-overlay)
+(defalias 'ffap-delete-overlay 'delete-overlay) ; reusable
+(defalias 'ffap-move-overlay 'move-overlay)
+(defalias 'ffap-overlay-put 'overlay-put) ; 'face
+(defalias 'ffap-find-face 'internal-find-face)
+(defun ffap-mouse-event nil		; current mouse event, or nil
+(and (listp last-nonmenu-event) last-nonmenu-event))
+(defun ffap-event-buffer (event) (window-buffer (car (event-start event))))
+)
+;;; Find Next Thing in buffer (`ffap-next'):
 ;;
 ;; Original ffap-next-url (URL's only) from RPECK 30 Mar 1995.  Since
 ;; then, broke it up into ffap-next-guess (noninteractive) and
 ;; ffap-next (a command).  It now work on files as well as url's.
 (if (interactive-p)
 	(call-interactively 'ffap-next)
 (ffap-next back wrap))))
-;;; Remote machines and paths:
+;;; Machines (`ffap-machine-p'):
-(defun ffap-replace-path-component (fullname name)
-"In remote FULLNAME, replace path with NAME.  May return nil."
-;; Use ange-ftp or efs if loaded, but do not load them otherwise.
-(let (found)
-(mapcar
-(function (lambda (sym) (and (fboundp sym) (setq found sym))))
-'(
-efs-replace-path-component
-ange-ftp-replace-path-component
-ange-ftp-replace-name-component
-))
-(and found
-	 (fset 'ffap-replace-path-component found)
-	 (funcall found fullname name))))
-;; (ffap-replace-path-component "/who@foo.com:/whatever" "/new")
-(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."
-(and file				; quietly reject 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.
 (defcustom ffap-machine-p-local 'reject	; this happens often
-"*A symbol, one of: ping, accept, reject.
+"*A symbol, one of: `ping', `accept', `reject'.
 What `ffap-machine-p' does with hostnames that have no domain."
 :type '(choice (const ping)
 		 (const accept)
 		 (const reject))
 :group 'ffap)
 		 ;; Other errors mean the host exists:
 		 (nth 2 error)))
 	      ;; Could be "Unknown service":
 	      (t (signal (car error) (cdr error))))))))))))
+;;; Possibly Remote Resources:
+(defun ffap-replace-path-component (fullname name)
+"In remote FULLNAME, replace path with NAME.  May return nil."
+;; Use ange-ftp or efs if loaded, but do not load them otherwise.
+(let (found)
+(mapcar
+(function (lambda (sym) (and (fboundp sym) (setq found sym))))
+'(
+efs-replace-path-component
+ange-ftp-replace-path-component
+ange-ftp-replace-name-component
+))
+(and found
+	 (fset 'ffap-replace-path-component found)
+	 (funcall found fullname name))))
+;; (ffap-replace-path-component "/who@foo.com:/whatever" "/new")
+(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."
+(and file				; quietly reject nil
+(let ((exists (file-exists-p file)))
+	 (and exists (if (stringp exists) exists file)))))
 (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 "/cssun.mathcs.emory.edu://path")
 ;; (ffap-file-remote-p "/ffap.el:80")
 "Return machine name at point if it exists, or nil."
 (let ((mach (ffap-string-at-point 'machine)))
 (and (ffap-machine-p mach) mach)))
 (defsubst ffap-host-to-path (host)
-"Convert HOST to something like \"/anonymous@HOST:\".
+"Convert HOST to something like \"/USER@HOST:\" or \"/HOST:\".
 Looks at `ffap-ftp-default-user', returns \"\" for \"localhost\"."
-(if (equal host "localhost") ""
+(if (equal host "localhost")
-(concat "/"
+""
-	    ffap-ftp-default-user (and ffap-ftp-default-user "@")
+(let ((user ffap-ftp-default-user))
-	    host ":")))
+;; Avoid including the user if it is same as default:
+(if (or (equal user (ffap-soft-value "ange-ftp-default-user"))
+	      (equal user (ffap-soft-value "efs-default-user")))
+	  (setq user nil))
+(concat "/" user (and user "@") host ":"))))
 (defun ffap-fixup-machine (mach)
 ;; Convert a hostname into an url, an ftp path, or nil.
 (cond
 ((not (and ffap-url-regexp (stringp mach))) nil)
 (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:
+;; This might autoload the url package, oh well:
 (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':
+;;; Path Handling:
 ;;
-;; Search actions depending on the major-mode or extensions of the
+;; The upcoming ffap-alist actions need various utilities to prepare
-;; current name.  Note all the little defun's could be broken out, at
+;; and search paths of directories.  Too many features here.
-;; some loss of locality.  A good example of featuritis.
+;; (defun ffap-last (l) (while (cdr l) (setq l (cdr l))) l)
-;; First, some helpers for functions in `ffap-alist':
+;; (defun ffap-splice (func inlist)
+;;  "Equivalent to (apply 'nconc (mapcar FUNC INLIST)), but less consing."
+;;  (let* ((head (cons 17 nil)) (last head))
+;;    (while inlist
+;;      (setcdr last (funcall func (car inlist)))
+;;      (setq last (ffap-last last) inlist (cdr inlist)))
+;;    (cdr head)))
 (defun ffap-list-env (env &optional empty)
-;; Replace this with parse-colon-path (lisp/files.el)?
+"Return a list of strings parsed from environment variable ENV.
-"Directory list parsed from path envinronment variable ENV.
+Optional EMPTY is the default list if \(getenv ENV\) is undefined, and
-Optional EMPTY is default if (getenv ENV) is undefined, and is also
+also is substituted for the first empty-string component, if there is one.
-substituted for the first empty-string component, if there is one.
+Uses `path-separator' to separate the path into substrings."
-Uses `path-separator' to separate the path into directories."
+;; We cannot use parse-colon-path (files.el), since it kills
-;; Derived from psg-list-env in RHOGEE's ff-paths and
+;; "//" entries using file-name-as-directory.
-;; bib-cite packages.  The `empty' argument is intended to mimic
+;; Similar: dired-split, TeX-split-string, and RHOGEE's psg-list-env
-;; the semantics of TeX/BibTeX variables, it is substituted for
+;; in ff-paths and bib-cite.  The EMPTY arg may help mimic kpathsea.
-;; 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))
 	(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
+	     (progn			; allow string or list here
 	       (setcdr match (append (cdr-safe empty) (cdr match)))
 	       (setcar match (or (car-safe empty) empty))))
 	ret)))
 (defun ffap-reduce-path (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)
+(defun ffap-all-subdirs (dir &optional depth)
-"Return PATH augmented with its immediate subdirectories."
+"Return list all subdirectories under DIR, starting with itself.
-;; (ffap-add-subdirs '("/notexist" "~"))
+Directories beginning with \".\" are ignored, and directory symlinks
-(let (ret subs)
+are listed but never searched (to avoid loops).
-(while path
+Optional DEPTH limits search depth."
-(mapcar
+(and (file-exists-p dir)
-(function
+(ffap-all-subdirs-loop (expand-file-name dir) (or depth -1))))
-	(lambda (f) (and (file-directory-p f) (setq ret (cons f ret)))))
-(condition-case nil
+(defun ffap-all-subdirs-loop (dir depth) ; internal
-	   (directory-files (car path) t "[^.]")
+(setq depth (1- depth))
-	 (error nil)))
+(cons dir
-(setq ret (cons (car path) ret)
+	(and (not (eq depth -1))
-	    path (cdr path)))
+	     (apply 'nconc
-(nreverse ret)))
+		    (mapcar
+		     (function
+		      (lambda (d)
+			(cond
+			 ((not (file-directory-p d)) nil)
+			 ((file-symlink-p d) (list d))
+			 (t (ffap-all-subdirs-loop d depth)))))
+		     (directory-files dir t "\\`[^.]")
+		     )))))
+(defvar ffap-kpathsea-depth 1
+"Bound on depth of subdirectory search in `ffap-kpathsea-expand-path'.
+Set to 0 to avoid all searching, or nil for no limit.")
+(defun ffap-kpathsea-expand-path (path)
+"Replace each \"//\"-suffixed dir in PATH by a list of its subdirs.
+The subdirs begin with the original directory, and the depth of the
+search is bounded by `ffap-kpathsea-depth'.  This is intended to mimic
+kpathsea, a library used by some versions of TeX."
+(apply 'nconc
+	 (mapcar
+	  (function
+	   (lambda (dir)
+	     (if (string-match "[^/]//\\'" dir)
+		 (ffap-all-subdirs (substring dir 0 -2) ffap-kpathsea-depth)
+	       (list dir))))
+	  path)))
+(defvar ffap-locate-jka-suffixes t
+"List of compression suffixes tried by `ffap-locate-file'.
+If not a list, it will be initialized by `ffap-locate-file', depending
+on whether you use jka-compr (a.k.a. `auto-compression-mode').
+Typical values are nil or '(\".gz\" \".Z\").") ; .z is dead
+(defun ffap-locate-file (file &optional nosuffix path)
+;; Note the Emacs 20 version of locate-library could almost
+;; replace this function, except that it does not let us overrride
+;; the list of suffixes.
+"A generic path-searching function, mimics `load' by default.
+Returns path to file that \(load FILE\) would load, or nil.
+Optional NOSUFFIX, if nil or t, is like the fourth argument
+for load: whether to try the suffixes (\".elc\" \".el\" \"\").
+If a nonempty list, it is a list of suffixes to try instead.
+Optional PATH is a list of directories instead of `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" "")))))
+;; Note we no longer check for old versions of jka-compr, that
+;; would aggressively try to convert any foo to foo.gz.
+(or (listp ffap-locate-jka-suffixes)
+	(setq ffap-locate-jka-suffixes
+	      (and (rassq 'jka-compr-handler file-name-handler-alist)
+		   '(".gz" ".Z"))))	; ".z" is dead, "" is implicit
+(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)))
+;;; Action List (`ffap-alist'):
+;;
+;; These search actions depend on the major-mode or regexps matching
+;; the current name.  The little functions and their variables are
+;; deferred to the next section, at some loss of "code locality".  A
+;; good example of featuritis.  Trim this list for speed.
 (defvar ffap-alist
-;; A big mess!  Parts are probably useless.
 '(
-("\\.info\\'" . ffap-info)
+("" . ffap-completable)		; completion, slow on some systems
-;; Since so many info files do not have .info extension, also do this:
+("\\.info\\'" . ffap-info)		; gzip.info
-("\\`info/" . ffap-info-2)
+("\\`info/" . ffap-info-2)		; info/emacs
-("\\`[-a-z]+\\'" . ffap-info-3)
+("\\`[-a-z]+\\'" . ffap-info-3)	; (emacs)Top [only in the parentheses]
-("\\.elc?\\'" . ffap-el)
+("\\.elc?\\'" . ffap-el)		; simple.el, simple.elc
-(emacs-lisp-mode . ffap-el-mode)
+(emacs-lisp-mode . ffap-el-mode)	; rmail, gnus, simple, custom
-(finder-mode . ffap-el-mode)	; v19: {C-h p}
+(finder-mode . ffap-el-mode)	; type {C-h p} and try it
-(help-mode . ffap-el-mode)		; v19.29
+(help-mode . ffap-el-mode)		; maybe useful
-(c++-mode . ffap-c-mode)
+(c++-mode . ffap-c-mode)		; search ffap-c-path
-(cc-mode . ffap-c-mode)
+(cc-mode . ffap-c-mode)		; same
-("\\.\\([chCH]\\|cc\\|hh\\)\\'" . ffap-c-mode)
+("\\.\\([chCH]\\|cc\\|hh\\)\\'" . ffap-c-mode) ; stdio.h
-(tex-mode . ffap-tex-mode)
+(fortran-mode . ffap-fortran-mode)	; FORTRAN requested by MDB
-(latex-mode . ffap-latex-mode)
+("\\.[fF]\\'" . ffap-fortran-mode)
+(tex-mode . ffap-tex-mode)		; search ffap-tex-path
+(latex-mode . ffap-latex-mode)	; similar
 ("\\.\\(tex\\|sty\\|doc\\|cls\\)\\'" . ffap-tex)
-("\\.bib\\'" . ffap-bib)
+("\\.bib\\'" . ffap-bib)		; search ffap-bib-path
-("\\`\\." . ffap-home)
+("\\`\\." . ffap-home)		; .emacs, .bashrc, .profile
-("\\`~/" . ffap-lcd)
+("\\`~/" . ffap-lcd)		; |~/misc/ffap.el.Z|
 ("^[Rr][Ff][Cc][- #]?\\([0-9]+\\)"	; no $
-. ffap-rfc)
+. ffap-rfc)			; "100% RFC2100 compliant"
-("\\`[^/]*\\'" . ffap-dired))
+(dired-mode . ffap-dired)		; maybe in a subdirectory
+)
 "Alist of \(KEY . FUNCTION\) pairs parsed by `ffap-file-at-point'.
 If string NAME at point (maybe \"\") is not a file or url, these pairs
 specify actions to try creating such a string.  A pair matches if either
 KEY is a symbol, and it equals `major-mode', or
 KEY is a string, it should matches NAME as a regexp.
 On a match, \(FUNCTION NAME\) is called and should return a file, an
 url, or nil. If nil, search the alist for further matches.")
 (put 'ffap-alist 'risky-local-variable t)
-(defun ffap-home (name) (locate-library name t '("~")))
+;;; Action Definitions:
+;;
+;; Define various default members of `ffap-alist'.
+(defun ffap-completable (name)
+(let* ((dir (or (file-name-directory name) default-directory))
+	 (cmp (file-name-completion (file-name-nondirectory name) dir)))
+(and cmp (concat dir cmp))))
+(defun ffap-home (name) (ffap-locate-file name t '("~")))
 (defun ffap-info (name)
-(locate-library
+(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/")))))
 (defun ffap-info-2 (name) (ffap-info (substring name 5)))
-;; This ignores the node! "(emacs)Top" same as "(emacs)Intro"
 (defun ffap-info-3 (name)
+;; This ignores the node! "(emacs)Top" same as "(emacs)Intro"
 (and (equal (ffap-string-around) "()") (ffap-info name)))
-(defun ffap-el (name) (locate-library name t))
+(defun ffap-el (name) (ffap-locate-file name t))
-;; Need better defaults here!
+(defun ffap-el-mode (name)
-(defvar ffap-c-path '("/usr/include" "/usr/local/include"))
+;; If name == "foo.el" we will skip it, since ffap-el already
+;; searched for it once.  (This assumes the default ffap-alist.)
+(and (not (string-match "\\.el\\'" name))
+(ffap-locate-file name '(".el"))))
+(defvar ffap-c-path
+;; Need smarter defaults here!  Suggestions welcome.
+'("/usr/include" "/usr/local/include"))
 (defun ffap-c-mode (name)
-(locate-library name t ffap-c-path))
+(ffap-locate-file name t ffap-c-path))
-(defun ffap-el-mode (name)
+(defvar ffap-fortran-path '("../include" "/usr/include"))
-;; We do not bother with "" here, since it was considered above.
-;; Also ignore "elc", for speed (who else reads elc files?)
+(defun ffap-fortran-mode (name)
-(and (not (string-match "\\.el\\'" name))
+(ffap-locate-file name t ffap-fortran-path))
-(locate-library name '(".el"))))
-;; Complicated because auctex may not be loaded yet.
 (defvar ffap-tex-path
 t				; delayed initialization
 "Path where `ffap-tex-mode' looks for tex files.
 If t, `ffap-tex-init' will initialize this when needed.")
 (defun ffap-tex-init nil
 ;; Compute ffap-tex-path if it is now t.
 (and (eq t ffap-tex-path)
+;; this may be slow, so say something
 (message "Initializing ffap-tex-path ...")
 (setq ffap-tex-path
 	     (ffap-reduce-path
-	      (append
+	      (cons
-	       (list ".")
+	       "."
-	       (ffap-list-env "TEXINPUTS")
+	       (ffap-kpathsea-expand-path
-	       ;; (ffap-list-env "BIBINPUTS")
+		(append
-	       (ffap-add-subdirs
+		 (ffap-list-env "TEXINPUTS")
-		(ffap-list-env "TEXINPUTS_SUBDIR"
+		 ;; (ffap-list-env "BIBINPUTS")
-			       (ffap-soft-value
+		 (ffap-soft-value
-				"TeX-macro-global"
+		  "TeX-macro-global"	; AUCTeX
-				'("/usr/local/lib/tex/macros"
+		  '("/usr/local/lib/tex/macros"
-				  "/usr/local/lib/tex/inputs")
+		    "/usr/local/lib/tex/inputs")))))))))
-				))))))))
 (defun ffap-tex-mode (name)
 (ffap-tex-init)
-(locate-library name '(".tex" "") ffap-tex-path))
+(ffap-locate-file name '(".tex" "") ffap-tex-path))
 (defun ffap-latex-mode (name)
 (ffap-tex-init)
-;; Any real need for "" here?
+;; only rare need for ""
-(locate-library name '(".cls" ".sty" ".tex" "")
+(ffap-locate-file name '(".cls" ".sty" ".tex" "") ffap-tex-path))
-		  ffap-tex-path))
 (defun ffap-tex (name)
 (ffap-tex-init)
-(locate-library name t ffap-tex-path))
+(ffap-locate-file name t ffap-tex-path))
+(defvar ffap-bib-path
+(ffap-list-env "BIBINPUTS"
+		 (ffap-reduce-path
+		  '(
+		    ;; a few wild guesses, need better
+		    "/usr/local/lib/tex/macros/bib" ; Solaris?
+		    "/usr/lib/texmf/bibtex/bib"	; Linux?
+		    ))))
 (defun ffap-bib (name)
-(locate-library
+(ffap-locate-file name t ffap-bib-path))
-name t
-(ffap-list-env "BIBINPUTS" '("/usr/local/lib/tex/macros/bib"))))
 (defun ffap-dired (name)
 (let ((pt (point)) dir try)
 (save-excursion
 (and (progn
 (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))))
 ;;; At-Point Functions:
 (defvar ffap-string-at-point-mode-alist
 '(
 ;; Slightly controversial decisions:
 ;; * strip trailing "@" and ":"
 ;; * no commas (good for latex)
 (file "--:$+<>@-Z_a-z~" "<@" "@>;.,!?:")
 ;; An url, or maybe a email/news message-id:
-(url "--:?$+@-Z_a-z~#,%" "^A-Za-z0-9" ":;.,!?")
+(url "--:=&?$+@-Z_a-z~#,%" "^A-Za-z0-9" ":;.,!?")
 ;; Find a string that does *not* contain a colon:
 (nocolon "--9$+<>@-Z_a-z~" "<@" "@>;.,!?")
 ;; A machine:
 (machine "-a-zA-Z0-9." "" ".")
 ;; Mathematica paths: allow backquotes
 	     (setcar ffap-string-at-point-region (point)))
 	   (save-excursion
 	     (skip-chars-forward (car args))
 	     (skip-chars-backward (nth 2 args) pt)
 	     (setcar (cdr ffap-string-at-point-region) (point))))))
-(or ffap-xemacs (set-text-properties 0 (length str) nil str))
+(set-text-properties 0 (length str) nil str)
 (setq ffap-string-at-point str)))
 (defun ffap-string-around nil
 ;; Sometimes useful to decide how to treat a string.
 "Return string of two chars around last `ffap-string-at-point'.
 (defun ffap-url-at-point nil
 "Return url from around point if it exists, or nil."
 ;; Could use w3's url-get-url-at-point instead.  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.
+;; ffap be less aggressive in such situations.
 (and
 ffap-url-regexp
 (or
-;; In a w3 buffer button zone?
+;; In a w3 buffer button?
-(let (tem)
+(and (eq major-mode 'w3-mode)
-(and (eq major-mode 'w3-mode)
+	 ;; interface recommended by wmperry:
-	   ;; assume: (boundp 'w3-zone-at) (boundp 'w3-zone-data)
+	 (w3-view-this-url t))
-	   (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 'url)))
-;; (case-fold-search t), why?
 (cond
 ((string-match "^url:" name) (setq name (substring name 4)))
-((and (string-match "\\`[^:</>@]+@[^:</>@]+[a-zA-Z]\\'" name)
+((and (string-match "\\`[^:</>@]+@[^:</>@]+[a-zA-Z0-9]\\'" name)
 	     ;; "foo@bar": could be "mailto" or "news" (a Message-ID).
-	     ;; If not adorned with "<>", it must be "mailto".
+	     ;; Without "<>" it must be "mailto".  Otherwise could be
-	     ;;	Otherwise could be either, so consult `ffap-foo-at-bar-prefix'.
+	     ;; either, so consult `ffap-foo-at-bar-prefix'.
 	     (let ((prefix (if (and (equal (ffap-string-around) "<>")
-				    ;; At least a couple of odd characters:
+				    ;; Expect some odd characters:
 				    (string-match "[$.0-9].*[$.0-9].*@" name))
 			       ;; Could be news:
 			       ffap-foo-at-bar-prefix
 			     "mailto")))
 	       (and prefix (setq name (concat prefix ":" name))))))
 	    (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))
+		  (and (setq try
+			     (condition-case nil
+				 (funcall (cdr tem) name)
+			       (error nil)))
 		       (setq try (or
 				  (ffap-url-p try) ; not a file!
 				  (ffap-file-remote-p try)
 				  (ffap-file-exists-string try))))))
 	    try))
 		   (ffap-replace-path-component remote-dir name))))))
 	 )
 (store-match-data data))))
-;;; ffap-read-file-or-url:
+;;; Prompting (`ffap-read-file-or-url'):
 ;;
 ;; We want to complete filenames as in read-file-name, but also url's
 ;; which read-file-name-internal would truncate at the "//" string.
 ;; The solution here is to replace read-file-name-internal with
 ;; `ffap-read-file-or-url-internal', which checks the minibuffer
 		'read-file-name-internal
 	      minibuffer-completion-table)))
 ad-do-it))))
-;;; Highlighting:
+;;; Highlighting (`ffap-highlight'):
 ;;
 ;; 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-highlight-overlay nil "Overlay used by `ffap-highlight'.")
+(defvar ffap-highlight-overlay nil
+"Overlay used by `ffap-highlight'.")
 (defun ffap-highlight (&optional remove)
 "If `ffap-highlight' is set, highlight the guess in this 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, or else `highlight'."
 (cond
-(remove (and ffap-highlight-overlay (delete-overlay ffap-highlight-overlay)))
+(remove
+(and ffap-highlight-overlay
+	 (ffap-delete-overlay ffap-highlight-overlay)))
 ((not ffap-highlight) nil)
 (ffap-highlight-overlay
-(move-overlay ffap-highlight-overlay
+(ffap-move-overlay ffap-highlight-overlay
-		  (car ffap-string-at-point-region)
+		       (car ffap-string-at-point-region)
-		  (nth 1 ffap-string-at-point-region)
+		       (nth 1 ffap-string-at-point-region)
-		  (current-buffer)))
+		       (current-buffer)))
 (t
-(setq ffap-highlight-overlay (apply 'make-overlay ffap-string-at-point-region))
+(setq ffap-highlight-overlay
-(overlay-put ffap-highlight-overlay 'face
+	  (apply 'ffap-make-overlay ffap-string-at-point-region))
-		 (if (internal-find-face 'ffap nil)
+(ffap-overlay-put ffap-highlight-overlay 'face
-		     'ffap 'highlight)))))
+		      (if (ffap-find-face 'ffap)
+			  'ffap 'highlight)))))
-;;; The big enchilada:
+;;; The big cheese (`ffap'):
 (defun ffap-guesser nil
-"Return file or url or nil, guessed from text around point."
+"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))))
 	 ))
 (ffap-highlight t)))
 ;;;###autoload
 (defun find-file-at-point (&optional filename)
-"Find FILENAME (or url), guessing default from text around point.
+"Find FILENAME, guessing a default from text around point.
-If `ffap-dired-wildcards' is set, wildcard patterns are passed to dired.
+If `ffap-url-regexp' is not nil, the FILENAME may also be an URL.
-See also the functions `ffap-file-at-point', `ffap-url-at-point'.
+With a prefix, this command behaves exactly like `ffap-file-finder'.
-With a prefix, this command behaves *exactly* like `ffap-file-finder'.
 If `ffap-require-prefix' is set, the prefix meaning is reversed.
+See also the variables `ffap-dired-wildcards', `ffap-newfile-prompt',
+and the functions `ffap-file-at-point' and `ffap-url-at-point'.
 See <ftp://ftp.mathcs.emory.edu/pub/mic/emacs/> for latest version."
 (interactive)
 (if (and (interactive-p)
 	   (if ffap-require-prefix (not current-prefix-arg)
 ;; 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:
+;; Shortcut: allow {M-x ffap} rather than {M-x find-file-at-point}.
-;;###autoload
+;; The defun is for autoload.el; the defalias takes over at load time.
+;;;###autoload
+(defun ffap (&optional filename)
+"A short alias for the find-file-at-point command.")
 (defalias 'ffap 'find-file-at-point)
-;;; Menu support:
+;;; Menu support (`ffap-menu'):
-;;
-;; 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.")
+For example, try \":/\" for URL (and some ftp) references.")
 (defvar ffap-menu-alist nil
 "Buffer local cache of menu presented by `ffap-menu'.")
 (make-variable-buffer-local 'ffap-menu-alist)
 (defvar ffap-menu-text-plist
 (and window-system
-;; These choices emulate goto-addr:
+'(face bold mouse-face highlight) ; keymap <mousy-map>
-(if ffap-xemacs
+)
-	   '(face bold highlight t) ; keymap <map>
-	 '(face bold mouse-face highlight) ; keymap <mousy-map>
-	 ))
 "Text properties applied to strings found by `ffap-menu-rescan'.
 These properties may be used to fontify the menu references.")
 ;;;###autoload
 (defun ffap-menu (&optional rescan)
 	  (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).
+Arguments are TITLE, ALIST, and CONT \(a continuation function\).
 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\) ALIST entry defines a choice \(data is ignored\).
+Each \(string . data\) ALIST entry defines a choice.
-Once the user makes a choice, function CONT is applied to the entry.
+Function CONT is applied to the entry chosen by the user."
-Always returns nil."
+;; Note: this function is used with a different continuation
-;; Bug: minibuffer prompting assumes the strings are unique.
+;; by the ffap-url add-on package.
-(let ((choice
+;; Could try rewriting to use easymenu.el or lmenu.el.
-	 (if (and (fboundp 'x-popup-menu) ; Emacs 19 or XEmacs 19.13
+(let (choice)
-		  (boundp 'last-nonmenu-event) ; not in XEmacs 19.13
+(cond
-		  (listp last-nonmenu-event))
+;; Emacs mouse:
-	     (x-popup-menu
+((and (fboundp 'x-popup-menu) (ffap-mouse-event))
-	      t
+(setq choice
-	      (list ""
+	    (x-popup-menu
-		    (cons title
+	     t
-			  (mapcar
+	     (list "" (cons title
-			   (function (lambda (i) (cons (car i) i)))
+			    (mapcar (function (lambda (i) (cons (car i) i)))
-			   alist))))
+				    alist))))))
-	   ;; Immediately popup completion buffer:
+;; minibuffer with completion buffer:
-	   (prog1
+(t
-	       (let ((minibuffer-setup-hook 'minibuffer-completion-help))
+(let ((minibuffer-setup-hook 'minibuffer-completion-help))
-		 ;; BUG: this code assumes that "" is not a valid choice
+	;; Bug: prompting may assume unique strings, no "".
-		 (completing-read
+	(setq choice
-		  (format "%s (default %s): " title (car (car alist)))
+	      (completing-read
-		  alist nil t
+	       (format "%s (default %s): " title (car (car alist)))
-		  ;; (cons (car (car alist)) 0)
+	       alist nil t
-		  nil
+	       ;; (cons (car (car alist)) 0)
-		  ))
+	       nil)))
-	     ;; Redraw original screen:
+(sit-for 0)			; redraw original screen
-	     (sit-for 0)))))
+;; Convert string to its entry, or else the default:
-;; Defaulting: convert "" to (car (car alist))
+(setq choice (or (assoc choice alist) (car alist))))
-(and (equal choice "") (setq choice (car (car alist))))
+)
-(and (stringp choice) (setq choice (assoc choice alist)))
+(if choice
-(if choice (funcall cont choice) (message "No choice made!")))
+	(funcall cont choice)
-nil)					; return nothing
+(message "No choice made!")	; possible with menus
+nil)))
 (defun ffap-menu-rescan nil
 "Search buffer for `ffap-menu-regexp' to build `ffap-menu-alist'.
 Applies `ffap-menu-text-plist' text properties at all matches."
 (interactive)
 (let ((ffap-next-regexp (or ffap-menu-regexp ffap-next-regexp))
-	(range (- (point-max) (point-min))) item
+	(range (- (point-max) (point-min)))
+	(mod (buffer-modified-p))	; was buffer modified?
 	buffer-read-only		; to set text-properties
+	item
 	;; Avoid repeated searches of the *mode-alist:
 	(major-mode (if (assq major-mode ffap-string-at-point-mode-alist)
 			major-mode
-		      'file))
+		      'file)))
-	)
 (setq ffap-menu-alist nil)
-(save-excursion
+(unwind-protect
-(goto-char (point-min))
+	(save-excursion
-(while (setq item (ffap-next-guess))
+	  (goto-char (point-min))
-	(setq ffap-menu-alist (cons (cons item (point)) ffap-menu-alist))
+	  (while (setq item (ffap-next-guess))
-	(add-text-properties (car ffap-string-at-point-region) (point)
+	    (setq ffap-menu-alist (cons (cons item (point)) ffap-menu-alist))
-			     ffap-menu-text-plist)
+	    (add-text-properties (car ffap-string-at-point-region) (point)
-	(message "Scanning...%2d%% <%s>"
+				 ffap-menu-text-plist)
-		 (/ (* 100 (- (point) (point-min))) range) item))))
+	    (message "Scanning...%2d%% <%s>"
+		     (/ (* 100 (- (point) (point-min))) range) item)))
+(or mod (set-buffer-modified-p nil))))
 (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))
+(let ((ptr ffap-menu-alist))		; remove duplicates
 (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:
+;;; Mouse Support (`ffap-at-mouse'):
 ;;
 ;; See the suggested binding in ffap-bindings (near eof).
-(defvar ffap-at-mouse-fallback 'ffap-menu
+(defvar ffap-at-mouse-fallback nil	; ffap-menu? too time-consuming
-"Invoked by `ffap-at-mouse' if no file or url at click.
+"Command invoked by `ffap-at-mouse' if nothing found at click, or nil.
-A command symbol, or nil for nothing.")
+Ignored when `ffap-at-mouse' is called programmatically.")
 (put 'ffap-at-mouse-fallback 'risky-local-variable t)
+;;;###autoload
 (defun ffap-at-mouse (e)
-"Find file or url guessed from text around mouse point.
+"Find file or url guessed from text around mouse click.
-If none is found, call `ffap-at-mouse-fallback'."
+Interactively, calls `ffap-at-mouse-fallback' if nothing is found.
+Returns t or nil to indicate success."
 (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?
+	   ;; Would prefer to do nothing unless click was *on* text.  How
-	   ;; (cdr (posn-col-row (event-start e))) is always same as
+	   ;; to tell that the click was beyond the end of current line?
-	   ;; current column.  For posn-x-y, need pixel-width!
 	   (ffap-guesser))))
 (cond
 (guess
+(set-buffer (ffap-event-buffer e))
 (ffap-highlight)
 (unwind-protect
 	  (progn
 	    (sit-for 0)			; display
-	    (message "Guessing `%s'" guess)
+	    (message "Finding `%s'" guess)
-	    (find-file-at-point guess))
+	    (find-file-at-point guess)
+	    t)				; success: return non-nil
 	(ffap-highlight t)))
-((and (interactive-p)
+((interactive-p)
-	   ffap-at-mouse-fallback)
+(if ffap-at-mouse-fallback
-(call-interactively ffap-at-mouse-fallback))
+	  (call-interactively ffap-at-mouse-fallback)
-((message "No file or URL found at mouse click.")))))
+	(message "No file or url found at mouse click.")))
+;; failure: return nil
+)))
-;;; ffap-other-* commands
-;; Suggested by KPC.
+;;; ffap-other-* commands:
+;;
+;; Requested by KPC.
+;; There could be a real `ffap-noselect' function, but we would need
+;; at least two new user variables, and there is no w3-fetch-noselect.
+;; So instead, we just fake it with a slow save-window-excursion.
 (defun ffap-other-window nil
-"Like `ffap', but put buffer in another window."
+"Like `ffap', but put buffer in another window.
+Only intended for interactive use."
 (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."
+"Like `ffap', but put buffer in another frame.
+Only intended for interactive use."
 (interactive)
-(switch-to-buffer-other-frame
+;; Extra code works around dedicated windows (noted by JENS, 7/96):
-(save-window-excursion (call-interactively 'ffap) (current-buffer))))
+(let* ((win (selected-window)) (wdp (window-dedicated-p win)))
+(unwind-protect
+	(progn
+	  (set-window-dedicated-p win nil)
+	  (switch-to-buffer-other-frame
+	   (save-window-excursion
+	     (call-interactively 'ffap)
+	     (current-buffer))))
+(set-window-dedicated-p win wdp))))
 ;;; Bug Reporter:
 (defun ffap-bug nil
 (interactive)
 (require 'reporter)
 (let ((reporter-prompt-for-summary-p t))
 (reporter-submit-bug-report
 "Michelangelo Grigni <mic@mathcs.emory.edu>"
-"ffap 1.6"
+"ffap"				; version? just rely on Emacs version
 (mapcar 'intern (all-completions "ffap-" obarray 'boundp)))))
 (fset 'ffap-submit-bug 'ffap-bug)	; another likely name
 (defun ffap-gnus-menu nil
 "Run `ffap-menu' in the gnus article buffer."
 (interactive) (ffap-gnus-wrapper '(ffap-menu)))
-;;; ffap-bindings: offer default global bindings
+;;; Offer default global bindings (`ffap-bindings'):
 (defvar ffap-bindings
-(nconc
+'(
-(cond
+(global-set-key [S-mouse-3] 'ffap-at-mouse)
-((not (eq window-system 'x))
+(global-set-key [C-S-mouse-3] 'ffap-menu)
-nil)
+(global-set-key "\C-x\C-f" 'find-file-at-point)
-;; GNU coding standards say packages should not bind S-mouse-*.
+(global-set-key "\C-x4f"   'ffap-other-window)
-;; Is it ok to simply suggest such a binding to the user?
+(global-set-key "\C-x5f"   'ffap-other-frame)
-(ffap-xemacs
+(add-hook 'gnus-summary-mode-hook 'ffap-gnus-hook)
-'((global-set-key '(shift button3) 'ffap-at-mouse)))
+(add-hook 'gnus-article-mode-hook 'ffap-gnus-hook)
-(t
+(add-hook 'vm-mode-hook 'ffap-ro-mode-hook)
-'((global-set-key [S-down-mouse-3] 'ffap-at-mouse))))
+(add-hook 'rmail-mode-hook 'ffap-ro-mode-hook)
-'(
+;; (setq dired-x-hands-off-my-keys t) ; the default
-(global-set-key "\C-x\C-f" 'find-file-at-point)
+)
-(global-set-key "\C-x4f"   'ffap-other-window)
+"List of binding forms evaluated by function `ffap-bindings'.
-(global-set-key "\C-x5f"   'ffap-other-frame)
-(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)
-;; (setq dired-x-hands-off-my-keys t) ; the default
-))
-"List of forms evaluated by function `ffap-bindings'.
 A reasonable ffap installation needs just these two lines:
 (require 'ffap)
 (ffap-bindings)
-These are only suggestions, they may be modified or ignored.")
+Of course if you do not like these bindings, just roll your own!")
 (defun ffap-bindings nil
 "Evaluate the forms in variable `ffap-bindings'."
 (eval (cons 'progn ffap-bindings)))
 ;; (setq ffap-alist                   ; remove a feature 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]+$"
+;;	  (cons "^YSN[0-9]+$"
 ;;		(defun ffap-ysn (name)
 ;;		  (concat
-;;		   "http://snorri.chem.washington.edu/ysnarchive/issuefiles/"
+;;		   "http://www.physics.uiuc.edu/"
+;;                 "ysn/httpd/htdocs/ysnarchive/issuefiles/"
 ;;		   (substring name 3) ".html")))
 ;;	  ffap-alist))
-;;; XEmacs:
-;; Extended suppport in another file, for copyright reasons.
-(or (not ffap-xemacs)
-(load "ffap-xe" t t)
-(message "ffap warning: ffap-xe.el not found"))
 ;;; ffap.el ends here

Mercurial > emacs

comparison lisp/ffap.el @ 18291:130a48e6cc13