Commits

youngs  committed fec413c

2002-01-26 Adrian Aichner <adrian@xemacs.org>

* pcl-cvs-defs.el (cvs-diff-ignore-marks): Update docstring by synch.
* pcl-cvs-defs.el (cvs-confirm-removals): Ditto.
* pcl-cvs-defs.el (cvs-add-default-message): Ditto.
* pcl-cvs-defs.el (cvs-mode-map): Comment out mapping of
`cvs-mode-undo' to undo, Add mappings for "z", "\C-m", "!" and
[mouse-2]. Remove bad mapping of cvs-mode-force-command to "M-f"
(also submitted to pcvs in GNU Emacs).
* pcl-cvs-info.el: Cosmetic synch with pcvs.
* pcl-cvs-info.el (cvs-applicable-p): Ditto.
* pcl-cvs-info.el (cvs-fileinfo-pp): Ditto.
* pcl-cvs-info.el (cvs-fileinfo<): Ditto.
* pcl-cvs-parse.el (cvs-parse-buffer): Update docstring by synch.
* pcl-cvs-parse.el (cvs-parse-merge): Ditto.
* pcl-cvs-util.el: Cosmetic synch with pcvs.
* pcl-cvs-util.el (cvs-pop-to-buffer-same-frame): Ditto.
* pcl-cvs-util.el (cvs-bury-buffer): Don't delete existing window.
* pcl-cvs-util.el (cvs-insert-strings): New.
* pcl-cvs-util.el (cvs-prefix-set): Cosmetic synch with pcvs.
* pcl-cvs.el: Cosmetic synch with pcvs.
* pcl-cvs.el (cvs-diff-flags): Add to list of defaults.
* pcl-cvs.el (cvs-mode!): Cosmetic synch with pcvs.
* pcl-cvs.el (cvs-temp-buffer): Ditto.
* pcl-cvs.el (cvs-cmd-do): Ditto.
* pcl-cvs.el (cvs-run-process): Ditto.
* pcl-cvs.el (cvs-sentinel): Ditto.
* pcl-cvs.el (cvs-parse-process): Ditto.
* pcl-cvs.el ((cvs-mode-revert-buffer . SIMPLE)): Ditto.
* pcl-cvs.el (cvs-quickdir): New.
* pcl-cvs.el (cvs-update-filter): Cosmetic synch with pcvs.
* pcl-cvs.el (cvs-mode): Ditto.
* pcl-cvs.el (cvs-mouse-toggle-mark): Ditto.
* pcl-cvs.el ((cvs-mode-diff . DOUBLE)): Ditto.
* pcl-cvs.el ((cvs-mode-diff-head . SIMPLE)): Ditto.
* pcl-cvs.el ((cvs-mode-diff-vendor . SIMPLE)): Ditto.
* pcl-cvs.el ((cvs-mode-idiff-other . NOARGS)): Ditto.
* pcl-cvs.el (cvs-mode-delete-lock): Ditto.
* pcl-cvs.el (cvs-mode-add-change-log-entry-other-window): Ditto.
* pcl-cvs.el (cvs-dired-use-hook): Ditto.
* pcl-cvs.texi: Add Stefan Monnier (incomplete merge).

  • Participants
  • Parent commits 500fd4a

Comments (0)

Files changed (7)

+2002-01-26  Adrian Aichner  <adrian@xemacs.org>
+
+	* pcl-cvs-defs.el (cvs-diff-ignore-marks): Update docstring by synch.
+	* pcl-cvs-defs.el (cvs-confirm-removals): Ditto.
+	* pcl-cvs-defs.el (cvs-add-default-message): Ditto.
+	* pcl-cvs-defs.el (cvs-mode-map): Comment out mapping of
+	`cvs-mode-undo' to undo, Add mappings for "z", "\C-m", "!" and
+	[mouse-2].  Remove bad mapping of cvs-mode-force-command to "M-f"
+	(also submitted to pcvs in GNU Emacs).
+	* pcl-cvs-info.el: Cosmetic synch with pcvs.
+	* pcl-cvs-info.el (cvs-applicable-p): Ditto.
+	* pcl-cvs-info.el (cvs-fileinfo-pp): Ditto.
+	* pcl-cvs-info.el (cvs-fileinfo<): Ditto.
+	* pcl-cvs-parse.el (cvs-parse-buffer): Update docstring by synch.
+	* pcl-cvs-parse.el (cvs-parse-merge): Ditto.
+	* pcl-cvs-util.el: Cosmetic synch with pcvs.
+	* pcl-cvs-util.el (cvs-pop-to-buffer-same-frame): Ditto.
+	* pcl-cvs-util.el (cvs-bury-buffer): Don't delete existing window.
+	* pcl-cvs-util.el (cvs-insert-strings): New.
+	* pcl-cvs-util.el (cvs-prefix-set): Cosmetic synch with pcvs.
+	* pcl-cvs.el: Cosmetic synch with pcvs.
+	* pcl-cvs.el (cvs-diff-flags): Add to list of defaults.
+	* pcl-cvs.el (cvs-mode!): Cosmetic synch with pcvs.
+	* pcl-cvs.el (cvs-temp-buffer): Ditto.
+	* pcl-cvs.el (cvs-cmd-do): Ditto.
+	* pcl-cvs.el (cvs-run-process): Ditto.
+	* pcl-cvs.el (cvs-sentinel): Ditto.
+	* pcl-cvs.el (cvs-parse-process): Ditto.
+	* pcl-cvs.el ((cvs-mode-revert-buffer . SIMPLE)): Ditto.
+	* pcl-cvs.el (cvs-quickdir): New.
+	* pcl-cvs.el (cvs-update-filter): Cosmetic synch with pcvs.
+	* pcl-cvs.el (cvs-mode): Ditto.
+	* pcl-cvs.el (cvs-mouse-toggle-mark): Ditto.
+	* pcl-cvs.el ((cvs-mode-diff . DOUBLE)): Ditto.
+	* pcl-cvs.el ((cvs-mode-diff-head . SIMPLE)): Ditto.
+	* pcl-cvs.el ((cvs-mode-diff-vendor . SIMPLE)): Ditto.
+	* pcl-cvs.el ((cvs-mode-idiff-other . NOARGS)): Ditto.
+	* pcl-cvs.el (cvs-mode-delete-lock): Ditto.
+	* pcl-cvs.el (cvs-mode-add-change-log-entry-other-window): Ditto.
+	* pcl-cvs.el (cvs-dired-use-hook): Ditto.
+	* pcl-cvs.texi: Add Stefan Monnier (incomplete merge).
+
 2002-01-22  Jarl Friis  <jarl@diku.dk>
 
 	* pcl-cvs.el (cvs-reread-cvsrc): using default parameters for

