(symbol-at-point): Don't use `form-at-point' which

fails if the symbol contains chars like ( or '.
(bounds-of-thing-at-point): Remove unused vars `end' and `beg'.
(thing-at-point-bounds-of-url-at-point): Remove unused vars `url' and `short'.

1 files changed, 46 insertions, 49 deletions

diff --git a/lisp/thingatpt.el b/lisp/thingatpt.el
index 27fecacdd36..c0aa80ef1ae 100644
--- a/lisp/thingatpt.el
+++ b/lisp/thingatpt.el
@@ -53,7 +53,7 @@
 
 ;;;###autoload
 (defun forward-thing (thing &optional n)
-  "Move forward to the end of the next THING."
+  "Move forward to the end of the Nth next THING."
   (let ((forward-op (or (get thing 'forward-op)
                         (intern-soft (format "forward-%s" thing)))))
     (if (functionp forward-op)
@@ -80,16 +80,13 @@ of the textual entity that was found."
       (condition-case nil
           (save-excursion
             ;; Try moving forward, then back.
-            (let ((end (progn
-                         (funcall
-                          (or (get thing 'end-op)
-                              (function (lambda () (forward-thing thing 1)))))
-                         (point)))
-                  (beg (progn
-                         (funcall
-                          (or (get thing 'beginning-op)
-                              (function (lambda () (forward-thing thing -1)))))
-                         (point))))
+            (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 (not (and beg (> beg orig)))
                   ;; If that brings us all the way back to ORIG,
                   ;; it worked.  But END may not be the real end.
@@ -98,28 +95,25 @@ of the textual entity that was found."
                          (progn
                            (funcall
                             (or (get thing 'end-op)
-                                (function (lambda () (forward-thing thing 1)))))
+                                (lambda () (forward-thing thing 1))))
                            (point))))
                     (if (and beg real-end (<= beg orig) (<= orig 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.
-                (let ((beg (progn
-                             (funcall
-                              (or (get thing 'beginning-op)
-                                  (function (lambda () (forward-thing thing -1)))))
-                             (point)))
-                      (end (progn
-                             (funcall
-                              (or (get thing 'end-op)
-                                  (function (lambda () (forward-thing thing 1)))))
-                             (point)))
-                      (real-beg
+                (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)
-                              (function (lambda () (forward-thing thing -1)))))
+                              (lambda () (forward-thing thing -1))))
                          (point))))
                   (if (and real-beg end (<= real-beg orig) (<= orig end))
                       (cons real-beg end))))))
@@ -160,7 +154,7 @@ a symbol as a valid THING."
 ;; and it has no final newline.
 
 (put 'line 'beginning-op
-     (function (lambda () (if (bolp) (forward-line -1) (beginning-of-line)))))
+     (lambda () (if (bolp) (forward-line -1) (beginning-of-line))))
 
 ;;  Sexps
 
@@ -190,7 +184,7 @@ a symbol as a valid THING."
 
 ;;  Lists
 
-(put 'list 'end-op (function (lambda () (up-list 1))))
+(put 'list 'end-op (lambda () (up-list 1)))
 (put 'list 'beginning-op 'backward-sexp)
 
 ;;  Filenames and URLs  www.com/foo%32bar
@@ -229,7 +223,7 @@ Hostname matching is stricter in this case than for
     "afs:" "tn3270:" "mailserver:"
   ;; Compatibility
     "snews:")
-  "Uniform Resource Identifier (URI) Schemes")
+  "Uniform Resource Identifier (URI) Schemes.")
 
 (defvar thing-at-point-url-regexp
   (concat "\\<\\(" (mapconcat 'identity thing-at-point-uri-schemes "\\|") "\\)"
@@ -243,18 +237,19 @@ This may contain whitespace (including newlines) .")
 
 (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 ((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)
+  (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)))
+            ;; (setq short (thing-at-point-looking-at
+            ;;           thing-at-point-short-url-regexp))
+            )
         (let ((beginning (match-beginning 0))
               (end (match-end 0)))
-          (cond (strip
-                 (setq beginning (+ beginning 5))
-                 (setq end (- end 1))))
+          (when strip
+            (setq beginning (+ beginning 5))
+            (setq end (- end 1)))
           (cons beginning end)))))
 
 (put 'url 'thing-at-point 'thing-at-point-url-at-point)
@@ -327,17 +322,17 @@ point."
         (looking-at regexp)))))
 
 (put 'url 'end-op
-     (function (lambda ()
-                 (let ((bounds (thing-at-point-bounds-of-url-at-point)))
-                   (if bounds
-                       (goto-char (cdr bounds))
-                     (error "No URL here"))))))
+     (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
-     (function (lambda ()
-                 (let ((bounds (thing-at-point-bounds-of-url-at-point)))
-                   (if bounds
-                       (goto-char (car bounds))
-                     (error "No URL here"))))))
+     (lambda ()
+       (let ((bounds (thing-at-point-bounds-of-url-at-point)))
+         (if bounds
+             (goto-char (car bounds))
+           (error "No URL here")))))
 
 ;;  Whitespace
 
@@ -385,7 +380,7 @@ point."
 (defun sentence-at-point () (thing-at-point 'sentence))
 
 (defun read-from-whole-string (str)
-  "Read a lisp expression from STR.
+  "Read a Lisp expression from STR.
 Signal an error if the entire string was not used."
   (let* ((read-data (read-from-string str))
          (more-left
@@ -407,11 +402,13 @@ Signal an error if the entire string was not used."
 ;;;###autoload
 (defun sexp-at-point ()   (form-at-point 'sexp))
 ;;;###autoload
-(defun symbol-at-point () (form-at-point 'sexp 'symbolp))
+(defun symbol-at-point ()
+  (let ((thing (thing-at-point 'symbol)))
+    (if thing (intern thing))))
 ;;;###autoload
 (defun number-at-point () (form-at-point 'sexp 'numberp))
 ;;;###autoload
 (defun list-at-point ()   (form-at-point 'list 'listp))
 
-;;; arch-tag: bb65a163-dae2-4055-aedc-fe11f497f698
+;; arch-tag: bb65a163-dae2-4055-aedc-fe11f497f698
 ;;; thingatpt.el ends here