X-Git-Url: http://git.hcoop.net/bpt/emacs.git/blobdiff_plain/1259009aa17da6dc038afff96963f6d9bbd3b8e1..d2301b5d805d603547b36d96e3a09e6d8124a6d7:/lisp/thingatpt.el diff --git a/lisp/thingatpt.el b/lisp/thingatpt.el index 1600785c11..ea5819e488 100644 --- a/lisp/thingatpt.el +++ b/lisp/thingatpt.el @@ -1,9 +1,9 @@ ;;; thingatpt.el --- get the `thing' at point -;; Copyright (C) 1991-1998, 2000-2012 Free Software Foundation, Inc. +;; Copyright (C) 1991-1998, 2000-2014 Free Software Foundation, Inc. ;; Author: Mike Williams -;; Maintainer: FSF +;; Maintainer: emacs-devel@gnu.org ;; Keywords: extensions, matching, mouse ;; Created: Thu Mar 28 13:48:23 1991 @@ -84,64 +84,70 @@ positions of the thing found." (if (get thing 'bounds-of-thing-at-point) (funcall (get thing 'bounds-of-thing-at-point)) (let ((orig (point))) - (condition-case nil - (save-excursion - ;; Try moving forward, then back. - (funcall ;; First move to end. - (or (get thing 'end-op) - (lambda () (forward-thing thing 1)))) - (funcall ;; Then move to beg. - (or (get thing 'beginning-op) - (lambda () (forward-thing thing -1)))) - (let ((beg (point))) - (if (<= beg orig) - ;; If that brings us all the way back to ORIG, - ;; it worked. But END may not be the real end. - ;; So find the real end that corresponds to BEG. - ;; FIXME: in which cases can `real-end' differ from `end'? - (let ((real-end - (progn - (funcall - (or (get thing 'end-op) - (lambda () (forward-thing thing 1)))) - (point)))) - (when (and (<= orig real-end) (< beg real-end)) - (cons beg real-end))) - (goto-char orig) - ;; Try a second time, moving backward first and then forward, - ;; so that we can find a thing that ends at ORIG. - (funcall ;; First, move to beg. - (or (get thing 'beginning-op) - (lambda () (forward-thing thing -1)))) - (funcall ;; Then move to end. - (or (get thing 'end-op) - (lambda () (forward-thing thing 1)))) - (let ((end (point)) - (real-beg + (ignore-errors + (save-excursion + ;; Try moving forward, then back. + (funcall ;; First move to end. + (or (get thing 'end-op) + (lambda () (forward-thing thing 1)))) + (funcall ;; Then move to beg. + (or (get thing 'beginning-op) + (lambda () (forward-thing thing -1)))) + (let ((beg (point))) + (if (<= beg orig) + ;; If that brings us all the way back to ORIG, + ;; it worked. But END may not be the real end. + ;; So find the real end that corresponds to BEG. + ;; FIXME: in which cases can `real-end' differ from `end'? + (let ((real-end (progn (funcall - (or (get thing 'beginning-op) - (lambda () (forward-thing thing -1)))) + (or (get thing 'end-op) + (lambda () (forward-thing thing 1)))) (point)))) - (if (and (<= real-beg orig) (<= orig end) (< real-beg end)) - (cons real-beg end)))))) - (error nil))))) + (when (and (<= orig real-end) (< beg real-end)) + (cons beg real-end))) + (goto-char orig) + ;; Try a second time, moving backward first and then forward, + ;; so that we can find a thing that ends at ORIG. + (funcall ;; First, move to beg. + (or (get thing 'beginning-op) + (lambda () (forward-thing thing -1)))) + (funcall ;; Then move to end. + (or (get thing 'end-op) + (lambda () (forward-thing thing 1)))) + (let ((end (point)) + (real-beg + (progn + (funcall + (or (get thing 'beginning-op) + (lambda () (forward-thing thing -1)))) + (point)))) + (if (and (<= real-beg orig) (<= orig end) (< real-beg end)) + (cons real-beg end)))))))))) ;;;###autoload -(defun thing-at-point (thing) +(defun thing-at-point (thing &optional no-properties) "Return the THING at point. THING should be a symbol specifying a type of syntactic entity. Possibilities include `symbol', `list', `sexp', `defun', `filename', `url', `email', `word', `sentence', `whitespace', -`line', and `page'. +`line', `number', and `page'. + +When the optional argument NO-PROPERTIES is non-nil, +strip text properties from the return value. See the file `thingatpt.el' for documentation on how to define a symbol as a valid THING." - (if (get thing 'thing-at-point) - (funcall (get thing 'thing-at-point)) - (let ((bounds (bounds-of-thing-at-point thing))) - (if bounds - (buffer-substring (car bounds) (cdr bounds)))))) + (let ((text + (if (get thing 'thing-at-point) + (funcall (get thing 'thing-at-point)) + (let ((bounds (bounds-of-thing-at-point thing))) + (when bounds + (buffer-substring (car bounds) (cdr bounds))))))) + (when (and text no-properties) + (set-text-properties 0 (length text) nil text)) + text)) ;; Go to beginning/end @@ -182,7 +188,7 @@ The bounds of THING are determined by `bounds-of-thing-at-point'." (defun end-of-sexp () "Move point to the end of the current sexp. \[This is an internal function.]" - (let ((char-syntax (char-syntax (char-after)))) + (let ((char-syntax (syntax-after (point)))) (if (or (eq char-syntax ?\)) (and (eq char-syntax ?\") (in-string-p))) (forward-char 1) @@ -210,21 +216,19 @@ The bounds of THING are determined by `bounds-of-thing-at-point'." \[Internal function used by `bounds-of-thing-at-point'.]" (save-excursion (let ((opoint (point)) - (beg (condition-case nil - (progn (up-list -1) - (point)) - (error nil)))) - (condition-case nil - (if beg - (progn (forward-sexp) - (cons beg (point))) - ;; Are we are at the beginning of a top-level sexp? - (forward-sexp) - (let ((end (point))) - (backward-sexp) - (if (>= opoint (point)) - (cons opoint end)))) - (error nil))))) + (beg (ignore-errors + (up-list -1) + (point)))) + (ignore-errors + (if beg + (progn (forward-sexp) + (cons beg (point))) + ;; Are we are at the beginning of a top-level sexp? + (forward-sexp) + (let ((end (point))) + (backward-sexp) + (if (>= opoint (point)) + (cons opoint end)))))))) ;; Defuns @@ -232,7 +236,7 @@ The bounds of THING are determined by `bounds-of-thing-at-point'." (put 'defun 'end-op 'end-of-defun) (put 'defun 'forward-op 'end-of-defun) -;; Filenames and URLs www.com/foo%32bar +;; Filenames (defvar thing-at-point-file-name-chars "-~/[:alnum:]_.${}#%,:" "Characters allowable in filenames.") @@ -248,94 +252,222 @@ The bounds of THING are determined by `bounds-of-thing-at-point'." (forward-char) (goto-char (point-min))))) +;; URIs + +(defvar thing-at-point-beginning-of-url-regexp nil + "Regexp matching the beginning of a well-formed URI. +If nil, construct the regexp from `thing-at-point-uri-schemes'.") + (defvar thing-at-point-url-path-regexp "[^]\t\n \"'<>[^`{}]*[^]\t\n \"'<>[^`{}.,;]+" - "A regular expression probably matching the host and filename or e-mail part of a URL.") + "Regexp matching the host and filename or e-mail part of a URL.") (defvar thing-at-point-short-url-regexp (concat "[-A-Za-z0-9]+\\.[-A-Za-z0-9.]+" thing-at-point-url-path-regexp) - "A regular expression probably matching a URL without an access scheme. -Hostname matching is stricter in this case than for -``thing-at-point-url-regexp''.") + "Regexp matching a URI without a scheme component.") (defvar thing-at-point-uri-schemes ;; Officials from http://www.iana.org/assignments/uri-schemes.html - '("ftp://" "http://" "gopher://" "mailto:" "news:" "nntp:" - "telnet://" "wais://" "file:/" "prospero:" "z39.50s:" "z39.50r:" - "cid:" "mid:" "vemmi:" "service:" "imap:" "nfs:" "acap:" "rtsp:" - "tip:" "pop:" "data:" "dav:" "opaquelocktoken:" "sip:" "tel:" "fax:" - "modem:" "ldap:" "https://" "soap.beep:" "soap.beeps:" "urn:" "go:" - "afs:" "tn3270:" "mailserver:" - "crid:" "dict:" "dns:" "dtn:" "h323:" "im:" "info:" "ipp:" - "iris.beep:" "mtqp:" "mupdate:" "pres:" "sips:" "snmp:" "tag:" - "tftp:" "xmlrpc.beep:" "xmlrpc.beeps:" "xmpp:" - ;; Compatibility - "snews:" "irc:" "mms://" "mmsh://") - "Uniform Resource Identifier (URI) Schemes.") - -(defvar thing-at-point-url-regexp - (concat "\\<\\(" (mapconcat 'identity thing-at-point-uri-schemes "\\|") "\\)" - thing-at-point-url-path-regexp) - "A regular expression probably matching a complete URL.") - -(defvar thing-at-point-markedup-url-regexp - "]+>" - "A regular expression matching a URL marked up per RFC1738. -This may contain whitespace (including newlines) .") + '("aaa://" "about:" "acap://" "apt:" "bzr://" "bzr+ssh://" + "attachment:/" "chrome://" "cid:" "content://" "crid://" "cvs://" + "data:" "dav:" "dict://" "doi:" "dns:" "dtn:" "feed:" "file:/" + "finger://" "fish://" "ftp://" "geo:" "git://" "go:" "gopher://" + "h323:" "http://" "https://" "im:" "imap://" "info:" "ipp:" + "irc://" "irc6://" "ircs://" "iris.beep:" "jar:" "ldap://" + "ldaps://" "mailto:" "mid:" "mtqp://" "mupdate://" "news:" + "nfs://" "nntp://" "opaquelocktoken:" "pop://" "pres:" + "resource://" "rmi://" "rsync://" "rtsp://" "rtspu://" "service:" + "sftp://" "sip:" "sips:" "smb://" "sms:" "snmp://" "soap.beep://" + "soap.beeps://" "ssh://" "svn://" "svn+ssh://" "tag:" "tel:" + "telnet://" "tftp://" "tip://" "tn3270://" "udp://" "urn:" + "uuid:" "vemmi://" "webcal://" "xri://" "xmlrpc.beep://" + "xmlrpc.beeps://" "z39.50r://" "z39.50s://" "xmpp:" + ;; Compatibility + "fax:" "mms://" "mmsh://" "modem:" "prospero:" "snews:" + "wais://") + "List of URI schemes recognized by `thing-at-point-url-at-point'. +Each string in this list should correspond to the start of a +URI's scheme component, up to and including the trailing // if +the scheme calls for that to be present.") + +(defvar thing-at-point-markedup-url-regexp "\n]+\\)>" + "Regexp matching a URL marked up per RFC1738. +This kind of markup was formerly recommended as a way to indicate +URIs, but as of RFC 3986 it is no longer recommended. +Subexpression 1 should contain the delimited URL.") + +(defvar thing-at-point-newsgroup-regexp + "\\`[[:lower:]]+\\.[-+[:lower:]_0-9.]+\\'" + "Regexp matching a newsgroup name.") + +(defvar thing-at-point-newsgroup-heads + '("alt" "comp" "gnu" "misc" "news" "sci" "soc" "talk") + "Used by `thing-at-point-newsgroup-p' if gnus is not running.") + +(defvar thing-at-point-default-mail-uri-scheme "mailto" + "Default scheme for ill-formed URIs that look like . +If nil, do not give such URIs a scheme.") (put 'url 'bounds-of-thing-at-point 'thing-at-point-bounds-of-url-at-point) -(defun thing-at-point-bounds-of-url-at-point () - (let ((strip (thing-at-point-looking-at - thing-at-point-markedup-url-regexp))) ;; (url "") short - (if (or strip - (thing-at-point-looking-at thing-at-point-url-regexp) - ;; Access scheme omitted? - ;; (setq short (thing-at-point-looking-at - ;; thing-at-point-short-url-regexp)) - ) - (let ((beginning (match-beginning 0)) - (end (match-end 0))) - (when strip - (setq beginning (+ beginning 5)) - (setq end (- end 1))) - (cons beginning end))))) + +(defun thing-at-point-bounds-of-url-at-point (&optional lax) + "Return a cons cell containing the start and end of the URI at point. +Try to find a URI using `thing-at-point-markedup-url-regexp'. +If that fails, try with `thing-at-point-beginning-of-url-regexp'. +If that also fails, and optional argument LAX is non-nil, return +the bounds of a possible ill-formed URI (one lacking a scheme)." + ;; Look for the old markup. If found, use it. + (or (thing-at-point--bounds-of-markedup-url) + ;; Otherwise, find the bounds within which a URI may exist. The + ;; method is similar to `ffap-string-at-point'. Note that URIs + ;; may contain parentheses but may not contain spaces (RFC3986). + (let* ((allowed-chars "--:=&?$+@-Z_[:alpha:]~#,%;*()!'") + (skip-before "^[0-9a-zA-Z]") + (skip-after ":;.,!?") + (pt (point)) + (beg (save-excursion + (skip-chars-backward allowed-chars) + (skip-chars-forward skip-before pt) + (point))) + (end (save-excursion + (skip-chars-forward allowed-chars) + (skip-chars-backward skip-after pt) + (point)))) + (or (thing-at-point--bounds-of-well-formed-url beg end pt) + (if lax (cons beg end)))))) + +(defun thing-at-point--bounds-of-markedup-url () + (when thing-at-point-markedup-url-regexp + (let ((case-fold-search t) + (pt (point)) + (beg (line-beginning-position)) + (end (line-end-position)) + found) + (save-excursion + (goto-char beg) + (while (and (not found) + (<= (point) pt) + (< (point) end)) + (and (re-search-forward thing-at-point-markedup-url-regexp + end 1) + (> (point) pt) + (setq found t)))) + (if found + (cons (match-beginning 1) (match-end 1)))))) + +(defun thing-at-point--bounds-of-well-formed-url (beg end _pt) + (save-excursion + (goto-char beg) + (let (url-beg paren-end regexp) + (save-restriction + (narrow-to-region beg end) + ;; The scheme component must either match at BEG, or have no + ;; other alphanumerical ASCII characters before it. + (setq regexp (concat "\\(?:\\`\\|[^a-zA-Z0-9]\\)\\(" + (or thing-at-point-beginning-of-url-regexp + (regexp-opt thing-at-point-uri-schemes)) + "\\)")) + (and (re-search-forward regexp end t) + ;; URI must have non-empty contents. + (< (point) end) + (setq url-beg (match-beginning 1)))) + (when url-beg + ;; If there is an open paren before the URI, truncate to the + ;; matching close paren. + (and (> url-beg (point-min)) + (eq (car-safe (syntax-after (1- url-beg))) 4) + (save-restriction + (narrow-to-region (1- url-beg) (min end (point-max))) + (setq paren-end (ignore-errors + (scan-lists (1- url-beg) 1 0)))) + (not (blink-matching-check-mismatch (1- url-beg) paren-end)) + (setq end (1- paren-end))) + (cons url-beg end))))) (put 'url 'thing-at-point 'thing-at-point-url-at-point) -(defun thing-at-point-url-at-point () - "Return the URL around or before point. -Search backwards for the start of a URL ending at or after point. If -no URL found, return nil. The access scheme will be prepended if -absent: \"mailto:\" if the string contains \"@\", \"ftp://\" if it -starts with \"ftp\" and not \"ftp:/\", or \"http://\" by default." - - (let ((url "") short strip) - (if (or (setq strip (thing-at-point-looking-at - thing-at-point-markedup-url-regexp)) - (thing-at-point-looking-at thing-at-point-url-regexp) - ;; Access scheme omitted? - (setq short (thing-at-point-looking-at - thing-at-point-short-url-regexp))) - (progn - (setq url (buffer-substring-no-properties (match-beginning 0) - (match-end 0))) - (and strip (setq url (substring url 5 -1))) ; Drop "" - ;; strip whitespace - (while (string-match "[ \t\n\r]+" url) - (setq url (replace-match "" t t url))) - (and short (setq url (concat (cond ((string-match "^[a-zA-Z]+:" url) - ;; already has a URL scheme. - "") - ((string-match "@" url) - "mailto:") - ;; e.g. ftp.swiss... or ftp-swiss... - ((string-match "^ftp" url) - "ftp://") - (t "http://")) - url))) - (if (string-equal "" url) - nil - url))))) +(defun thing-at-point-url-at-point (&optional lax bounds) + "Return the URL around or before point. +If no URL is found, return nil. + +If optional argument LAX is non-nil, look for URLs that are not +well-formed, such as foo@bar or . + +If optional arguments BOUNDS are non-nil, it should be a cons +cell of the form (START . END), containing the beginning and end +positions of the URI. Otherwise, these positions are detected +automatically from the text around point. + +If the scheme component is absent, either because a URI delimited +with lacks one, or because an ill-formed URI was found +with LAX or BEG and END, try to add a scheme in the returned URI. +The scheme is chosen heuristically: \"mailto:\" if the address +looks like an email address, \"ftp://\" if it starts with +\"ftp\", etc." + (unless bounds + (setq bounds (thing-at-point-bounds-of-url-at-point lax))) + (when (and bounds (< (car bounds) (cdr bounds))) + (let ((str (buffer-substring-no-properties (car bounds) (cdr bounds)))) + ;; If there is no scheme component, try to add one. + (unless (string-match "\\`[a-zA-Z][-a-zA-Z0-9+.]*:" str) + (or + ;; If the URI has the form , treat it according to + ;; `thing-at-point-default-mail-uri-scheme'. If there are + ;; no angle brackets, it must be mailto. + (when (string-match "\\`[^:@]+@[-.0-9=&?$+A-Z_a-z~#,%;*]" str) + (let ((scheme (if (and (eq (char-before (car bounds)) ?<) + (eq (char-after (cdr bounds)) ?>)) + thing-at-point-default-mail-uri-scheme + "mailto"))) + (if scheme + (setq str (concat scheme ":" str))))) + ;; If the string is like , where FOO is an existing user + ;; name on the system, treat that as an email address. + (and (string-match "\\`[[:alnum:]]+\\'" str) + (eq (char-before (car bounds)) ?<) + (eq (char-after (cdr bounds)) ?>) + (not (string-match "~" (expand-file-name (concat "~" str)))) + (setq str (concat "mailto:" str))) + ;; If it looks like news.example.com, treat it as news. + (if (thing-at-point-newsgroup-p str) + (setq str (concat "news:" str))) + ;; If it looks like ftp.example.com. treat it as ftp. + (if (string-match "\\`ftp\\." str) + (setq str (concat "ftp://" str))) + ;; If it looks like www.example.com. treat it as http. + (if (string-match "\\`www\\." str) + (setq str (concat "http://" str))) + ;; Otherwise, it just isn't a URI. + (setq str nil))) + str))) + +(defun thing-at-point-newsgroup-p (string) + "Return STRING if it looks like a newsgroup name, else nil." + (and + (string-match thing-at-point-newsgroup-regexp string) + (let ((htbs '(gnus-active-hashtb gnus-newsrc-hashtb gnus-killed-hashtb)) + (heads thing-at-point-newsgroup-heads) + htb ret) + (while htbs + (setq htb (car htbs) htbs (cdr htbs)) + (ignore-errors + ;; errs: htb symbol may be unbound, or not a hash-table. + ;; gnus-gethash is just a macro for intern-soft. + (and (symbol-value htb) + (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))) + (or ret (not heads) + (let ((head (string-match "\\`\\([[:lower:]]+\\)\\." string))) + (and head (setq head (substring string 0 (match-end 1))) + (member head heads) + (setq ret string)))) + ret))) + +(put 'url 'end-op (lambda () (end-of-thing 'url))) + +(put 'url 'beginning-op (lambda () (end-of-thing 'url))) ;; The normal thingatpt mechanism doesn't work for complex regexps. ;; This should work for almost any regexp wherever we are in the @@ -344,19 +476,22 @@ starts with \"ftp\" and not \"ftp:/\", or \"http://\" by default." ;; matches that straddle the start position so we search forwards once ;; and then back repeatedly and then back up a char at a time. -(defun thing-at-point-looking-at (regexp) +(defun thing-at-point-looking-at (regexp &optional distance) "Return non-nil if point is in or just after a match for REGEXP. Set the match data from the earliest such match ending at or after point." (save-excursion - (let ((old-point (point)) match) + (let ((old-point (point)) + (forward-bound (and distance (+ (point) distance))) + (backward-bound (and distance (- (point) distance))) + match) (and (looking-at regexp) (>= (match-end 0) old-point) (setq match (point))) ;; Search back repeatedly from end of next match. ;; This may fail if next match ends before this match does. - (re-search-forward regexp nil 'limit) - (while (and (re-search-backward regexp nil t) + (re-search-forward regexp forward-bound 'limit) + (while (and (re-search-backward regexp backward-bound t) (or (> (match-beginning 0) old-point) (and (looking-at regexp) ; Extend match-end past search start (>= (match-end 0) old-point) @@ -372,19 +507,6 @@ point." (goto-char match) (looking-at regexp))))) -(put 'url 'end-op - (lambda () - (let ((bounds (thing-at-point-bounds-of-url-at-point))) - (if bounds - (goto-char (cdr bounds)) - (error "No URL here"))))) -(put 'url 'beginning-op - (lambda () - (let ((bounds (thing-at-point-bounds-of-url-at-point))) - (if bounds - (goto-char (car bounds)) - (error "No URL here"))))) - ;; Email addresses (defvar thing-at-point-email-regexp "?" @@ -399,7 +521,8 @@ with angle brackets.") (put 'email 'bounds-of-thing-at-point (lambda () - (let ((thing (thing-at-point-looking-at thing-at-point-email-regexp))) + (let ((thing (thing-at-point-looking-at + thing-at-point-email-regexp 500))) (if thing (let ((beginning (match-beginning 0)) (end (match-end 0))) @@ -412,59 +535,11 @@ with angle brackets.") (buffer-substring-no-properties (car boundary-pair) (cdr boundary-pair)))))) -;; Whitespace - -(defun forward-whitespace (arg) - "Move point to the end of the next sequence of whitespace chars. -Each such sequence may be a single newline, or a sequence of -consecutive space and/or tab characters. -With prefix argument ARG, do it ARG times if positive, or move -backwards ARG times if negative." - (interactive "p") - (if (natnump arg) - (re-search-forward "[ \t]+\\|\n" nil 'move arg) - (while (< arg 0) - (if (re-search-backward "[ \t]+\\|\n" nil 'move) - (or (eq (char-after (match-beginning 0)) ?\n) - (skip-chars-backward " \t"))) - (setq arg (1+ arg))))) - ;; Buffer (put 'buffer 'end-op (lambda () (goto-char (point-max)))) (put 'buffer 'beginning-op (lambda () (goto-char (point-min)))) -;; Symbols - -(defun forward-symbol (arg) - "Move point to the next position that is the end of a symbol. -A symbol is any sequence of characters that are in either the -word constituent or symbol constituent syntax class. -With prefix argument ARG, do it ARG times if positive, or move -backwards ARG times if negative." - (interactive "p") - (if (natnump arg) - (re-search-forward "\\(\\sw\\|\\s_\\)+" nil 'move arg) - (while (< arg 0) - (if (re-search-backward "\\(\\sw\\|\\s_\\)+" nil 'move) - (skip-syntax-backward "w_")) - (setq arg (1+ arg))))) - -;; Syntax blocks - -(defun forward-same-syntax (&optional arg) - "Move point past all characters with the same syntax class. -With prefix argument ARG, do it ARG times if positive, or move -backwards ARG times if negative." - (interactive "p") - (while (< arg 0) - (skip-syntax-backward - (char-to-string (char-syntax (char-before)))) - (setq arg (1+ arg))) - (while (> arg 0) - (skip-syntax-forward (char-to-string (char-syntax (char-after)))) - (setq arg (1- arg)))) - ;; Aliases (defun word-at-point () @@ -490,9 +565,8 @@ Signal an error if the entire string was not used." (car read-data)))) (defun form-at-point (&optional thing pred) - (let ((sexp (condition-case nil - (read-from-whole-string (thing-at-point (or thing 'sexp))) - (error nil)))) + (let ((sexp (ignore-errors + (read-from-whole-string (thing-at-point (or thing 'sexp)))))) (if (or (not pred) (funcall pred sexp)) sexp))) ;;;###autoload @@ -508,6 +582,7 @@ Signal an error if the entire string was not used." (defun number-at-point () "Return the number at point, or nil if none is found." (form-at-point 'sexp 'numberp)) +(put 'number 'thing-at-point 'number-at-point) ;;;###autoload (defun list-at-point () "Return the Lisp list at point, or nil if none is found."