Don't require cl, fortran.

(add-log-current-defun-function): Doc fix.
(change-log-version-number-regexp-list): Remove SCCS stuff.  Doc
fix.
(change-log-mode-map): Defvar directly.
(change-log-version-rcs): Function deleted.
(change-log-version-number-search): Doc fix.

1 files changed, 169 insertions, 219 deletions

diff --git a/lisp/add-log.el b/lisp/add-log.el
index a30e5eb9b7e..a89cbd49f6d 100644
--- a/lisp/add-log.el
+++ b/lisp/add-log.el
@@ -1,6 +1,6 @@
 ;;; add-log.el --- change log maintenance commands for Emacs
 
-;; Copyright (C) 1985, 86, 88, 93, 94, 97, 1998, 2000 Free Software Foundation, Inc.
+;; Copyright (C) 1985, 86, 88, 93, 94, 97, 98, 2000 Free Software Foundation, Inc.
 
 ;; Keywords: tools
 
@@ -28,9 +28,7 @@
 ;;; Code:
 
 (eval-when-compile
-  (require 'fortran)
-  (require 'timezone)
-  (require 'cl))
+  (require 'timezone))
 
 (defgroup change-log nil
   "Change log maintenance"
@@ -52,10 +50,9 @@
   :group 'change-log)
 
 (defcustom add-log-current-defun-function nil
-  "\
-*If non-nil, function to guess name of current function from surrounding text.
-\\[add-change-log-entry] calls this function (if nil, `add-log-current-defun'
-instead) with no arguments.  It returns a string or nil if it cannot guess."
+  "*If non-nil, function to guess name of surrounding function.
+It is used by `add-log-current-defun' in preference to built-in rules.
+Returns function's name as a string, or nil if outside a function."
   :type 'function
   :group 'change-log)
 
@@ -140,11 +137,9 @@ use the file's name relative to the directory of the change log file."
      ;;  (defconst ad-version "2.15"
      (concat "^(def[^ \t\n]+[ \t]+[^ \t\n][ \t]\"" re)
      ;; Revision: pcl-cvs.el,v 1.72 1999/09/05 20:21:54 monnier Exp
-     (concat "^;+ *Revision: +[^ \t\n]+[ \t]+" re)
-     ;; SCCS @(#)igrep.el 2.83
-     (concat "SCCS[ \t]+@(#).*[ \t]+" re)
-     ))
+     (concat "^;+ *Revision: +[^ \t\n]+[ \t]+" re)))
   "*List of regexps to search for version number.
+The version number must be in group 1.
 Note: The search is conducted only within 10%, at the beginning of the file."
   :version "21.1"
   :type '(repeat regexp)
@@ -185,11 +180,8 @@ Note: The search is conducted only within 10%, at the beginning of the file."
      1 font-lock-comment-face))
   "Additional expressions to highlight in Change Log mode.")
 
-(defvar change-log-mode-map nil
+(defvar change-log-mode-map (make-sparse-keymap)
   "Keymap for Change Log major mode.")
-(if change-log-mode-map
-    nil
-  (setq change-log-mode-map (make-sparse-keymap)))
 
 (defvar change-log-time-zone-rule nil
   "Time zone used for calculating change log time stamps.
@@ -248,50 +240,33 @@ If nil, use local time.")
 			    (file-name-as-directory name))
 	name))))
 
-(defun change-log-version-rcs (rcs-string &optional end)
-  "Search for plain RCS-STRING from whole buffer up till END.
-The surrounding $ characters fro RCS-STRING are added in this function;
-provide argument e.g. as \"Id\"."
-  (let (str)
-    (save-excursion
-      (goto-char (point-min))
-      (when (re-search-forward
-	     (concat "[$]" rcs-string ":[^\n$]+[$]")
-	     end t)
-	(setq str (match-string 0))
-	(when (string-match "[0-9]+\.[0-9.]+" str)
-	  (match-string 0 str))))))
-
 (defun change-log-version-number-search ()
-  "Return version number for the file by searchin version control tags."
+  "Return version number of current buffer's file.
+This is the value returned by `vc-workfile-version' or, if that is
+nil, by matching `change-log-version-number-regexp-list'."
   (let* ((size (buffer-size))
 	 (end
-	  ;;  The version number can be anywhere in the file, but restrict
-	  ;;  search to the file beginning: 10% should be enough to prevent
-	  ;;  some mishits.
+	  ;; The version number can be anywhere in the file, but
+	  ;; restrict search to the file beginning: 10% should be
+	  ;; enough to prevent some mishits.
 	  ;;
-	  ;;  Apply percentage only if buffer size is bigger than approx 100 lines
+	  ;; Apply percentage only if buffer size is bigger than
+	  ;; approx 100 lines.
 	  (if (> size (* 100 80))
-	      (/ (* (buffer-size) 10) 100)
+	      (/ size 10)
 	    size))
 	 version)
-
-    ;; Search RCS, CVS version strings
-
-    (dolist (choice '("Revision" "Id"))
-      (when (setq version (change-log-version-rcs choice end))
-	(return)))
-
-    (unless version
-      (dolist (regexp change-log-version-number-regexp-list)
-	(save-excursion
-	  (goto-char (point-min))
-	  (when (re-search-forward regexp end t)
-	    (setq version (match-string 1))
-	    (return)))))
-
-      version
-      ))
+    (or (and buffer-file-name
+	     (vc-workfile-version buffer-file-name))
+	(save-restriction
+	  (widen)
+	  (let ((regexps change-log-version-number-regexp-list))
+	    (while regexps
+	      (save-excursion
+		(goto-char (point-min))
+		(when (re-search-forward (pop regexps) end t)
+		  (setq version (match-string 1)
+			regexps nil)))))))))
 
 
 ;;;###autoload
