(info-lookup-guess-c-symbol): Use skip-syntax-backward.

(info-lookup-guess-default): Simplified and cleaned up.
(info-lookup-guess-default*): Preserve point.

1 files changed, 31 insertions, 32 deletions

diff --git a/lisp/info-look.el b/lisp/info-look.el
index 9b0a0c2ed11..9440097cf87 100644
--- a/lisp/info-look.el
+++ b/lisp/info-look.el
@@ -482,54 +482,53 @@ If optional argument QUERY is non-nil, query for the help mode."
     result))
 
 (defun info-lookup-guess-default (topic mode)
-  "Pick up default item at point (with favor to look back).
-Return nil if there is nothing appropriate."
+  "Return a guess for a symbol to look up, based on text around point.
+Try all related modes applicable to TOPIC and MODE.
+Return nil if there is nothing appropriate in the buffer near point."
   (let ((modes (info-lookup->all-modes topic mode))
-	(start (point)) guess whitespace)
+	guess)
     (while (and (not guess) modes)
       (setq guess (info-lookup-guess-default* topic (car modes))
-	    modes (cdr modes))
-      (goto-char start))
+	    modes (cdr modes)))
     ;; Collapse whitespace characters.
-    (and guess (concat (delete nil (mapcar (lambda (ch)
-					     (if (or (char-equal ch ? )
-						     (char-equal ch ?\t)
-						     (char-equal ch ?\n))
-						 (if (not whitespace)
-						     (setq whitespace ? ))
-					       (setq whitespace nil) ch))
-					   guess))))))
+    (when guess
+      (let ((pos 0))
+	(while (string-match "[ \t\n]+" guess pos)
+	  (setq pos (1+ (match-beginning 0)))
+	  (setq guess (replace-match " " t t guess)))))
+    guess))
 
 (defun info-lookup-guess-default* (topic mode)
   (let ((case-fold-search (info-lookup->ignore-case topic mode))
 	(rule (or (info-lookup->parse-rule topic mode)
 		  (info-lookup->regexp topic mode)))
 	(start (point)) end regexp subexp result)
-    (if (symbolp rule)
-	(setq result (funcall rule))
-      (if (consp rule)
-	  (setq regexp (car rule)
-		subexp (cdr rule))
-	(setq regexp rule
-	      subexp 0))
-      (skip-chars-backward " \t\n") (setq end (point))
-      (while (and (re-search-backward regexp nil t)
-		  (looking-at regexp)
-		  (>= (match-end 0) end))
-	(setq result (match-string subexp)))
-      (if (not result)
-	  (progn
-	    (goto-char start)
-	    (skip-chars-forward " \t\n")
-	    (and (looking-at regexp)
-		 (setq result (match-string subexp))))))
+    (save-excursion
+      (if (symbolp rule)
+	  (setq result (funcall rule))
+	(if (consp rule)
+	    (setq regexp (car rule)
+		  subexp (cdr rule))
+	  (setq regexp rule
+		subexp 0))
+	(skip-chars-backward " \t\n") (setq end (point))
+	(while (and (re-search-backward regexp nil t)
+		    (looking-at regexp)
+		    (>= (match-end 0) end))
+	  (setq result (match-string subexp)))
+	(if (not result)
+	    (progn
+	      (goto-char start)
+	      (skip-chars-forward " \t\n")
+	      (and (looking-at regexp)
+		   (setq result (match-string subexp)))))))
     result))
 
 (defun info-lookup-guess-c-symbol ()
   "Get the C symbol at point."
   (condition-case nil
       (progn
-	(backward-sexp)
+	(skip-syntax-backward "w_")
 	(let ((start (point)) prefix name)
 	  ;; Test for a leading `struct', `union', or `enum' keyword
 	  ;; but ignore names like `foo_struct'.