File pcl-cvs-defs.el

   :type '(boolean))
 
 (defvar cvs-diff-ignore-marks t
-  "Obsolete variable: use cvs-ignore-marks instead.")
+  "Obsolete: use `cvs-invert-ignore-marks' instead.")
 
 (defcustom cvs-invert-ignore-marks
   (let ((l ()))
   "*Ask for confirmation before removing files.
 Non-nil means that PCL-CVS will ask confirmation before removing files
 except for files whose content can readily be recovered from the repository.
-A value of LIST means that the list of files to be deleted will be
+A value of `list' means that the list of files to be deleted will be
 displayed when asking for confirmation."
   :group 'pcl-cvs
   :type '(choice (const list)
 
 (defcustom cvs-add-default-message nil
   "*Default message to use when adding files.
-If set to NIL, `cvs-mode-add' will always prompt for a message."
+If set to nil, `cvs-mode-add' will always prompt for a message."
   :group 'pcl-cvs
   :type '(choice (const :tag "Prompt" nil)
 		 (string)))
     (("0" "1" "2" "3" "4" "5" "6" "7" "8" "9") . digit-argument)
     ("-" .	negative-argument)
     ;; various
-    (undo .	cvs-mode-undo)
+    ;; (undo .	cvs-mode-undo)
     ("?" .	cvs-help)
     ("h" .	cvs-help)
     ("q" .	cvs-bury-buffer)
-    ;;("Q" .	kill-buffer)
+    ("z" .	kill-this-buffer)
     ("F" .	cvs-mode-set-flags)
-    ("\M-f" .	cvs-mode-force-command)
+    ("!" .	cvs-mode-force-command)
     ("\C-c\C-c" . cvs-mode-kill-process)
     ;; marking
     ("m" .	cvs-mode-mark)
     ("c" .	cvs-mode-commit)
     ("e" .	cvs-mode-examine)
     ("f" .	cvs-mode-find-file)
+    ("\C-m" .	cvs-mode-find-file)
     ("i" .	cvs-mode-ignore)
     ("l" .	cvs-mode-log)
     ("o" .	cvs-mode-find-file-other-window)
     ;; cvstree bindings
     ("+" .	cvs-mode-tree)
     ;; mouse bindings
+    ([mouse-2] . cvs-mode-find-file)
     ([(down-mouse-3)] . cvs-menu)
     ;; Emacs-21 toolbar
     ;;([tool-bar item1] . (menu-item "Examine" cvs-examine :image (image :file "/usr/share/icons/xpaint.xpm" :type xpm)))

File pcl-cvs-info.el

   :group 'pcl-cvs
   :type '(boolean))
 
-
 ;;;;
 ;;;; Faces for fontification
 ;;;;
 ;;;; Utility functions
 ;;;;
 
-;;----------
 (defun cvs-applicable-p (fi-or-type func)
   "Check if FUNC is applicable to FI-OR-TYPE.
 If FUNC is nil, always return t.
 			 str))
   str)
 
-;;----------
 (defun cvs-fileinfo-pp (fileinfo)
   "Pretty print FILEINFO.  Insert a printed representation in current buffer.
 For use by the cookie package."
      ((memq type '(UP-TO-DATE NEED-UPDATE))
       (setf (cvs-fileinfo->merge fi) nil)))))
 
-;;----------
 (defun cvs-fileinfo< (a b)
   "Compare fileinfo A with fileinfo B and return t if A is `less'.
 The ordering defined by this function is such that directories are

File pcl-cvs-parse.el

   either a fileinfo or t (if the matched text should be ignored) or
   nil if it didn't match anything.
 DONT-CHANGE-DISC just indicates whether the command was changing the disc
-  or not (useful to tell the difference btween `cvs-examine' and `cvs-update'
-  ouytput.
+  or not (useful to tell the difference between `cvs-examine' and `cvs-update'
+  output.
 The path names should be interpreted as relative to SUBDIR (defaults
   to the `default-directory').
-Return a list of collected entries, or t if an error occured."
+Return a list of collected entries, or t if an error occurred."
   (goto-char (point-min))
   (let ((fileinfos ())
 	(cvs-current-dir "")
 			   "\\) already contains the differences between .*$")
 		   (path 1) (type '(UP-TO-DATE . MERGED)))
 	t)
+       ;; FIXME: PATH might not be set yet.  Sometimes the only path
+       ;; information is in `RCS file: ...' (yuck!!).
        (cvs-parsed-fileinfo (if dont-change-disc 'NEED-MERGE
 			      (or type '(MODIFIED . MERGED))) path nil
 			    :merge (cons base-rev head-rev))))))

File pcl-cvs-util.el

 
 ;;;;
 ;;;; list processing
-;;;l
+;;;;
 
 (defsubst cvs-car (x) (if (consp x) (car x) x))
 (defalias 'cvs-cdr 'cdr-safe)
 (defun cvs-pop-to-buffer-same-frame (buf)
   "Pop to BUF like `pop-to-buffer' but staying on the same frame.
 If `pop-to-buffer' would have opened a new frame, this function would
-try to split the a new window instead."
+try to split a new window instead."
   (let ((pop-up-windows (or pop-up-windows pop-up-frames))
 	(pop-up-frames nil))
     (or (let ((buf (get-buffer-window buf))) (and buf (select-window buf)))
 		(delete-window win)
 	      (error (iconify-frame (window-frame win))))
 	  (if (and mainbuf (get-buffer-window mainbuf))
-	      (delete-window win)))))
+	      ;; FIXME: if the buffer popped into a pre-existing window,
+	      ;; we don't want to delete that window.
+	      t ;;(delete-window win)
+	      ))))
     (with-current-buffer buf
       (bury-buffer (unless (and (eq buf (window-buffer (selected-window)))
 				(not (window-dedicated-p (selected-window))))
 ;;;; string processing
 ;;;;
 
+(defun cvs-insert-strings (strings)
+  "Insert a list of STRINGS into the current buffer.
+Uses columns to keep the listing readable but compact."
+  (when (consp strings)
+    (let* ((length (apply 'max (mapcar 'length strings)))
+	   (wwidth (1- (window-width)))
+	   (columns (min
+		     ;; At least 2 columns; at least 2 spaces between columns.
+		     (max 2 (/ wwidth (+ 2 length)))
+		     ;; Don't allocate more columns than we can fill.
+		     ;; Windows can't show less than 3 lines anyway.
+		     (max 1 (/ (length strings) 2))))
+	   (colwidth (/ wwidth columns)))
+      ;; Use tab-width rather than indent-to.
+      (setq tab-width colwidth)
+      ;; The insertion should be "sensible" no matter what choices were made.
+      (dolist (str strings)
+	(unless (bolp) (insert " \t"))
+	(when (< wwidth (+ (max colwidth (length str)) (current-column)))
+	  (delete-char -2) (insert "\n"))
+	(insert str)))))
+
+
 (defun cvs-file-to-string (file &optional oneline args)
   "Read the content of FILE and return it as a string.
 If ONELINE is t, only the first line (no \\n) will be returned.
   it queries the user and sets the -ARG'th default.
 If ARG is greater than 9 (or \\[universal-argument] \\[universal-argument]),
   the (ARG mod 10)'th prefix is made persistent.
-If ARG is NIL toggle the PREFIX's value between its 0th default and NIL
+If ARG is nil toggle the PREFIX's value between its 0th default and nil
   and reset the persistence."
   (let* ((prefix (symbol-value (cvs-prefix-sym sym)))
 	 (numarg (if (integerp arg) arg 0))
 
 (defvar cvs-from-vc nil "Bound to t inside VC advice.")
 
-;;;; 
+;;;;
 ;;;; flags variables
-;;;; 
+;;;;
 
 (defun cvs-defaults (&rest defs)
   (let ((defs (cvs-first defs cvs-shared-start)))
 (cvs-flags-define cvs-checkout-flags (cvs-defaults '("-P")))
 (cvs-flags-define cvs-status-flags (cvs-defaults '("-v") nil))
 (cvs-flags-define cvs-log-flags (cvs-defaults nil))
-(cvs-flags-define cvs-diff-flags (cvs-defaults '("-u" "-N") '("-c" "-N")))
+(cvs-flags-define cvs-diff-flags (cvs-defaults '("-u" "-N") '("-c" "-N") '("-u" "-b")))
 (cvs-flags-define cvs-tag-flags (cvs-defaults nil))
 (cvs-flags-define cvs-add-flags (cvs-defaults nil))
 (cvs-flags-define cvs-commit-flags (cvs-defaults nil))
   "Mode-line control for displaying info on cvs process status.")
 
 
-;;;; 
+;;;;
 ;;;; Query-Type-Descriptor for Tags
-;;;; 
+;;;;
 
 (eval-when-compile (autoload 'cvs-status-get-tags "cvs-status"))
 (autoload 'cvs-status-get-tags "cvs-status")
 (defconst cvs-qtypedesc-tag
   (cvs-qtypedesc-create 'identity 'identity 'cvs-tags-list 'cvs-tag-history))
 
-;;;; 
+;;;;
 
 (defun cvs-mode! (&optional -cvs-mode!-fun -cvs-mode!-noerror)
   "Switch to the *cvs* buffer.
 	 (cvsbuf (cond ((cvs-buffer-p) (current-buffer))
 		       ((and cvs-buffer (cvs-buffer-p cvs-buffer)) cvs-buffer)
 		       (-cvs-mode!-noerror (current-buffer))
-		       (t (error "can't find the *cvs* buffer."))))
+		       (t (error "can't find the *cvs* buffer"))))
 	 (-cvs-mode!-wrapper cvs-minor-wrap-function)
 	 (-cvs-mode!-cont (lambda ()
 			    (save-current-buffer
 	    ;; the selected window has not been changed by FUN
 	    (select-window cvs-mode!-owin)))))))
 
-;;;; 
+;;;;
 ;;;; Prefixes
-;;;; 
+;;;;
 
 (defvar cvs-branches (list cvs-vendor-branch "HEAD" "HEAD"))
 (cvs-prefix-define cvs-branch-prefix
 		     (cvs-prefix-get 'cvs-secondary-branch-prefix))))
     (if branch (cons (concat (or arg "-r") branch) flags) flags)))
 
-;;;; 
+;;;;
 
 (easy-mmode-define-minor-mode
  cvs-minor-mode
 		(set (make-local-variable 'cvs-temp-buffer)
 		     (cvs-get-buffer-create
 		      (eval cvs-temp-buffer-name) 'noreuse))))))
-    
+
     ;; handle the potential pre-existing process
     (let ((proc (get-buffer-process buf)))
       (when (and (not normal) (processp proc)
 	 (cvsbuf (cvs-make-cvs-buffer dir new)))
     ;; Check that dir is under CVS control.
     (unless (file-directory-p dir)
-      (error "%s is not a directory." dir))
+      (error "%s is not a directory" dir))
     (unless (or noexist (file-directory-p (expand-file-name "CVS" dir)))
-      (error "%s does not contain CVS controlled files." dir))
+      (error "%s does not contain CVS controlled files" dir))
 
     (set-buffer cvsbuf)
     (cvs-mode-run cmd flags fis
 ;;		   'pop-to-buffer 'switch-to-buffer)
 ;;	       cvsbuf))))
 
-;;----------
 (defun cvs-run-process (args fis postprocess &optional single-dir)
   (assert (cvs-buffer-p cvs-buffer))
   (save-current-buffer
     (let ((procbuf (current-buffer))
 	  (cvsbuf cvs-buffer)
 	  (single-dir (or single-dir (eq cvs-execute-single-dir t))))
-      
+
       (set-buffer procbuf)
       (goto-char (point-max))
       (unless (bolp) (let ((inhibit-read-only t)) (insert "\n")))
 	  (set-process-filter process 'cvs-update-filter)
 	  (set-marker (process-mark process) (point-max))
 	  (ignore-errors (process-send-eof process)) ;close its stdin to avoid hangs
-	
+
 	  ;; now finish setting up the cvs-buffer
 	  (set-buffer cvsbuf)
 	  (setq cvs-mode-line-process (symbol-name (process-status process)))
 	  (tin-invalidate cvs-cookies tin0 tin-1)))));;)
 
 
-;;----------
 (defun cvs-sentinel (proc msg)
   "Sentinel for the cvs update process.
 This is responsible for parsing the output from the cvs update when
 	;; This might not even be necessary
 	(set-buffer obuf)))))
 
-;;----------
 (defun cvs-parse-process (dcd &optional subdir)
-  "FIXME: bad name, no doc"
+  "FIXME: bad name, no doc."
   (let* ((from-buf (current-buffer))
 	 (fileinfos (cvs-parse-buffer 'cvs-parse-table dcd subdir))
 	 (_ (set-buffer cvs-buffer))
 	      :noexist t))
 
 
-;;;; 
+;;;;
 ;;;; The code for running a "cvs update" and friends in various ways.
-;;;; 
+;;;;
 
 (defun-cvs-mode (cvs-mode-revert-buffer . SIMPLE)
                 (&optional ignore-auto noconfirm)
-  "Rerun cvs-examine on the current directory with the default flags."
+  "Rerun `cvs-examine' on the current directory with the default flags."
   (interactive)
   (cvs-examine default-directory t))
 
       default-directory
     (read-directory-name msg nil default-directory nil)))
 
+;;;###autoload
+(defun cvs-quickdir (dir &optional flags noshow)
+  "Open a *cvs* buffer on DIR without running cvs.
+With a prefix argument, prompt for a directory to use.
+A prefix arg >8 (ex: \\[universal-argument] \\[universal-argument]),
+  prevents reuse of an existing *cvs* buffer.
+Optional argument NOSHOW if non-nil means not to display the buffer.
+FLAGS is ignored."
+  (interactive (list (cvs-query-directory "CVS quickdir (directory): ")))
+  ;; FIXME: code duplication with cvs-cmd-do and cvs-parse-process
+  (let* ((dir (file-name-as-directory
+	       (abbreviate-file-name (expand-file-name dir))))
+	 (new (> (prefix-numeric-value current-prefix-arg) 8))
+	 (cvsbuf (cvs-make-cvs-buffer dir new))
+	 last)
+    ;; Check that dir is under CVS control.
+    (unless (file-directory-p dir)
+      (error "%s is not a directory" dir))
+    (unless (file-directory-p (expand-file-name "CVS" dir))
+      (error "%s does not contain CVS controlled files" dir))
+    (set-buffer cvsbuf)
+    (dolist (fi (cvs-fileinfo-from-entries ""))
+      (setq last (cvs-addto-collection cvs-cookies fi last)))
+    (cvs-cleanup-collection cvs-cookies
+			    (eq cvs-auto-remove-handled t)
+			    cvs-auto-remove-directories
+			    nil)
+    (if noshow cvsbuf
+      (let ((pop-up-windows nil)) (pop-to-buffer cvsbuf)))))
 
 ;;;###autoload
 (defun cvs-examine (directory flags &optional noshow)
 	      (> (prefix-numeric-value current-prefix-arg) 8)
 	      :noshow noshow :dont-change-disc t))
 