@@ -380,12 +355,10 @@ non-nil, otherwise in local time."
 	 ;; s/he can edit the full name field in prompter if s/he wants.
 	(setq add-log-mailing-address
 	      (read-input "Mailing address: " add-log-mailing-address))))
-  (let ((defun (funcall (or add-log-current-defun-function
-			    'add-log-current-defun)))
+  (let ((defun (add-log-current-defun))
 	(version (and change-log-version-info-enabled
 		      (change-log-version-number-search)))
-	bound
-	entry)
+	bound entry)
 
     (setq file-name (expand-file-name (find-change-log file-name)))
 
@@ -450,7 +423,7 @@ non-nil, otherwise in local time."
 	   (goto-char (match-beginning 0))
 	   ;; Delete excess empty lines; make just 2.
 	   (while (and (not (eobp)) (looking-at "^\\s *$"))
-	     (delete-region (point) (save-excursion (forward-line 1) (point))))
+	     (delete-region (point) (line-beginning-position 2)))
 	   (insert "\n\n")
 	   (forward-line -2)
 	   (indent-relative-maybe))
@@ -460,12 +433,11 @@ non-nil, otherwise in local time."
 	   (while (looking-at "\\sW")
 	     (forward-line 1))
 	   (while (and (not (eobp)) (looking-at "^\\s *$"))
-	     (delete-region (point) (save-excursion (forward-line 1) (point))))
+	     (delete-region (point) (line-beginning-position 2)))
 	   (insert "\n\n\n")
 	   (forward-line -2)
 	   (indent-to left-margin)
-	   (insert "* " (or entry ""))
-	   ))
+	   (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.
@@ -473,22 +445,19 @@ non-nil, otherwise in local time."
 	(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 "): "
-		  (if version
-		      (concat version " ")
-		    "")))
+	  (unless (save-excursion
+		    (beginning-of-line 1)
+		    (looking-at "\\s *$"))
+	    (insert ?\ ))
+	  (insert "(" defun "): ")
+	  (if version
+	      (insert version ?\ )))
       ;; 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 ": "
