(add-log-current-defun): Use CC Mode functions to

find the beginning and end of a defun.

2 files changed, 130 insertions, 119 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 7dd645cb4a3..45e65ce8417 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,8 @@
+2007-01-21  Guanpeng Xu  <herberteuler@hotmail.com>
+
+	* add-log.el (add-log-current-defun): Use CC Mode functions to
+	find the beginning and end of a defun.
+
 2007-01-21  Nick Roberts  <nickrob@snap.net.nz>
 
 	* progmodes/gdb-ui.el (gdb-var-create-regexp)
@@ -90,6 +95,7 @@
 
 	* progmodes/compile.el: Add handling for makepplog.
 
+>>>>>>> 1.10581
 2007-01-19  Reiner Steib  <Reiner.Steib@gmx.de>
 
 	* textmodes/ispell.el (ispell-change-dictionary): Ensure that
@@ -593,7 +599,7 @@
 	(image-type-from-buffer): Handle new format.  New arg INCLUDE-MAYBES.
 	(image-type-from-file-header): Pass t for INCLUDE-MAYBES.
 
-2006-12-26  Guanpeng Xu  <herberteuler@hotmail.com>  (tiny change)
+2006-12-26  Guanpeng Xu  <herberteuler@hotmail.com>
 
 	* add-log.el (add-log-current-defun): Call `forward-sexp'
 	multiple times to pick a member function name defined as
diff --git a/lisp/add-log.el b/lisp/add-log.el
index 11cd63526c7..748abefd400 100644
--- a/lisp/add-log.el
+++ b/lisp/add-log.el
@@ -813,51 +813,56 @@ Has a preference of looking backwards."
 						 (progn (forward-sexp 1)
 							(point))))
 		((memq major-mode add-log-c-like-modes)
-		 (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))
-		 (let (maybe-beg)
-		   ;; Try to find the containing defun.
-		   (beginning-of-defun)
-		   (end-of-defun)
-		   ;; If the defun we found ends before the desired position,
-		   ;; see if there's a DEFUN construct
-		   ;; between that end and the desired position.
-		   (when (save-excursion
-			   (and (> location (point))
-				(re-search-forward "^DEFUN"
-						   (save-excursion
-						     (goto-char location)
-						     (line-end-position))
-						   t)
-				(re-search-forward "^{" nil t)
-				(setq maybe-beg (point))))
-		     ;; If so, go to the end of that instead.
-		     (goto-char maybe-beg)
-		     (end-of-defun)))
-		 ;; If the desired position is within the defun we found,
-		 ;; find the function name.
-		 (when (< location (point))
-		   ;; Move back over function body.
-		   (backward-sexp 1)
-		   (let (beg)
-		     ;; Skip back over typedefs and arglist.
-		     ;; Stop at the function definition itself
-		     ;; or at the line that follows end of function doc string.
-		     (forward-line -1)
-		     (while (and (not (bobp))
-				 (looking-at "[ \t\n]")
-				 (not (looking-back "[*]/)\n" (- (point) 4))))
-		       (forward-line -1))
-		     ;; If we found a doc string, this must be the DEFUN macro
-		     ;; used in Emacs.  Move back to the DEFUN line.
-		     (when (looking-back "[*]/)\n" (- (point) 4))
-		       (backward-sexp 1)
-		       (beginning-of-line))
+		 ;; See whether the point is inside a defun.
+		 (let (having-previous-defun
+		       having-next-defun
+		       previous-defun-end
+		       next-defun-beginning)
+		     
+		   (save-excursion
+		     (setq having-previous-defun
+			   (c-beginning-of-defun))
+		     (c-end-of-defun)
+		     ;; `c-end-of-defun' moves point to the line after
+		     ;; the function close, but the position we prefer
+		     ;; here is the position after the final }.
+		     (backward-sexp 1)
+		     (forward-sexp 1)
+		     (setq previous-defun-end (point)))
+
+		   (save-excursion
+		     (setq having-next-defun
+			   (c-end-of-defun))
+		     (c-beginning-of-defun)
+		     (setq next-defun-beginning (point)))
+
+		   (if (and having-next-defun
+			    (< location next-defun-beginning))
+		       (skip-syntax-forward " "))
+		   (if (and having-previous-defun
+			    (> location previous-defun-end))
+		       (skip-syntax-backward " "))
+		   (unless (or
+			    ;; When there is no previous defun, the
+			    ;; point is not in a defun if it is not at
+			    ;; the beginning of the next defun.
+			    (and (not having-previous-defun)
+				 (not (= (point)
+					 next-defun-beginning)))
+			    ;; When there is no next defun, the point
+			    ;; is not in a defun if it is not at the
+			    ;; end of the previous defun.
+			    (and (not having-next-defun)
+				 (not (= (point)
+					 previous-defun-end)))
+			    ;; If the point is between two defuns, it
+			    ;; is not in a defun.
+			    (and (> (point) previous-defun-end)
+				 (< (point) next-defun-beginning)))
+		     ;; If the point is already at the beginning of a
+		     ;; defun, there is no need to move point again.
+		     (if (not (= (point) next-defun-beginning))
+			 (c-beginning-of-defun))
 		     ;; Is this a DEFUN construct?  And is LOCATION in it?
 		     (if (and (looking-at "DEFUN\\b")
 			      (>= location (point)))
@@ -879,82 +884,82 @@ Has a preference of looking backwards."
 			   ;; Objective-C
 			   (change-log-get-method-definition)
 			 ;; Ordinary C function syntax.
-			 (setq beg (point))
-			 (if (and
-			      ;; Protect against "Unbalanced parens" error.
-			      (condition-case nil
-				  (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.
-			      (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))
-			     (let (end middle)
-			       ;; Don't include any final whitespace
-			       ;; in the name we use.
-			       (skip-chars-backward " \t\n")
-			       (setq end (point))
-			       (backward-sexp 1)
-			       ;; Now find the right beginning of the name.
-			       ;; Include certain keywords if they
-			       ;; precede the name.
-			       (setq middle (point))
-			       ;; Single (forward-sexp -1) invocation is
-			       ;; not enough for C++ member function defined 
-			       ;; as part of nested class and/or namespace 
-			       ;; like:
-			       ;;
-			       ;;   void 
-			       ;;   foo::bar::baz::bazz ()
-			       ;;   { ...
-			       ;; 
-			       ;; Here we have to move the point to 
-			       ;; the beginning of foo, not bazz.
-			       (while (not (looking-back "\\(^\\|[ \t]\\)"))
-				 (forward-sexp -1))
-			       ;; Is this C++ method?
-			       (when (and (< 2 middle)
-					  (string= (buffer-substring (- middle 2)
-								     middle)
-						   "::"))
-				 ;; Include "classname::".
-				 (setq middle (point)))
-			       ;; Ignore these subparts of a class decl
-			       ;; and move back to the class name itself.
-			       (while (looking-at "public \\|private ")
-				 (skip-chars-backward " \t:")
+			 (let ((beg (point)))
+			   (if (and
+				;; Protect against "Unbalanced parens" error.
+				(condition-case nil
+				    (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.
+				(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))
+			       (let (end middle)
+				 ;; Don't include any final whitespace
+				 ;; in the name we use.
+				 (skip-chars-backward " \t\n")
 				 (setq end (point))
 				 (backward-sexp 1)
+				 ;; Now find the right beginning of the name.
+				 ;; Include certain keywords if they
+				 ;; precede the name.
 				 (setq middle (point))
-				 (forward-word -1))
-			       (and (bolp)
-				    (looking-at
-				     "enum \\|struct \\|union \\|class ")
-				    (setq middle (point)))
-			       (goto-char end)
-			       (when (eq (preceding-char) ?=)
-				 (forward-char -1)
-				 (skip-chars-backward " \t")
-				 (setq end (point)))
-			       (buffer-substring-no-properties
-				middle end))))))))
+				 ;; Single (forward-sexp -1) invocation is
+				 ;; not enough for C++ member function defined 
+				 ;; as part of nested class and/or namespace 
+				 ;; like:
+				 ;;
+				 ;;   void 
+				 ;;   foo::bar::baz::bazz ()
+				 ;;   { ...
+				 ;; 
+				 ;; Here we have to move the point to 
+				 ;; the beginning of foo, not bazz.
+				 (while (not (looking-back "\\(^\\|[ \t]\\)"))
+				   (forward-sexp -1))
+				 ;; Is this C++ method?
+				 (when (and (< 2 middle)
+					    (string= (buffer-substring (- middle 2)
+								       middle)
+						     "::"))
+				   ;; Include "classname::".
+				   (setq middle (point)))
+				 ;; Ignore these subparts of a class decl
+				 ;; and move back to the class name itself.
+				 (while (looking-at "public \\|private ")
+				   (skip-chars-backward " \t:")
+				   (setq end (point))
+				   (backward-sexp 1)
+				   (setq middle (point))
+				   (forward-word -1))
+				 (and (bolp)
+				      (looking-at
+				       "enum \\|struct \\|union \\|class ")
+				      (setq middle (point)))
+				 (goto-char end)
+				 (when (eq (preceding-char) ?=)
+				   (forward-char -1)
+				   (skip-chars-backward " \t")
+				   (setq end (point)))
+				 (buffer-substring-no-properties
+				  middle end)))))))))
 		((memq major-mode add-log-tex-like-modes)
 		 (if (re-search-backward
 		      "\\\\\\(sub\\)*\\(section\\|paragraph\\|chapter\\)"