-;;----------
 (defun cvs-update-filter (proc string)
   "Filter function for pcl-cvs.
 This function gets the output that CVS sends to stdout.  It inserts
 	  ;;  (tin-delete cookies
 	  ;;	      (tin-nth cookies 1)))
 	  ;; Check if CVS is waiting for a lock.
-	  (beginning-of-line 0)		;Move to beginning of last complete line.
+	  (beginning-of-line 0)         ;Move to beginning of last complete line.
 	  (when (looking-at "^[ a-z]+: \\(.*waiting for .*lock in \\(.*\\)\\)$")
 	    (let ((msg (match-string 1))
 		  (lock (match-string 2)))
   (interactive "P")
   (cvs-prefix-set 'cvs-force-command arg))
 
-;;----------
 (put 'cvs-mode 'mode-class 'special)
 (define-derived-mode cvs-mode fundamental-mode "CVS"
   "Mode used for PCL-CVS, a frontend to CVS.
   (interactive "p")
   (tin-goto-next cvs-cookies (point) arg))
 
-;;;; 
+;;;;
 ;;;; Mark handling
-;;;; 
+;;;;
 
 (defun-cvs-mode cvs-mode-mark (&optional arg)
   "Mark the fileinfo on the current line.
 (defun cvs-mouse-toggle-mark (e)
   "Toggle the mark of the entry under the mouse."
   (interactive "e")
-  (mouse-set-point e)
-  (cvs-mode-mark 'toggle))
+  (save-excursion
+    (mouse-set-point e)
+    (cvs-mode-mark 'toggle)))
 
 (defun-cvs-mode cvs-mode-unmark ()
   "Unmark the fileinfo on the current line."
    (lambda (obj) (caar (member* obj cvs-ignore-marks-alternatives :key 'cdr)))
    (lambda () cvs-ignore-marks-alternatives)
    nil t))
-  
+
 (defun-cvs-mode cvs-mode-toggle-marks (arg)
   "Toggle whether the next CVS command uses marks.
 See `cvs-prefix-set' for further description of the behavior.
 \\[universal-argument] 3 selects `toggle-marks'."
   (interactive "P")
   (cvs-prefix-set 'cvs-ignore-marks-modif arg))
-      
+
 (defun cvs-ignore-marks-p (cmd &optional read-only)
   (let ((default (if (member cmd cvs-invert-ignore-marks)
 		     (not cvs-default-ignore-marks)
     (cvs-mode-do "commit" (list* "-m" msg flags) 'commit)))
 
 
-;;;; 
+;;;;
 ;;;; CVS Mode commands
-;;;; 
+;;;;
 
 (defun-cvs-mode (cvs-mode-insert . NOARGS) (file)
   "Insert an entry for a specific file."
 		(dolist (fi ',dirs) (setf (cvs-fileinfo->type fi) 'DEAD))))))
       (cvs-mode-run "add" flags fis :postproc postproc))))
 
-;;----------
 (defun-cvs-mode (cvs-mode-diff . DOUBLE) (flags)
   "Diff the selected files against the repository.
 This command compares the files in your working area against the
   (cvs-mode-do "diff" flags 'diff
 	       :show t)) ;; :ignore-exit t
 
-;;----------
 (defun-cvs-mode (cvs-mode-diff-head . SIMPLE) (flags)
   "Diff the selected files against the head of the current branch.
 See ``cvs-mode-diff'' for more info."
   (interactive (list (cvs-flags-query 'cvs-diff-flags "cvs diff flags")))
   (cvs-mode-diff-1 (cons "-rHEAD" flags)))
 
-;;----------
 (defun-cvs-mode (cvs-mode-diff-vendor . SIMPLE) (flags)
   "Diff the selected files against the head of the vendor branch.
 See ``cvs-mode-diff'' for more info."
   (interactive (list (cvs-flags-query 'cvs-diff-flags "cvs diff flags")))
   (cvs-mode-diff-1 (cons (concat "-r" cvs-vendor-branch) flags)))
 
-;;----------
 ;; sadly, this is not provided by cvs, so we have to roll our own
 (defun-cvs-mode (cvs-mode-diff-backup . SIMPLE) (flags)
   "Diff the files against the backup file.
 
 ;;
 ;; Ediff support
-;; 
+;;
 
 (defvar ediff-after-quit-destination-buffer)
 (defvar cvs-transient-buffers)
 	    (setq rev2-buf
 		  (if rev2 (cvs-retrieve-revision fi2 rev2)
 		    (find-file-noselect (cvs-fileinfo->full-path fi2)))))
-	(error "idiff-other doesn't know what other file/buffer to use."))
+	(error "idiff-other doesn't know what other file/buffer to use"))
       (let* (;; this binding is used by cvs-ediff-startup-hook
 	     (cvs-transient-buffers (list rev1-buf rev2-buf)))
 	(funcall (car cvs-idiff-imerge-handlers)
   (let* ((default-directory (cvs-expand-dir-name cvs-lock-file))
 	 (locks (directory-files default-directory nil cvs-lock-file-regexp)))
     (cond
-     ((not locks) (error "No lock files found."))
+     ((not locks) (error "No lock files found"))
      ((yes-or-no-p (concat "Really delete locks in " cvs-lock-file "? "))
       (dolist (lock locks)
 	(cond ((file-directory-p lock) (delete-directory lock))
 	 (cvs-flags-query 'cvs-tag-flags "tag flags")))
   (cvs-mode-do "tag" (append '("-d") flags (list tag))
 	       (when cvs-force-dir-tag 'tag)))
-  
+
 
 ;; Byte compile files.
 
 
 ;; ChangeLog support.
 
-;;----------
 (defun-cvs-mode cvs-mode-add-change-log-entry-other-window ()
   "Add a ChangeLog entry in the ChangeLog of the current directory."
   (interactive)
 ;;;###autoload
 (defcustom cvs-dired-use-hook '(4)
   "Whether or not opening a CVS directory should run PCL-CVS.
-NIL means never do it.
+nil means never do it.
 ALWAYS means to always do it unless a prefix argument is given to the
   command that prompted the opening of the directory.
 Anything else means to do it only if the prefix arg is equal to this value."
 			"cvs-mark-buffer-changed")))
 	      (cvs-addto-collection cvs-cookies fi))))))))
 
-
 (add-hook 'after-save-hook 'cvs-mark-buffer-changed)
 
 ;;

File pcl-cvs.texi

 @c -release-
 @sp 3
 @center Per Cederqvist
+@center Stefan Monnier
 @c -date-
 
 @c  The following two commands start the copyright page