-		  (if version
-		      (concat version " ") ""))))))
+      (unless (save-excursion
+		(beginning-of-line 1)
+		(looking-at "\\s *\\(\\*\\s *\\)?$"))
+	(insert ": ")
+	(if version (insert version ?\ ))))))
 
 ;;;###autoload
 (defun add-change-log-entry-other-window (&optional whoami file-name)
@@ -579,11 +548,11 @@ Prefix arg means justify as well."
   "Return name of function definition point is in, or nil.
 
 Understands C, Lisp, LaTeX (\"functions\" are chapters, sections, ...),
-Texinfo (@node titles), Perl, and Fortran.
+Texinfo (@node titles) and Perl.
 
 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 variables
+identifiers followed by `:' or `='.  See variables
 `add-log-current-defun-header-regexp' and
 `add-log-current-defun-function'
 
@@ -591,15 +560,16 @@ Has a preference of looking backwards."
   (condition-case nil
       (save-excursion
 	(let ((location (point)))
-	  (cond ((and (functionp add-log-current-defun-function)
-		      (funcall add-log-current-defun-function)))
+	  (cond (add-log-current-defun-function
+		 (funcall add-log-current-defun-function))
 		((memq major-mode add-log-lisp-like-modes)
 		 ;; If we are now precisely at 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.
+		 ;; Make sure we are really inside the defun found,
+		 ;; not after it.
 		 (when (and (looking-at "\\s(")
 			    (progn (end-of-defun)
 				   (< location (point)))
@@ -613,9 +583,9 @@ Has a preference of looking backwards."
 		   ;; The second element is usually a symbol being defined.
 		   ;; If it is not, use the first symbol in it.
 		   (skip-chars-forward " \t\n'(")
-		   (buffer-substring (point)
-				     (progn (forward-sexp 1)
-					    (point)))))
+		   (buffer-substring-no-properties (point)
+						   (progn (forward-sexp 1)
+							  (point)))))
 		((and (memq major-mode add-log-c-like-modes)
 		      (save-excursion
 			(beginning-of-line)
@@ -631,8 +601,9 @@ Has a preference of looking backwards."
 		   (forward-line -1))
 		 (search-forward "define")
 		 (skip-chars-forward " \t")
-		 (buffer-substring (point)
-				   (progn (forward-sexp 1) (point))))
+		 (buffer-substring-no-properties (point)
+						 (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,
@@ -642,142 +613,123 @@ Has a preference of looking backwards."
 		 (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
-					(end-of-line)
-					(while (= (preceding-char) ?\\)
-					  (end-of-line 2))
-					(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))))
-                           (if (looking-at "^[+-]")
-                               (change-log-get-method-definition)
-                             ;; Ordinary C function syntax.
-                             (setq beg (point))
-                             (if (and (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.
-				      (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)
-				   ;; 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 middle end)))))))))
+		 (when (progn (end-of-defun)
+			      (< location (point)))
+		   (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
+				    (end-of-line)
+				    (while (= (preceding-char) ?\\)
+				      (end-of-line 2))
+				    (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-no-properties
+			    (point)
+			    (progn (forward-sexp 1)
+				   (point))))
+		       (if (looking-at "^[+-]")
+			   (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))
+			       (forward-word -1)
+			       ;; 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\\)" nil t)
+		      "\\\\\\(sub\\)*\\(section\\|paragraph\\|chapter\\)"
+		      nil t)
 		     (progn
 		       (goto-char (match-beginning 0))
-		       (buffer-substring (1+ (point));; without initial backslash
-					 (progn
-					   (end-of-line)
-					   (point))))))
+		       (buffer-substring-no-properties
+			(1+ (point))	; without initial backslash
+			(line-end-position)))))
 		((eq major-mode 'texinfo-mode)
 		 (if (re-search-backward "^@node[ \t]+\\([^,\n]+\\)" nil t)
-		     (buffer-substring (match-beginning 1)
-				       (match-end 1))))
+		     (match-string-no-properties 1)))
 		((eq major-mode 'perl-mode)
 		 (if (re-search-backward "^sub[ \t]+\\([^ \t\n]+\\)" nil t)
-		     (buffer-substring (match-beginning 1)
-				       (match-end 1))))
+		     (match-string-no-properties 1)))
+		;; Emacs's autoconf-mode installs its own
+		;; `add-log-current-defun-function'.  This applies to
+		;; a different mode apparently for editing .m4
+		;; autoconf source.
                 ((eq major-mode 'autoconf-mode)
-                 (if (re-search-backward "^\\(\\(m4_\\)?define\\|A._DEFUN\\)(\\[?\\([A-Za-z0-9_]+\\)" nil t)
-                     (buffer-substring (match-beginning 3)
-                                       (match-end 3))))
-                ((or (eq major-mode 'fortran-mode)
-		     ;; Needs work for f90, but better than nothing.
-		     (eq major-mode 'f90-mode))
-                 ;; must be inside function body for this to work
-                 (fortran-beginning-of-subprogram)
-                 (let ((case-fold-search t)) ; case-insensitive
-                   ;; search for fortran subprogram start
-                   (if (re-search-forward
-                        "^[ \t]*\\(program\\|subroutine\\|function\
-\\|[ \ta-z0-9*()]*[ \t]+function\\|\\(block[ \t]*data\\)\\)"
-                        (save-excursion (fortran-end-of-subprogram)
-                                        (point))
-                        t)
-                       (or (match-string 2)
-                           (progn
-                             ;; move to EOL or before first left paren
-                             (if (re-search-forward "[(\n]" nil t)
-				 (progn (backward-char)
-                                        (skip-chars-backward " \t"))
-                               (end-of-line))
-                             ;; Use the name preceding that.
-                             (buffer-substring (point)
-					       (progn (backward-sexp)
-						      (point)))))
-		     "main")))
+                 (if (re-search-backward
+		      "^\\(\\(m4_\\)?define\\|A._DEFUN\\)(\\[?\\([A-Za-z0-9_]+\\)" nil t)
+                     (match-string-no-properties 3)))
 		(t
 		 ;; If all else fails, try heuristics
 		 (let (case-fold-search
@@ -787,14 +739,12 @@ Has a preference of looking backwards."
 			  add-log-current-defun-header-regexp
 			  (- (point) 10000)
 			  t)
-		     (setq result (or (buffer-substring (match-beginning 1)
-							(match-end 1))
-				      (buffer-substring (match-beginning 0)
-							(match-end 0))))
+		     (setq result (or (match-string-no-properties 1)
+				      (match-string-no-properties 0)))
 		     ;; Strip whitespace away
 		     (when (string-match "\\([^ \t\n\r\f].*[^ \t\n\r\f]\\)"
 					 result)
-		       (setq result (match-string 1 result)))
+		       (setq result (match-string-no-properties 1 result)))
 		     result))))))
     (error nil)))
 
@@ -806,7 +756,7 @@ Has a preference of looking backwards."
 (defun change-log-get-method-definition-1 (end)
   (setq change-log-get-method-definition-md
 	(concat change-log-get-method-definition-md
-		(buffer-substring (match-beginning 1) (match-end 1))
+		(match-string 1)
 		end))
   (goto-char (match-end 0)))