(add-log-current-defun): Add condition-case around

the body, so at worst we return nil.

1 files changed, 129 insertions, 128 deletions

diff --git a/lisp/add-log.el b/lisp/add-log.el
index f7f61b3952f..780c2d84cf8 100644
--- a/lisp/add-log.el
+++ b/lisp/add-log.el
@@ -218,136 +218,137 @@ identifiers followed by `:' or `=', see variable
 `add-log-current-defun-header-regexp'.
 
 Has a preference of looking backwards."
-  (save-excursion
-    (let ((location (point)))
-      (cond ((memq major-mode '(emacs-lisp-mode lisp-mode scheme-mode))
-	     ;; If we are now precisely a the beginning of a defun,
-	     ;; make sure beginning-of-defun finds that one
-	     ;; rather than the previous one.
-	     (or (eobp) (forward-char 1))
-	     (beginning-of-defun)
-	     ;; Make sure we are really inside the defun found, not after it.
-	     (if (and (progn (end-of-defun)
-			     (< location (point)))
-		      (progn (forward-sexp -1)
-			     (>= location (point))))
-		 (progn
-		   (forward-word 1)
-		   (skip-chars-forward " ")
-		   (buffer-substring (point)
-				     (progn (forward-sexp 1) (point))))))
-	    ((and (memq major-mode '(c-mode 'c++-mode))
-		  (save-excursion (beginning-of-line)
-				  ;; Use eq instead of = here to avoid
-				  ;; error when at bob and char-after
-				  ;; returns nil.
-				  (while (eq (char-after (- (point) 2)) ?\\)
-				    (forward-line -1))
-				  (looking-at "[ \t]*#[ \t]*define[ \t]")))
-	     ;; Handle a C macro definition.
-	     (beginning-of-line)
-	     (while (eq (char-after (- (point) 2)) ?\\) ;not =; note above
-	       (forward-line -1))
-	     (search-forward "define")
-	     (skip-chars-forward " \t")
-	     (buffer-substring (point)
-			       (progn (forward-sexp 1) (point))))
-	    ((memq major-mode '(c-mode 'c++-mode))
-	     (beginning-of-line)
-	     ;; See if we are in the beginning part of a function,
-	     ;; before the open brace.  If so, advance forward.
-	     (while (not (looking-at "{\\|\\(\\s *$\\)"))
-	       (forward-line 1))
-	     (or (eobp)
-		 (forward-char 1))
-	     (beginning-of-defun)
-	     (if (progn (end-of-defun)
-			(< location (point)))
-		 (progn
-		   (backward-sexp 1)
-		   (let (beg tem)
-		   
-		     (forward-line -1)
-		     ;; Skip back over typedefs of arglist.
-		     (while (and (not (bobp))
-				 (looking-at "[ \t\n]"))
-		       (forward-line -1))
-		     ;; See if this is using the DEFUN macro used in Emacs,
-		     ;; or the DEFUN macro used by the C library.
-		     (if (condition-case nil
-			     (and (save-excursion
-				    (forward-line 1)
-				    (backward-sexp 1)
-				    (beginning-of-line)
-				    (setq tem (point))
-				    (looking-at "DEFUN\\b"))
-				  (>= location tem))
-			   (error nil))
-			 (progn
-			   (goto-char tem)
-			   (down-list 1)
-			   (if (= (char-after (point)) ?\")
-			       (progn
-				 (forward-sexp 1)
-				 (skip-chars-forward " ,")))
-			   (buffer-substring (point)
-					     (progn (forward-sexp 1) (point))))
-		       ;; Ordinary C function syntax.
-		       (setq beg (point))
-		       (if (condition-case nil
-			       ;; Protect against "Unbalanced parens" error.
-			       (progn
-				 (down-list 1) ; into arglist
-				 (backward-up-list 1)
-				 (skip-chars-backward " \t")
-				 t)
-			     (error nil))
-			   ;; Verify initial pos was after
-			   ;; real start of function.
-			   (if (and (save-excursion
-				      (goto-char beg)
-				      ;; For this purpose, include the line
-				      ;; that has the decl keywords.  This
-				      ;; may also include some of the
-				      ;; comments before the function.
-				      (while (and (not (bobp))
-						  (save-excursion
-						    (forward-line -1)
-						    (looking-at "[^\n\f]")))
+  (condition-case nil
+      (save-excursion
+	(let ((location (point)))
+	  (cond ((memq major-mode '(emacs-lisp-mode lisp-mode scheme-mode))
+		 ;; If we are now precisely a the beginning of a defun,
+		 ;; make sure beginning-of-defun finds that one
+		 ;; rather than the previous one.
+		 (or (eobp) (forward-char 1))
+		 (beginning-of-defun)
+		 ;; Make sure we are really inside the defun found, not after it.
+		 (if (and (progn (end-of-defun)
+				 (< location (point)))
+			  (progn (forward-sexp -1)
+				 (>= location (point))))
+		     (progn
+		       (forward-word 1)
+		       (skip-chars-forward " ")
+		       (buffer-substring (point)
+					 (progn (forward-sexp 1) (point))))))
+		((and (memq major-mode '(c-mode 'c++-mode))
+		      (save-excursion (beginning-of-line)
+				      ;; Use eq instead of = here to avoid
+				      ;; error when at bob and char-after
+				      ;; returns nil.
+				      (while (eq (char-after (- (point) 2)) ?\\)
 					(forward-line -1))
-				      (>= location (point)))
-				    ;; Consistency check: going down and up
-				    ;; shouldn't take us back before BEG.
-				    (> (point) beg))
-			       (buffer-substring (point)
-						 (progn (backward-sexp 1)
-							(point))))))))))
-	    ((memq major-mode
-		   '(TeX-mode plain-TeX-mode LaTeX-mode;; tex-mode.el
-			      plain-tex-mode latex-mode;; cmutex.el
-			      ))
-	     (if (re-search-backward
-		  "\\\\\\(sub\\)*\\(section\\|paragraph\\|chapter\\)" nil t)
-		 (progn
-		   (goto-char (match-beginning 0))
-		   (buffer-substring (1+ (point));; without initial backslash
-				     (progn
-				       (end-of-line)
-				       (point))))))
-	    ((eq major-mode 'texinfo-mode)
-	     (if (re-search-backward "^@node[ \t]+\\([^,]+\\)," nil t)
-		 (buffer-substring (match-beginning 1)
-				   (match-end 1))))
-	    (t
-	     ;; If all else fails, try heuristics
-	     (let (case-fold-search)
-	       (end-of-line)
-	       (if (re-search-backward add-log-current-defun-header-regexp
-				       (- (point) 10000)
-				       t)
-		   (buffer-substring (match-beginning 1)
-				     (match-end 1)))))))))
+				      (looking-at "[ \t]*#[ \t]*define[ \t]")))
+		 ;; Handle a C macro definition.
+		 (beginning-of-line)
+		 (while (eq (char-after (- (point) 2)) ?\\) ;not =; note above
+		   (forward-line -1))
+		 (search-forward "define")
+		 (skip-chars-forward " \t")
+		 (buffer-substring (point)
+				   (progn (forward-sexp 1) (point))))
+		((memq major-mode '(c-mode 'c++-mode))
+		 (beginning-of-line)
+		 ;; See if we are in the beginning part of a function,
+		 ;; before the open brace.  If so, advance forward.
+		 (while (not (looking-at "{\\|\\(\\s *$\\)"))
+		   (forward-line 1))
+		 (or (eobp)
+		     (forward-char 1))
+		 (beginning-of-defun)
+		 (if (progn (end-of-defun)
+			    (< location (point)))
+		     (progn
+		       (backward-sexp 1)
+		       (let (beg tem)
 
+			 (forward-line -1)
+			 ;; Skip back over typedefs of arglist.
+			 (while (and (not (bobp))
+				     (looking-at "[ \t\n]"))
+			   (forward-line -1))
+			 ;; See if this is using the DEFUN macro used in Emacs,
+			 ;; or the DEFUN macro used by the C library.
+			 (if (condition-case nil
+				 (and (save-excursion
+					(forward-line 1)
+					(backward-sexp 1)
+					(beginning-of-line)
+					(setq tem (point))
+					(looking-at "DEFUN\\b"))
+				      (>= location tem))
+			       (error nil))
+			     (progn
+			       (goto-char tem)
+			       (down-list 1)
+			       (if (= (char-after (point)) ?\")
+				   (progn
+				     (forward-sexp 1)
+				     (skip-chars-forward " ,")))
+			       (buffer-substring (point)
+						 (progn (forward-sexp 1) (point))))
+			   ;; Ordinary C function syntax.
+			   (setq beg (point))
+			   (if (condition-case nil
+				   ;; Protect against "Unbalanced parens" error.
+				   (progn
+				     (down-list 1) ; into arglist
+				     (backward-up-list 1)
+				     (skip-chars-backward " \t")
+				     t)
+				 (error nil))
+			       ;; Verify initial pos was after
+			       ;; real start of function.
+			       (if (and (save-excursion
+					  (goto-char beg)
+					  ;; For this purpose, include the line
+					  ;; that has the decl keywords.  This
+					  ;; may also include some of the
+					  ;; comments before the function.
+					  (while (and (not (bobp))
+						      (save-excursion
+							(forward-line -1)
+							(looking-at "[^\n\f]")))
+					    (forward-line -1))
+					  (>= location (point)))
+					;; Consistency check: going down and up
+					;; shouldn't take us back before BEG.
+					(> (point) beg))
+				   (buffer-substring (point)
+						     (progn (backward-sexp 1)
+							    (point))))))))))
+		((memq major-mode
+		       '(TeX-mode plain-TeX-mode LaTeX-mode;; tex-mode.el
+				  plain-tex-mode latex-mode;; cmutex.el
+				  ))
+		 (if (re-search-backward
+		      "\\\\\\(sub\\)*\\(section\\|paragraph\\|chapter\\)" nil t)
+		     (progn
+		       (goto-char (match-beginning 0))
+		       (buffer-substring (1+ (point));; without initial backslash
+					 (progn
+					   (end-of-line)
+					   (point))))))
+		((eq major-mode 'texinfo-mode)
+		 (if (re-search-backward "^@node[ \t]+\\([^,]+\\)," nil t)
+		     (buffer-substring (match-beginning 1)
+				       (match-end 1))))
+		(t
+		 ;; If all else fails, try heuristics
+		 (let (case-fold-search)
+		   (end-of-line)
+		   (if (re-search-backward add-log-current-defun-header-regexp
+					   (- (point) 10000)
+					   t)
+		       (buffer-substring (match-beginning 1)
+					 (match-end 1))))))))
+    (error nil)))
 
 
 (provide 'add-log)