[bpt/emacs.git] / lisp / add-log.el

;;; add-log.el --- change log maintenance commands for Emacs

;; Copyright (C) 1985, 86, 87, 88, 89, 90, 91, 1992
;;	Free Software Foundation, Inc.

;; This file is part of GNU Emacs.

;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to
;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

;;; Code:

;;;###autoload
(defvar change-log-default-name nil
  "*Name of a change log file for \\[add-change-log-entry].")

(defun change-log-name ()
  (or change-log-default-name
      (if (eq system-type 'vax-vms) "$CHANGE_LOG$.TXT" "ChangeLog")))

(defun prompt-for-change-log-name ()
  "Prompt for a change log name."
  (let ((default (change-log-name)))
    (expand-file-name
     (read-file-name (format "Log file (default %s): " default)
		     nil default))))

;;;###autoload
(defun add-change-log-entry (&optional whoami file-name other-window)
  "Find change log file and add an entry for today.
Optional arg (interactive prefix) non-nil means prompt for user name and site.
Second arg is file name of change log.  If nil, uses `change-log-default-name'.
Third arg OTHER-WINDOW non-nil means visit in other window."
  (interactive (list current-prefix-arg
		     (prompt-for-change-log-name)))
  (let* ((full-name (if whoami
			(read-input "Full name: " (user-full-name))
		      (user-full-name)))
	 ;; Note that some sites have room and phone number fields in
	 ;; full name which look silly when inserted.  Rather than do
	 ;; anything about that here, let user give prefix argument so that
	 ;; s/he can edit the full name field in prompter if s/he wants.
	 (login-name (if whoami
			 (read-input "Login name: " (user-login-name))
		       (user-login-name)))
	 (site-name (if whoami
			(read-input "Site name: " (system-name))
		      (system-name)))
	 (defun (add-log-current-defun))
	 entry entry-position empty-entry)
    (or file-name
	(setq file-name (or change-log-default-name
			    default-directory)))
    (setq file-name (if (file-directory-p file-name)
			(expand-file-name (change-log-name) file-name)
		      (expand-file-name file-name)))
    ;; Chase links before visiting the file.
    ;; This makes it easier to use a single change log file
    ;; for several related directories.
    (setq file-name (or (file-symlink-p file-name) file-name))
    (set (make-local-variable 'change-log-default-name) file-name)
    (if buffer-file-name
	(setq entry (if (string-match
			 (concat "^" (regexp-quote (file-name-directory
						    file-name)))
			 buffer-file-name)
			(substring buffer-file-name (match-end 0))
		      (file-name-nondirectory buffer-file-name))))
    ;; Never want to add a change log entry for the ChangeLog file itself.
    (if (equal entry "ChangeLog")
	(setq entry nil
	      defun nil))
    (if (and other-window (not (equal file-name buffer-file-name)))
	(find-file-other-window file-name)
      (find-file file-name))
    (undo-boundary)
    (goto-char (point-min))
    (if (not (and (looking-at (substring (current-time-string) 0 10))
		  (looking-at (concat ".* " full-name "  (" login-name "@"))))
	(progn (insert (current-time-string)
		       "  " full-name
		       "  (" login-name
		       "@" site-name ")\n\n")))
    (goto-char (point-min))
    (setq empty-entry
	  (and (search-forward "\n\t* \n" nil t)
	       (1- (point))))
    (if (and entry
	     (not empty-entry))
	;; Look for today's entry for the same file.
	;; If there is an empty entry (just a `*'), take the hint and
	;; use it.  This is so that C-x a from the ChangeLog buffer
	;; itself can be used to force the next entry to be added at
	;; the beginning, even if there are today's entries for the
	;; same file (but perhaps different revisions).
	(let ((entry-boundary (save-excursion
				(and (re-search-forward "\n[A-Z]" nil t)
				     (point)))))
	  (setq entry-position (save-excursion
				 (and (re-search-forward
				       (concat
					(regexp-quote (concat "* " entry))
					;; don't accept `foo.bar' when
					;; looking for `foo':
					"[ \n\t,:]")
				       entry-boundary
				       t)
				      (1- (match-end 0)))))))
    ;; Now insert the new line for this entry.
    (cond (entry-position
	   ;; Move to the existing entry for the same file.
	   (goto-char entry-position)
	   (re-search-forward "^\\s *$")
	   (beginning-of-line)
	   (while (and (not (eobp)) (looking-at "^\\s *$"))
	     (delete-region (point) (save-excursion (forward-line 1) (point))))
	   (insert "\n\n")
	   (forward-line -2)
	   (indent-relative-maybe))
	  (empty-entry
	   ;; Put this file name into the existing empty entry.
	   (goto-char empty-entry)
	   (if entry
	       (insert entry)))
	  (t
	   ;; Make a new entry.
	   (forward-line 1)
	   (while (looking-at "\\sW")
	     (forward-line 1))
	   (while (and (not (eobp)) (looking-at "^\\s *$"))
	     (delete-region (point) (save-excursion (forward-line 1) (point))))
	   (insert "\n\n\n")
	   (forward-line -2)
	   (indent-to left-margin)
	   (insert "* " (or entry ""))))
    ;; Now insert the function name, if we have one.
    ;; Point is at the entry for this file,
    ;; either at the end of the line or at the first blank line.
    (if defun
	(progn
	  ;; Make it easy to get rid of the function name.
	  (undo-boundary)
	  (insert (if (save-excursion
			(beginning-of-line 1)
			(looking-at "\\s *$")) 
		      ""
		    " ")
		  "(" defun "): "))
      ;; No function name, so put in a colon unless we have just a star.
      (if (not (save-excursion
		 (beginning-of-line 1)
		 (looking-at "\\s *\\(\\*\\s *\\)?$")))
	  (insert ": ")))))

;;;###autoload
(define-key ctl-x-4-map "a" 'add-change-log-entry-other-window)

;;;###autoload
(defun add-change-log-entry-other-window (&optional whoami file-name)
  "Find change log file in other window and add an entry for today.
First arg (interactive prefix) non-nil means prompt for user name and site.
Second arg is file name of change log.
Interactively, with a prefix argument, the file name is prompted for."
  (interactive (if current-prefix-arg
		   (list current-prefix-arg
			 (prompt-for-change-log-name))))
  (add-change-log-entry whoami file-name t))

(defun change-log-mode ()
  "Major mode for editting change logs; like Indented Text Mode.
Prevents numeric backups and sets `left-margin' to 8 and `fill-column' to 74.
New log entries are usually made with \\[add-change-log-entry] or \\[add-change-log-entry-other-window]."
  (interactive)
  (kill-all-local-variables)
  (indented-text-mode)
  (setq major-mode 'change-log-mode)
  (setq mode-name "Change Log")
  (setq left-margin 8)
  (setq fill-column 74)
  ;; Let each entry behave as one paragraph:
  (set (make-local-variable 'paragraph-start) "^\\s *$\\|^^L")
  (set (make-local-variable 'paragraph-separate) "^\\s *$\\|^^L\\|^\\sw")
  ;; Let all entries for one day behave as one page.
  ;; Note that a page boundary is also a paragraph boundary.
  ;; Unfortunately the date line of a page actually belongs to
  ;; the next day, but I don't see how to avoid that since
  ;; page moving cmds go to the end of the match, and Emacs
  ;; regexps don't have a context feature.
  (set (make-local-variable 'page-delimiter) "^[A-Z][a-z][a-z] .*\n\\|^\f")
  (set (make-local-variable 'version-control) 'never)
  (set (make-local-variable 'adaptive-fill-regexp) "\\s *")
  (run-hooks 'change-log-mode-hook))

(defvar add-log-current-defun-header-regexp
  "^\\([A-Z][A-Z_ ]+\\|[a-z_---A-Z]+\\)[ \t]*[:=]"
  "*Heuristic regexp used by `add-log-current-defun' for unknown major modes.")

(defun add-log-current-defun ()
  "Return name of function definition point is in, or nil.

Understands Lisp, LaTeX (\"functions\" are chapters, sections, ...),
Texinfo (@node titles), and C.

Other modes are handled by a heuristic that looks in the 10K before
point for uppercase headings starting in the first column or
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 (or (eq major-mode 'c-mode)
		      (eq major-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 (= (char-after (- (point) 2)) ?\\)
	       (forward-line -1))
	     (search-forward "define")
	     (skip-chars-forward " \t")
	     (buffer-substring (point)
			       (progn (forward-sexp 1) (point))))
	    ((or (eq major-mode 'c-mode)
		 (eq major-mode 'c++-mode))
	     ;; See if we are in the beginning part of a function,
	     ;; before the open brace.  If so, advance forward.
	     (while (not (or (looking-at "{")
			     (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.
		     (if (save-excursion
			   (while (and (not (bobp))
				       (looking-at "[^\n\f]")
				       (not (looking-at ".*\\*/")))
			     (forward-line -1))
			   (forward-line 1)
			   (setq tem (point))
			   (and (looking-at "DEFUN ")
				(>= location (point))))
			 (progn
			   (goto-char tem)
			   (down-list 1)
			   (forward-sexp 1)
			   (skip-chars-forward " ,")
			   (buffer-substring (point)
					     (progn (forward-sexp 1) (point))))
		       ;; Ordinary C function syntax.
		       (setq beg (point))
		       (down-list 1)	; into arglist
		       (backward-up-list 1)
		       (skip-chars-backward " \t")
		       ;; 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)
	       (if (re-search-backward add-log-current-defun-header-regexp
				       (- (point) 10000)
				       t)
		   (buffer-substring (match-beginning 1)
				     (match-end 1)))))))))

;;; add-log.el ends here
Commit	Line	Data
84fc2cfa ER	1	;;; add-log.el --- change log maintenance commands for Emacs
84fc2cfa ER	2
dd309224 RM	3	;; Copyright (C) 1985, 86, 87, 88, 89, 90, 91, 1992
dd309224 RM	4	;; Free Software Foundation, Inc.
84fc2cfa ER	5
	6	;; This file is part of GNU Emacs.
	7
	8	;; GNU Emacs is free software; you can redistribute it and/or modify
	9	;; it under the terms of the GNU General Public License as published by
fd7fa35a	10	;; the Free Software Foundation; either version 2, or (at your option)
84fc2cfa ER	11	;; any later version.
	12
	13	;; GNU Emacs is distributed in the hope that it will be useful,
	14	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	;; GNU General Public License for more details.
	17
	18	;; You should have received a copy of the GNU General Public License
	19	;; along with GNU Emacs; see the file COPYING. If not, write to
	20	;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
	21
fd7fa35a	22	;;; Code:
84fc2cfa ER	23
	24	;;;###autoload
	25	(defvar change-log-default-name nil
	26	"*Name of a change log file for \\[add-change-log-entry].")
	27
	28	(defun change-log-name ()
	29	(or change-log-default-name
	30	(if (eq system-type 'vax-vms) "$CHANGE_LOG$.TXT" "ChangeLog")))
	31
	32	(defun prompt-for-change-log-name ()
	33	"Prompt for a change log name."
	34	(let ((default (change-log-name)))
	35	(expand-file-name
	36	(read-file-name (format "Log file (default %s): " default)
	37	nil default))))
	38
	39	;;;###autoload
	40	(defun add-change-log-entry (&optional whoami file-name other-window)
	41	"Find change log file and add an entry for today.
	42	Optional arg (interactive prefix) non-nil means prompt for user name and site.
	43	Second arg is file name of change log. If nil, uses `change-log-default-name'.
	44	Third arg OTHER-WINDOW non-nil means visit in other window."
	45	(interactive (list current-prefix-arg
	46	(prompt-for-change-log-name)))
dd309224	47	(let* ((full-name (if whoami
84fc2cfa ER	48	(read-input "Full name: " (user-full-name))
	49	(user-full-name)))
	50	;; Note that some sites have room and phone number fields in
	51	;; full name which look silly when inserted. Rather than do
	52	;; anything about that here, let user give prefix argument so that
	53	;; s/he can edit the full name field in prompter if s/he wants.
	54	(login-name (if whoami
	55	(read-input "Login name: " (user-login-name))
	56	(user-login-name)))
	57	(site-name (if whoami
	58	(read-input "Site name: " (system-name))
21d7e080 ER	59	(system-name)))
21d7e080 ER	60	(defun (add-log-current-defun))
dd309224	61	entry entry-position empty-entry)
84fc2cfa ER	62	(or file-name
	63	(setq file-name (or change-log-default-name
	64	default-directory)))
dd309224 RM	65	(setq file-name (if (file-directory-p file-name)
	66	(expand-file-name (change-log-name) file-name)
	67	(expand-file-name file-name)))
09b389d0 RS	68	;; Chase links before visiting the file.
	69	;; This makes it easier to use a single change log file
	70	;; for several related directories.
	71	(setq file-name (or (file-symlink-p file-name) file-name))
84fc2cfa	72	(set (make-local-variable 'change-log-default-name) file-name)
dd309224 RM	73	(if buffer-file-name
	74	(setq entry (if (string-match
	75	(concat "^" (regexp-quote (file-name-directory
	76	file-name)))
	77	buffer-file-name)
	78	(substring buffer-file-name (match-end 0))
	79	(file-name-nondirectory buffer-file-name))))
1832dbd1 RS	80	;; Never want to add a change log entry for the ChangeLog file itself.
1832dbd1 RS	81	(if (equal entry "ChangeLog")
dd309224 RM	82	(setq entry nil
dd309224 RM	83	defun nil))
84fc2cfa ER	84	(if (and other-window (not (equal file-name buffer-file-name)))
	85	(find-file-other-window file-name)
	86	(find-file file-name))
	87	(undo-boundary)
	88	(goto-char (point-min))
	89	(if (not (and (looking-at (substring (current-time-string) 0 10))
	90	(looking-at (concat ".* " full-name " (" login-name "@"))))
	91	(progn (insert (current-time-string)
	92	" " full-name
	93	" (" login-name
	94	"@" site-name ")\n\n")))
	95	(goto-char (point-min))
21d7e080 ER	96	(setq empty-entry
	97	(and (search-forward "\n\t* \n" nil t)
	98	(1- (point))))
	99	(if (and entry
	100	(not empty-entry))
dd309224	101	;; Look for today's entry for the same file.
21d7e080 ER	102	;; If there is an empty entry (just a `*'), take the hint and
	103	;; use it. This is so that C-x a from the ChangeLog buffer
	104	;; itself can be used to force the next entry to be added at
	105	;; the beginning, even if there are today's entries for the
	106	;; same file (but perhaps different revisions).
dd309224 RM	107	(let ((entry-boundary (save-excursion
	108	(and (re-search-forward "\n[A-Z]" nil t)
	109	(point)))))
	110	(setq entry-position (save-excursion
	111	(and (re-search-forward
	112	(concat
	113	(regexp-quote (concat "* " entry))
	114	;; don't accept `foo.bar' when
	115	;; looking for `foo':
	116	"[ \n\t,:]")
	117	entry-boundary
	118	t)
	119	(1- (match-end 0)))))))
1832dbd1	120	;; Now insert the new line for this entry.
21d7e080	121	(cond (entry-position
dd309224 RM	122	;; Move to the existing entry for the same file.
	123	(goto-char entry-position)
	124	(re-search-forward "^\\s *$")
1832dbd1	125	(beginning-of-line)
09b389d0	126	(while (and (not (eobp)) (looking-at "^\\s *$"))
1832dbd1 RS	127	(delete-region (point) (save-excursion (forward-line 1) (point))))
	128	(insert "\n\n")
	129	(forward-line -2)
dd309224	130	(indent-relative-maybe))
21d7e080	131	(empty-entry
dd309224 RM	132	;; Put this file name into the existing empty entry.
	133	(goto-char empty-entry)
	134	(if entry
	135	(insert entry)))
21d7e080	136	(t
dd309224 RM	137	;; Make a new entry.
	138	(forward-line 1)
	139	(while (looking-at "\\sW")
	140	(forward-line 1))
09b389d0	141	(while (and (not (eobp)) (looking-at "^\\s *$"))
1832dbd1 RS	142	(delete-region (point) (save-excursion (forward-line 1) (point))))
	143	(insert "\n\n\n")
	144	(forward-line -2)
dd309224 RM	145	(indent-to left-margin)
dd309224 RM	146	(insert "* " (or entry ""))))
1832dbd1	147	;; Now insert the function name, if we have one.
21d7e080 ER	148	;; Point is at the entry for this file,
	149	;; either at the end of the line or at the first blank line.
	150	(if defun
	151	(progn
dd309224	152	;; Make it easy to get rid of the function name.
21d7e080	153	(undo-boundary)
dd309224 RM	154	(insert (if (save-excursion
	155	(beginning-of-line 1)
	156	(looking-at "\\s *$"))
	157	""
	158	" ")
	159	"(" defun "): "))
1832dbd1	160	;; No function name, so put in a colon unless we have just a star.
dd309224 RM	161	(if (not (save-excursion
	162	(beginning-of-line 1)
	163	(looking-at "\\s \\(\\\\s *\\)?$")))
1832dbd1	164	(insert ": ")))))
84fc2cfa ER	165
	166	;;;###autoload
	167	(define-key ctl-x-4-map "a" 'add-change-log-entry-other-window)
	168
	169	;;;###autoload
	170	(defun add-change-log-entry-other-window (&optional whoami file-name)
	171	"Find change log file in other window and add an entry for today.
	172	First arg (interactive prefix) non-nil means prompt for user name and site.
	173	Second arg is file name of change log.
	174	Interactively, with a prefix argument, the file name is prompted for."
	175	(interactive (if current-prefix-arg
	176	(list current-prefix-arg
	177	(prompt-for-change-log-name))))
	178	(add-change-log-entry whoami file-name t))
	179
21d7e080	180	(defun change-log-mode ()
dd309224	181	"Major mode for editting change logs; like Indented Text Mode.
09b389d0	182	Prevents numeric backups and sets `left-margin' to 8 and `fill-column' to 74.
043b998c	183	New log entries are usually made with \\[add-change-log-entry] or \\[add-change-log-entry-other-window]."
21d7e080 ER	184	(interactive)
	185	(kill-all-local-variables)
	186	(indented-text-mode)
	187	(setq major-mode 'change-log-mode)
	188	(setq mode-name "Change Log")
fd7fa35a ER	189	(setq left-margin 8)
fd7fa35a ER	190	(setq fill-column 74)
21d7e080	191	;; Let each entry behave as one paragraph:
dd309224 RM	192	(set (make-local-variable 'paragraph-start) "^\\s *$\\\|^^L")
dd309224 RM	193	(set (make-local-variable 'paragraph-separate) "^\\s *$\\\|^^L\\\|^\\sw")
21d7e080 ER	194	;; Let all entries for one day behave as one page.
	195	;; Note that a page boundary is also a paragraph boundary.
	196	;; Unfortunately the date line of a page actually belongs to
	197	;; the next day, but I don't see how to avoid that since
	198	;; page moving cmds go to the end of the match, and Emacs
	199	;; regexps don't have a context feature.
	200	(set (make-local-variable 'page-delimiter) "^[A-Z][a-z][a-z] .*\n\\\|^\f")
dd309224 RM	201	(set (make-local-variable 'version-control) 'never)
dd309224 RM	202	(set (make-local-variable 'adaptive-fill-regexp) "\\s *")
21d7e080 ER	203	(run-hooks 'change-log-mode-hook))
	204
	205	(defvar add-log-current-defun-header-regexp
	206	"^\\([A-Z][A-Z_ ]+\\\|[a-z_---A-Z]+\\)[ \t]*[:=]"
	207	"*Heuristic regexp used by `add-log-current-defun' for unknown major modes.")
	208
	209	(defun add-log-current-defun ()
	210	"Return name of function definition point is in, or nil.
	211
	212	Understands Lisp, LaTeX (\"functions\" are chapters, sections, ...),
	213	Texinfo (@node titles), and C.
	214
	215	Other modes are handled by a heuristic that looks in the 10K before
	216	point for uppercase headings starting in the first column or
	217	identifiers followed by `:' or `=', see variable
	218	`add-log-current-defun-header-regexp'.
	219
	220	Has a preference of looking backwards."
	221	(save-excursion
1832dbd1 RS	222	(let ((location (point)))
	223	(cond ((memq major-mode '(emacs-lisp-mode lisp-mode scheme-mode))
	224	;; If we are now precisely a the beginning of a defun,
	225	;; make sure beginning-of-defun finds that one
	226	;; rather than the previous one.
09b389d0	227	(or (eobp) (forward-char 1))
1832dbd1 RS	228	(beginning-of-defun)
1832dbd1 RS	229	;; Make sure we are really inside the defun found, not after it.
09b389d0 RS	230	(if (and (progn (end-of-defun)
	231	(< location (point)))
	232	(progn (forward-sexp -1)
	233	(>= location (point))))
1832dbd1 RS	234	(progn
	235	(forward-word 1)
	236	(skip-chars-forward " ")
	237	(buffer-substring (point)
	238	(progn (forward-sexp 1) (point))))))
09b389d0 RS	239	((and (or (eq major-mode 'c-mode)
	240	(eq major-mode 'c++-mode))
	241	(save-excursion (beginning-of-line)
7e9b0c96 RM	242	;; Use eq instead of = here to avoid
	243	;; error when at bob and char-after
	244	;; returns nil.
	245	(while (eq (char-after (- (point) 2)) ?\\)
09b389d0 RS	246	(forward-line -1))
	247	(looking-at "[ \t]#[ \t]define[ \t]")))
	248	;; Handle a C macro definition.
	249	(beginning-of-line)
	250	(while (= (char-after (- (point) 2)) ?\\)
	251	(forward-line -1))
	252	(search-forward "define")
	253	(skip-chars-forward " \t")
	254	(buffer-substring (point)
	255	(progn (forward-sexp 1) (point))))
1832dbd1 RS	256	((or (eq major-mode 'c-mode)
	257	(eq major-mode 'c++-mode))
	258	;; See if we are in the beginning part of a function,
	259	;; before the open brace. If so, advance forward.
	260	(while (not (or (looking-at "{")
	261	(looking-at "\\s *$")))
	262	(forward-line 1))
09b389d0	263	(or (eobp) (forward-char 1))
1832dbd1	264	(beginning-of-defun)
09b389d0 RS	265	(if (progn (end-of-defun)
09b389d0 RS	266	(< location (point)))
1832dbd1	267	(progn
09b389d0 RS	268	(backward-sexp 1)
	269	(let (beg tem)
	270
	271	(forward-line -1)
	272	;; Skip back over typedefs of arglist.
	273	(while (and (not (bobp))
	274	(looking-at "[ \t\n]"))
	275	(forward-line -1))
	276	;; See if this is using the DEFUN macro used in Emacs.
	277	(if (save-excursion
	278	(while (and (not (bobp))
	279	(looking-at "[^\n\f]")
	280	(not (looking-at ".\\/")))
	281	(forward-line -1))
	282	(forward-line 1)
	283	(setq tem (point))
	284	(and (looking-at "DEFUN ")
	285	(>= location (point))))
	286	(progn
	287	(goto-char tem)
	288	(down-list 1)
	289	(forward-sexp 1)
	290	(skip-chars-forward " ,")
	291	(buffer-substring (point)
	292	(progn (forward-sexp 1) (point))))
	293	;; Ordinary C function syntax.
	294	(setq beg (point))
	295	(down-list 1) ; into arglist
	296	(backward-up-list 1)
	297	(skip-chars-backward " \t")
	298	;; Verify initial pos was after real start of function.
	299	(if (and (save-excursion
	300	(goto-char beg)
	301	;; For this purpose, include the line
	302	;; that has the decl keywords.
	303	;; This may also include some of the comments
	304	;; before the function.
	305	(while (and (not (bobp))
	306	(save-excursion (forward-line -1)
	307	(looking-at "[^\n\f]")))
	308	(forward-line -1))
	309	(>= location (point)))
	310	;; Consistency check: going down and up
	311	;; shouldn't take us back before BEG.
	312	(> (point) beg))
	313	(buffer-substring (point)
	314	(progn (backward-sexp 1)
	315	(point)))))))))
1832dbd1 RS	316	((memq major-mode
	317	'(TeX-mode plain-TeX-mode LaTeX-mode;; tex-mode.el
	318	plain-tex-mode latex-mode;; cmutex.el
	319	))
	320	(if (re-search-backward
	321	"\\\\\\(sub\\)*\\(section\\\|paragraph\\\|chapter\\)" nil t)
	322	(progn
	323	(goto-char (match-beginning 0))
	324	(buffer-substring (1+ (point));; without initial backslash
	325	(progn
	326	(end-of-line)
	327	(point))))))
	328	((eq major-mode 'texinfo-mode)
	329	(if (re-search-backward "^@node[ \t]+\\([^,]+\\)," nil t)
21d7e080	330	(buffer-substring (match-beginning 1)
1832dbd1 RS	331	(match-end 1))))
	332	(t
	333	;; If all else fails, try heuristics
	334	(let (case-fold-search)
	335	(if (re-search-backward add-log-current-defun-header-regexp
	336	(- (point) 10000)
	337	t)
	338	(buffer-substring (match-beginning 1)
	339	(match-end 1)))))))))
fd7fa35a ER	340
fd7fa35a ER	341	;;; add-log.el ends here