X-Git-Url: http://cgit.sxemacs.org/?a=blobdiff_plain;f=lisp%2Fnnfolder.el;h=60ad4289bbb10a2614ea01771c4f2e8bdef8914c;hb=507b285173baa14c25dc095f5c65d05a5474a8fe;hp=0942128d35d19a68d0afea2f0611f2354e1c81e5;hpb=90f9d514fb2d7606084123584fdc0a661f3241ec;p=gnus

diff --git a/lisp/nnfolder.el b/lisp/nnfolder.el
index 0942128d3..60ad4289b 100644
--- a/lisp/nnfolder.el
+++ b/lisp/nnfolder.el
@@ -1,10 +1,10 @@
 ;;; nnfolder.el --- mail folder access for Gnus
-;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995,96,97 Free Software Foundation, Inc.
 
 ;; Author: Scott Byer <byer@mv.us.adobe.com>
 ;;	Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
 ;; 	Masanobu UMEDA <umerin@flab.flab.fujitsu.junet>
-;; Keywords: news, mail
+;; Keywords: mail
 
 ;; This file is part of GNU Emacs.
 
@@ -19,334 +19,318 @@
 ;; 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.
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
 
 ;;; Commentary:
 
-;; For an overview of what the interface functions do, please see the
-;; Gnus sources.  
-
-;; Various enhancements by byer@mv.us.adobe.com (Scott Byer).
-
 ;;; Code:
 
 (require 'nnheader)
-(require 'rmail)
+(require 'message)
 (require 'nnmail)
+(require 'nnoo)
+(require 'cl)
+(require 'gnus-util)
+
+(nnoo-declare nnfolder)
 
-(defvar nnfolder-directory (expand-file-name "~/Mail/")
-  "The name of the mail box file in the users home directory.")
+(defvoo nnfolder-directory (expand-file-name message-directory)
+  "The name of the nnfolder directory.")
 
-(defvar nnfolder-active-file 
-  (concat (file-name-as-directory nnfolder-directory) "active")
+(defvoo nnfolder-active-file
+  (nnheader-concat nnfolder-directory "active")
   "The name of the active file.")
 
-;; I renamed this variable to somehting more in keeping with the general GNU
+;; I renamed this variable to something more in keeping with the general GNU
 ;; style. -SLB
 
-(defvar nnfolder-ignore-active-file nil
-  "If non-nil, causes nnfolder to do some extra work in order to determine the true active ranges of an mbox file.  
-Note that the active file is still saved, but it's values are not
-used.  This costs some extra time when scanning an mbox when opening
-it.")
-
-;; Note that this variable may not be completely implemented yet. -SLB
-
-(defvar nnfolder-always-close nil
-  "If non-nil, nnfolder attempts to only ever have one mbox open at a time.  
-This is a straight space/performance trade off, as the mboxes will have to 
-be scanned every time they are read in.  If nil (default), nnfolder will
-attempt to keep the buffers around (saving the nnfolder's buffer upon group 
-close, but not killing it), speeding some things up tremendously, especially
-such things as moving mail.  All buffers always get killed upon server close.")
-
-(defvar nnfolder-newsgroups-file 
-  (concat (file-name-as-directory  nnfolder-directory) "newsgroups")
+(defvoo nnfolder-ignore-active-file nil
+  "If non-nil, causes nnfolder to do some extra work in order to determine
+the true active ranges of an mbox file.  Note that the active file is still
+saved, but it's values are not used.  This costs some extra time when
+scanning an mbox when opening it.")
+
+(defvoo nnfolder-distrust-mbox nil
+  "If non-nil, causes nnfolder to not trust the user with respect to
+inserting unaccounted for mail in the middle of an mbox file.  This can greatly
+slow down scans, which now must scan the entire file for unmarked messages.
+When nil, scans occur forward from the last marked message, a huge
+time saver for large mailboxes.")
+
+(defvoo nnfolder-newsgroups-file
+  (concat (file-name-as-directory nnfolder-directory) "newsgroups")
   "Mail newsgroups description file.")
 
-(defvar nnfolder-get-new-mail t
-  "If non-nil, nnml will check the incoming mail file and split the mail.")
+(defvoo nnfolder-get-new-mail t
+  "If non-nil, nnfolder will check the incoming mail file and split the mail.")
 
-(defvar nnfolder-prepare-save-mail-hook nil
+(defvoo nnfolder-prepare-save-mail-hook nil
   "Hook run narrowed to an article before saving.")
 
+(defvoo nnfolder-save-buffer-hook nil
+  "Hook run before saving the nnfolder mbox buffer.")
+
+(defvoo nnfolder-inhibit-expiry nil
+  "If non-nil, inhibit expiry.")
+
 
 
-(defconst nnfolder-version "nnfolder 0.2"
+(defconst nnfolder-version "nnfolder 1.0"
   "nnfolder version.")
 
 (defconst nnfolder-article-marker "X-Gnus-Article-Number: "
   "String used to demarcate what the article number for a message is.")
 
-(defvar nnfolder-current-group nil)
-(defvar nnfolder-current-buffer nil)
-(defvar nnfolder-status-string "")
-(defvar nnfolder-group-alist nil)
-(defvar nnfolder-buffer-alist nil)
-
-(defmacro nnfolder-article-string (article)
-  (` (concat "\n" nnfolder-article-marker (int-to-string (, article)) " ")))
-
-
-
-(defvar nnfolder-current-server nil)
-(defvar nnfolder-server-alist nil)
-(defvar nnfolder-server-variables 
-  (list 
-   (list 'nnfolder-directory nnfolder-directory)
-   (list 'nnfolder-active-file nnfolder-active-file)
-   (list 'nnfolder-newsgroups-file nnfolder-newsgroups-file)
-   (list 'nnfolder-get-new-mail nnfolder-get-new-mail)
-   '(nnfolder-current-group nil)
-   '(nnfolder-current-buffer nil)
-   '(nnfolder-status-string "")
-   '(nnfolder-group-alist nil)
-   '(nnfolder-buffer-alist nil)))
+(defvoo nnfolder-current-group nil)
+(defvoo nnfolder-current-buffer nil)
+(defvoo nnfolder-status-string "")
+(defvoo nnfolder-group-alist nil)
+(defvoo nnfolder-buffer-alist nil)
+(defvoo nnfolder-scantime-alist nil)
+(defvoo nnfolder-active-timestamp nil)
 
 
 
 ;;; Interface functions
 
-(defun nnfolder-retrieve-headers (sequence &optional newsgroup server)
+(nnoo-define-basics nnfolder)
+
+(deffoo nnfolder-retrieve-headers (articles &optional group server fetch-old)
   (save-excursion
     (set-buffer nntp-server-buffer)
     (erase-buffer)
-    (let ((delim-string (concat "^" rmail-unix-mail-delimiter))
-	  article art-string start stop)
-      (nnfolder-possibly-change-group newsgroup)
-      (set-buffer nnfolder-current-buffer)
-      (goto-char (point-min))
-      (if (stringp (car sequence))
-	  'headers
-	(while sequence
-	  (setq article (car sequence))
-	  (setq art-string (nnfolder-article-string article))
-	  (set-buffer nnfolder-current-buffer)
-	  (if (or (search-forward art-string nil t)
-		  ;; Don't search the whole file twice!  Also, articles
-		  ;; probably have some locality by number, so searching
-		  ;; backwards will be faster.  Especially if we're at the
-		  ;; beginning of the buffer :-). -SLB
-		  (search-backward art-string nil t))
-	      (progn
-		(setq start (or (re-search-backward delim-string nil t)
-				(point)))
-		(search-forward "\n\n" nil t)
-		(setq stop (1- (point)))
-		(set-buffer nntp-server-buffer)
-		(insert (format "221 %d Article retrieved.\n" article))
-		(insert-buffer-substring nnfolder-current-buffer start stop)
-		(goto-char (point-max))
-		(insert ".\n")))
-	  (setq sequence (cdr sequence)))
-
-	;; Fold continuation lines.
-	(set-buffer nntp-server-buffer)
+    (let (article art-string start stop)
+      (nnfolder-possibly-change-group group server)
+      (when nnfolder-current-buffer
+	(set-buffer nnfolder-current-buffer)
 	(goto-char (point-min))
-	(while (re-search-forward "\\(\r?\n[ \t]+\\)+" nil t)
-	  (replace-match " " t t))
-	'headers))))
-
-(defun nnfolder-open-server (server &optional defs)
-  (nnheader-init-server-buffer)
-  (if (equal server nnfolder-current-server)
-      t
-    (if nnfolder-current-server
-	(setq nnfolder-server-alist 
-	      (cons (list nnfolder-current-server
-			  (nnheader-save-variables nnfolder-server-variables))
-		    nnfolder-server-alist)))
-    (let ((state (assoc server nnfolder-server-alist)))
-      (if state 
-	  (progn
-	    (nnheader-restore-variables (nth 1 state))
-	    (setq nnfolder-server-alist (delq state nnfolder-server-alist)))
-	(nnheader-set-init-variables nnfolder-server-variables defs)))
-    (setq nnfolder-current-server server)))
-
-(defun nnfolder-close-server (&optional server)
-  t)
-
-(defun nnfolder-server-opened (&optional server)
-  (and (equal server nnfolder-current-server)
-       nntp-server-buffer
-       (buffer-name nntp-server-buffer)))
-
-(defun nnfolder-request-close ()
+	(if (stringp (car articles))
+	    'headers
+	  (while articles
+	    (setq article (car articles))
+	    (setq art-string (nnfolder-article-string article))
+	    (set-buffer nnfolder-current-buffer)
+	    (when (or (search-forward art-string nil t)
+		      ;; Don't search the whole file twice!  Also, articles
+		      ;; probably have some locality by number, so searching
+		      ;; backwards will be faster.  Especially if we're at the
+		      ;; beginning of the buffer :-). -SLB
+		      (search-backward art-string nil t))
+	      (nnmail-search-unix-mail-delim-backward)
+	      (setq start (point))
+	      (search-forward "\n\n" nil t)
+	      (setq stop (1- (point)))
+	      (set-buffer nntp-server-buffer)
+	      (insert (format "221 %d Article retrieved.\n" article))
+	      (insert-buffer-substring nnfolder-current-buffer start stop)
+	      (goto-char (point-max))
+	      (insert ".\n"))
+	    (setq articles (cdr articles)))
+
+	  (set-buffer nntp-server-buffer)
+	  (nnheader-fold-continuation-lines)
+	  'headers)))))
+
+(deffoo nnfolder-open-server (server &optional defs)
+  (nnoo-change-server 'nnfolder server defs)
+  (nnmail-activate 'nnfolder t)
+  (gnus-make-directory nnfolder-directory)
+  (cond
+   ((not (file-exists-p nnfolder-directory))
+    (nnfolder-close-server)
+    (nnheader-report 'nnfolder "Couldn't create directory: %s"
+		     nnfolder-directory))
+   ((not (file-directory-p (file-truename nnfolder-directory)))
+    (nnfolder-close-server)
+    (nnheader-report 'nnfolder "Not a directory: %s" nnfolder-directory))
+   (t
+    (nnmail-activate 'nnfolder)
+    (nnheader-report 'nnfolder "Opened server %s using directory %s"
+		     server nnfolder-directory)
+    t)))
+
+(deffoo nnfolder-request-close ()
   (let ((alist nnfolder-buffer-alist))
     (while alist
-      (nnfolder-close-group (car (car alist)) nil t)
+      (nnfolder-close-group (caar alist) nil t)
       (setq alist (cdr alist))))
+  (nnoo-close-server 'nnfolder)
   (setq nnfolder-buffer-alist nil
 	nnfolder-group-alist nil))
 
-(defun nnfolder-status-message (&optional server)
-  nnfolder-status-string)
-
-(defun nnfolder-request-article (article &optional newsgroup server buffer)
-  (nnfolder-possibly-change-group newsgroup)
-  (if (stringp article)
-      nil
-    (save-excursion
-      (set-buffer nnfolder-current-buffer)
-      (goto-char (point-min))
-      (if (search-forward (nnfolder-article-string article) nil t)
-	  (let (start stop)
-	    (re-search-backward (concat "^" rmail-unix-mail-delimiter) nil t)
-	    (setq start (point))
-	    (forward-line 1)
-	    (or (and (re-search-forward 
-		      (concat "^" rmail-unix-mail-delimiter) nil t)
+(deffoo nnfolder-request-article (article &optional group server buffer)
+  (nnfolder-possibly-change-group group server)
+  (save-excursion
+    (set-buffer nnfolder-current-buffer)
+    (goto-char (point-min))
+    (when (search-forward (nnfolder-article-string article) nil t)
+      (let (start stop)
+	(nnmail-search-unix-mail-delim-backward)
+	(setq start (point))
+	(forward-line 1)
+	(unless (and (nnmail-search-unix-mail-delim)
 		     (forward-line -1))
-		(goto-char (point-max)))
-	    (setq stop (point))
-	    (let ((nntp-server-buffer (or buffer nntp-server-buffer)))
-	      (set-buffer nntp-server-buffer)
-	      (erase-buffer)
-	      (insert-buffer-substring nnfolder-current-buffer start stop)
-	      (goto-char (point-min))
-	      (while (looking-at "From ")
-		(delete-char 5)
-		(insert "X-From-Line: ")
-		(forward-line 1))
-	      t))))))
-
-(defun nnfolder-request-group (group &optional server dont-check)
+	  (goto-char (point-max)))
+	(setq stop (point))
+	(let ((nntp-server-buffer (or buffer nntp-server-buffer)))
+	  (set-buffer nntp-server-buffer)
+	  (erase-buffer)
+	  (insert-buffer-substring nnfolder-current-buffer start stop)
+	  (goto-char (point-min))
+	  (while (looking-at "From ")
+	    (delete-char 5)
+	    (insert "X-From-Line: ")
+	    (forward-line 1))
+	  (if (numberp article)
+	      (cons nnfolder-current-group article)
+	    (goto-char (point-min))
+	    (search-forward (concat "\n" nnfolder-article-marker))
+	    (cons nnfolder-current-group
+		  (string-to-int
+		   (buffer-substring
+		    (point) (progn (end-of-line) (point)))))))))))
+
+(deffoo nnfolder-request-group (group &optional server dont-check)
+  (nnfolder-possibly-change-group group server t)
   (save-excursion
-    (nnfolder-possibly-change-group group)
-    (and (assoc group nnfolder-group-alist)
-	 (progn
-	   (if dont-check
-	       t
-	     (nnfolder-get-new-mail group))
-	   (let* ((active (assoc group nnfolder-group-alist))
-		  (group (car active))
-		  (range (car (cdr active)))
-		  (minactive (car range))
-		  (maxactive (cdr range)))
-	     ;; I've been getting stray 211 lines in my nnfolder active
-	     ;; file.  So, let's make sure that doesn't happen. -SLB
-	     (set-buffer nntp-server-buffer)
-	     (erase-buffer)
-	     (insert (format "211 %d %d %d %s\n" 
-			     (1+ (- maxactive minactive))
-			     minactive maxactive group))
-	     t)))))
+    (if (not (assoc group nnfolder-group-alist))
+	(nnheader-report 'nnfolder "No such group: %s" group)
+      (if dont-check
+	  (progn
+	    (nnheader-report 'nnfolder "Selected group %s" group)
+	    t)
+	(let* ((active (assoc group nnfolder-group-alist))
+	       (group (car active))
+	       (range (cadr active)))
+	  (cond
+	   ((null active)
+	    (nnheader-report 'nnfolder "No such group: %s" group))
+	   ((null nnfolder-current-group)
+	    (nnheader-report 'nnfolder "Empty group: %s" group))
+	   (t
+	    (nnheader-report 'nnfolder "Selected group %s" group)
+	    (nnheader-insert "211 %d %d %d %s\n"
+			     (1+ (- (cdr range) (car range)))
+			     (car range) (cdr range) group))))))))
+
+(deffoo nnfolder-request-scan (&optional group server)
+  (nnfolder-possibly-change-group nil server)
+  (when nnfolder-get-new-mail
+    (nnfolder-possibly-change-group group server)
+    (nnmail-get-new-mail
+     'nnfolder
+     (lambda ()
+       (let ((bufs nnfolder-buffer-alist))
+	 (save-excursion
+	   (while bufs
+	     (if (not (buffer-live-p (nth 1 (car bufs))))
+		 (setq nnfolder-buffer-alist
+		       (delq (car bufs) nnfolder-buffer-alist))
+	       (set-buffer (nth 1 (car bufs)))
+	       (nnfolder-save-buffer)
+	       (kill-buffer (current-buffer)))
+	     (setq bufs (cdr bufs))))))
+     nnfolder-directory
+     group)))
 
 ;; Don't close the buffer if we're not shutting down the server.  This way,
 ;; we can keep the buffer in the group buffer cache, and not have to grovel
 ;; over the buffer again unless we add new mail to it or modify it in some
 ;; way.
 
-(defun nnfolder-close-group (group &optional server force)
+(deffoo nnfolder-close-group (group &optional server force)
   ;; Make sure we _had_ the group open.
-  (if (or (assoc group nnfolder-buffer-alist)
-	  (equal group nnfolder-current-group))
-      (progn
-	(nnfolder-possibly-change-group group)
-	(save-excursion
-	  (set-buffer nnfolder-current-buffer)
-	  ;; If the buffer was modified, write the file out now.
-	  (and (buffer-modified-p) (save-buffer))
-	  (if (or force
-		  nnfolder-always-close)
-	      ;; If we're shutting the server down, we need to kill the
-	      ;; buffer and remove it from the open buffer list.  Or, of
-	      ;; course, if we're trying to minimize our space impact.
-	      (progn
-		(kill-buffer (current-buffer))
-		(setq nnfolder-buffer-alist (delq (assoc group 
-							 nnfolder-buffer-alist)
-						  nnfolder-buffer-alist)))))))
+  (when (or (assoc group nnfolder-buffer-alist)
+	    (equal group nnfolder-current-group))
+    (let ((inf (assoc group nnfolder-buffer-alist)))
+      (when inf
+	(when (and nnfolder-current-group
+		   nnfolder-current-buffer)
+	  (push (list nnfolder-current-group nnfolder-current-buffer)
+		nnfolder-buffer-alist))
+	(setq nnfolder-buffer-alist
+	      (delq inf nnfolder-buffer-alist))
+	(setq nnfolder-current-buffer (cadr inf)
+	      nnfolder-current-group (car inf))))
+    (when (and nnfolder-current-buffer
+	       (buffer-name nnfolder-current-buffer))
+      (save-excursion
+	(set-buffer nnfolder-current-buffer)
+	;; If the buffer was modified, write the file out now.
+	(nnfolder-save-buffer)
+	;; If we're shutting the server down, we need to kill the
+	;; buffer and remove it from the open buffer list.  Or, of
+	;; course, if we're trying to minimize our space impact.
+	(kill-buffer (current-buffer))
+	(setq nnfolder-buffer-alist (delq (assoc group nnfolder-buffer-alist)
+					  nnfolder-buffer-alist)))))
   (setq nnfolder-current-group nil
 	nnfolder-current-buffer nil)
   t)
 
-(defun nnfolder-request-create-group (group &optional server) 
-  (nnfolder-request-list)
-  (setq nnfolder-group-alist (nnmail-get-active))
-  (or (assoc group nnfolder-group-alist)
-      (progn
-	(setq nnfolder-group-alist 
-	      (cons (list group (cons 0 0)) nnfolder-group-alist))
-	(nnmail-save-active nnfolder-group-alist nnfolder-active-file)))
+(deffoo nnfolder-request-create-group (group &optional server args)
+  (nnfolder-possibly-change-group nil server)
+  (nnmail-activate 'nnfolder)
+  (when group
+    (unless (assoc group nnfolder-group-alist)
+      (push (list group (cons 1 0)) nnfolder-group-alist)
+      (nnmail-save-active nnfolder-group-alist nnfolder-active-file)))
   t)
 
-(defun nnfolder-request-list (&optional server)
-  (if server (nnfolder-get-new-mail))
+(deffoo nnfolder-request-list (&optional server)
+  (nnfolder-possibly-change-group nil server)
   (save-excursion
-    (or nnfolder-group-alist
-	(nnmail-find-file nnfolder-active-file)
-	(progn
-	  (setq nnfolder-group-alist (nnmail-get-active))
-	  (nnmail-save-active nnfolder-group-alist nnfolder-active-file)
-	  (nnmail-find-file nnfolder-active-file)))))
+    (nnmail-find-file nnfolder-active-file)
+    (setq nnfolder-group-alist (nnmail-get-active))
+    t))
 
-(defun nnfolder-request-newgroups (date &optional server)
+(deffoo nnfolder-request-newgroups (date &optional server)
+  (nnfolder-possibly-change-group nil server)
   (nnfolder-request-list server))
 
-(defun nnfolder-request-list-newsgroups (&optional server)
+(deffoo nnfolder-request-list-newsgroups (&optional server)
+  (nnfolder-possibly-change-group nil server)
   (save-excursion
     (nnmail-find-file nnfolder-newsgroups-file)))
 
-(defun nnfolder-request-post (&optional server)
-  (mail-send-and-exit nil))
-
-(defalias 'nnfolder-request-post-buffer 'nnmail-request-post-buffer)
-
-(defun nnfolder-request-expire-articles 
+(deffoo nnfolder-request-expire-articles
   (articles newsgroup &optional server force)
-  (nnfolder-possibly-change-group newsgroup)
-  (let* ((days (or (and nnmail-expiry-wait-function
-			(funcall nnmail-expiry-wait-function newsgroup))
-		   nnmail-expiry-wait))
-	 (is-old t)
+  (nnfolder-possibly-change-group newsgroup server)
+  (let* ((is-old t)
 	 rest)
-    (nnfolder-request-list)
-    (setq nnfolder-group-alist (nnmail-get-active))
+    (nnmail-activate 'nnfolder)
 
-    (save-excursion 
+    (save-excursion
       (set-buffer nnfolder-current-buffer)
-      (while articles
+      (while (and articles is-old)
 	(goto-char (point-min))
-	(if (search-forward (nnfolder-article-string (car articles)) nil t)
-	    (if (or force
-		    (setq is-old
-			  (> (nnmail-days-between 
-			      (current-time-string)
-			      (buffer-substring 
-			       (point) (progn (end-of-line) (point))))
-			     days)))
-		(progn
-		  (and gnus-verbose-backends
-		       (message "Deleting: %s" (car articles)))
-		  (nnfolder-delete-mail))
-	      (setq rest (cons (car articles) rest))))
+	(when (search-forward (nnfolder-article-string (car articles)) nil t)
+	  (if (setq is-old
+		    (nnmail-expired-article-p
+		     newsgroup
+		     (buffer-substring
+		      (point) (progn (end-of-line) (point)))
+		     force nnfolder-inhibit-expiry))
+	      (progn
+		(nnheader-message 5 "Deleting article %d..."
+				  (car articles) newsgroup)
+		(nnfolder-delete-mail))
+	    (push (car articles) rest)))
 	(setq articles (cdr articles)))
-      (and (buffer-modified-p) (save-buffer))
-      ;; Find the lowest active article in this group.
-      (let* ((active (car (cdr (assoc newsgroup nnfolder-group-alist))))
-	     (marker (concat "\n" nnfolder-article-marker))
-	     (number "[0-9]+")
-	     (activemin (cdr active)))
-	(goto-char (point-min))
-	(while (and (search-forward marker nil t)
-		    (re-search-forward number nil t))
-	  (setq activemin (min activemin
-			       (string-to-number (buffer-substring
-						  (match-beginning 0)
-						  (match-end 0))))))
-	(setcar active activemin))
+      (unless nnfolder-inhibit-expiry
+	(nnheader-message 5 "Deleting articles...done"))
+      (nnfolder-save-buffer)
+      (nnfolder-adjust-min-active newsgroup)
       (nnmail-save-active nnfolder-group-alist nnfolder-active-file)
       (nconc rest articles))))
 
-(defun nnfolder-request-move-article
+(deffoo nnfolder-request-move-article
   (article group server accept-form &optional last)
-  (nnfolder-possibly-change-group group)
   (let ((buf (get-buffer-create " *nnfolder move*"))
 	result)
-    (and 
+    (and
      (nnfolder-request-article article group server)
      (save-excursion
        (set-buffer buf)
@@ -354,8 +338,8 @@ such things as moving mail.  All buffers always get killed upon server close.")
        (erase-buffer)
        (insert-buffer-substring nntp-server-buffer)
        (goto-char (point-min))
-       (while (re-search-forward 
-	       "^X-Gnus-Newsgroup:" 
+       (while (re-search-forward
+	       (concat "^" nnfolder-article-marker)
 	       (save-excursion (search-forward "\n\n" nil t) (point)) t)
 	 (delete-region (progn (beginning-of-line) (point))
 			(progn (forward-line 1) (point))))
@@ -363,41 +347,50 @@ such things as moving mail.  All buffers always get killed upon server close.")
        (kill-buffer buf)
        result)
      (save-excursion
-       (nnfolder-possibly-change-group group)
+       (nnfolder-possibly-change-group group server)
        (set-buffer nnfolder-current-buffer)
        (goto-char (point-min))
-       (if (search-forward (nnfolder-article-string article) nil t)
-	   (nnfolder-delete-mail))
-       (and last 
-	    (buffer-modified-p)
-	    (save-buffer))))
+       (when (search-forward (nnfolder-article-string article) nil t)
+	 (nnfolder-delete-mail))
+       (when last
+	 (nnfolder-save-buffer)
+	 (nnfolder-adjust-min-active group)
+	 (nnmail-save-active nnfolder-group-alist nnfolder-active-file))))
     result))
 
-(defun nnfolder-request-accept-article (group &optional last)
-  (nnfolder-possibly-change-group group)
+(deffoo nnfolder-request-accept-article (group &optional server last)
+  (nnfolder-possibly-change-group group server)
+  (nnmail-check-syntax)
   (let ((buf (current-buffer))
-	result)
+	result art-group)
     (goto-char (point-min))
-    (if (looking-at "X-From-Line: ")
-	(replace-match "From ")
-      (insert "From nobody " (current-time-string) "\n"))
-    (and 
+    (when (looking-at "X-From-Line: ")
+      (replace-match "From "))
+    (and
      (nnfolder-request-list)
      (save-excursion
        (set-buffer buf)
        (goto-char (point-min))
        (search-forward "\n\n" nil t)
        (forward-line -1)
-       (while (re-search-backward "^X-Gnus-Newsgroup: " nil t)
+       (while (re-search-backward (concat "^" nnfolder-article-marker) nil t)
 	 (delete-region (point) (progn (forward-line 1) (point))))
-       (setq result (car (nnfolder-save-mail (and (stringp group) group)))))
-     (save-excursion
-       (set-buffer nnfolder-current-buffer)
-       (and last (buffer-modified-p) (save-buffer))))
+       (setq result
+	     (car (nnfolder-save-mail
+		   (if (stringp group)
+		       (list (cons group (nnfolder-active-number group)))
+		     (setq art-group
+			   (nnmail-article-group 'nnfolder-active-number)))))))
+     (when last
+       (save-excursion
+	 (nnfolder-possibly-change-folder (or (caar art-group) group))
+	 (nnfolder-save-buffer))))
     (nnmail-save-active nnfolder-group-alist nnfolder-active-file)
+    (unless result
+      (nnheader-report 'nnfolder "Couldn't store article"))
     result))
 
-(defun nnfolder-request-replace-article (article group buffer)
+(deffoo nnfolder-request-replace-article (article group buffer)
   (nnfolder-possibly-change-group group)
   (save-excursion
     (set-buffer nnfolder-current-buffer)
@@ -406,120 +399,185 @@ such things as moving mail.  All buffers always get killed upon server close.")
 	nil
       (nnfolder-delete-mail t t)
       (insert-buffer-substring buffer)
-      (and (buffer-modified-p) (save-buffer))
+      (nnfolder-save-buffer)
       t)))
 
+(deffoo nnfolder-request-delete-group (group &optional force server)
+  (nnfolder-close-group group server t)
+  ;; Delete all articles in GROUP.
+  (if (not force)
+      ()				; Don't delete the articles.
+    ;; Delete the file that holds the group.
+    (ignore-errors
+      (delete-file (nnfolder-group-pathname group))))
+  ;; Remove the group from all structures.
+  (setq nnfolder-group-alist
+	(delq (assoc group nnfolder-group-alist) nnfolder-group-alist)
+	nnfolder-current-group nil
+	nnfolder-current-buffer nil)
+  ;; Save the active file.
+  (nnmail-save-active nnfolder-group-alist nnfolder-active-file)
+  t)
+
+(deffoo nnfolder-request-rename-group (group new-name &optional server)
+  (nnfolder-possibly-change-group group server)
+  (save-excursion
+    (set-buffer nnfolder-current-buffer)
+    (and (file-writable-p buffer-file-name)
+	 (ignore-errors
+	   (rename-file
+	    buffer-file-name
+	    (nnfolder-group-pathname new-name))
+	   t)
+	 ;; That went ok, so we change the internal structures.
+	 (let ((entry (assoc group nnfolder-group-alist)))
+	   (and entry (setcar entry new-name))
+	   (setq nnfolder-current-buffer nil
+		 nnfolder-current-group nil)
+	   ;; Save the new group alist.
+	   (nnmail-save-active nnfolder-group-alist nnfolder-active-file)
+	   ;; We kill the buffer instead of renaming it and stuff.
+	   (kill-buffer (current-buffer))
+	   t))))
+
 
 ;;; Internal functions.
 
+(defun nnfolder-adjust-min-active (group)
+  ;; Find the lowest active article in this group.
+  (let* ((active (cadr (assoc group nnfolder-group-alist)))
+	 (marker (concat "\n" nnfolder-article-marker))
+	 (number "[0-9]+")
+	 (activemin (cdr active)))
+    (save-excursion
+      (set-buffer nnfolder-current-buffer)
+      (goto-char (point-min))
+      (while (and (search-forward marker nil t)
+		  (re-search-forward number nil t))
+	(setq activemin (min activemin
+			     (string-to-number (buffer-substring
+						(match-beginning 0)
+						(match-end 0))))))
+      (setcar active activemin))))
+
+(defun nnfolder-article-string (article)
+  (if (numberp article)
+      (concat "\n" nnfolder-article-marker (int-to-string article) " ")
+    (concat "\nMessage-ID: " article)))
+
 (defun nnfolder-delete-mail (&optional force leave-delim)
-  ;; Beginning of the article.
+  "Delete the message that point is in."
   (save-excursion
-    (save-restriction
-      (narrow-to-region
-       (save-excursion
-	 (re-search-backward (concat "^" rmail-unix-mail-delimiter) nil t)
-	 (if leave-delim (progn (forward-line 1) (point))
-	   (match-beginning 0)))
-       (progn
-	 (forward-line 1)
-	 (or (and (re-search-forward (concat "^" rmail-unix-mail-delimiter) 
-				     nil t)
-		  (if (and (not (bobp)) leave-delim)
-		      (progn (forward-line -2) (point))
-		    (match-beginning 0)))
-	     (point-max))))
-      (delete-region (point-min) (point-max)))))
-
-(defun nnfolder-possibly-change-group (group)
-  (or (file-exists-p nnfolder-directory)
-      (make-directory (directory-file-name nnfolder-directory)))
-  (nnfolder-possibly-activate-groups nil)
-  (or (assoc group nnfolder-group-alist)
-      (not (file-exists-p (concat (file-name-as-directory nnfolder-directory)
-				  group)))
-      (progn
-	(setq nnfolder-group-alist 
-	      (cons (list group (cons 1 0)) nnfolder-group-alist))
-	(nnmail-save-active nnfolder-group-alist nnfolder-active-file)))
-  (let (inf file)
-    (if (and (equal group nnfolder-current-group)
-	     nnfolder-current-buffer
-	     (buffer-name nnfolder-current-buffer))
-	()
-      (setq nnfolder-current-group group)
-
-      ;; If we have to change groups, see if we don't already have the mbox
-      ;; in memory.  If we do, verify the modtime and destroy the mbox if
-      ;; needed so we can rescan it.
-      (if (setq inf (assoc group nnfolder-buffer-alist))
+    (delete-region
+     (save-excursion
+       (nnmail-search-unix-mail-delim-backward)
+       (if leave-delim (progn (forward-line 1) (point))
+	 (point)))
+     (progn
+       (forward-line 1)
+       (if (nnmail-search-unix-mail-delim)
+	   (if (and (not (bobp)) leave-delim)
+	       (progn (forward-line -2) (point))
+	     (point))
+	 (point-max))))))
+
+(defun nnfolder-possibly-change-group (group &optional server dont-check)
+  ;; Change servers.
+  (when (and server
+	     (not (nnfolder-server-opened server)))
+    (nnfolder-open-server server))
+  (unless (gnus-buffer-live-p nnfolder-current-buffer)
+    (setq nnfolder-current-buffer nil
+	  nnfolder-current-group nil))
+  ;; Change group.
+  (when (and group
+	     (not (equal group nnfolder-current-group)))
+    (nnmail-activate 'nnfolder)
+    (when (and (not (assoc group nnfolder-group-alist))
+	       (not (file-exists-p
+		     (nnfolder-group-pathname group))))
+      ;; The group doesn't exist, so we create a new entry for it.
+      (push (list group (cons 1 0)) nnfolder-group-alist)
+      (nnmail-save-active nnfolder-group-alist nnfolder-active-file))
+
+    (if dont-check
+	(setq nnfolder-current-group group)
+      (let (inf file)
+	;; If we have to change groups, see if we don't already have the
+	;; folder in memory.  If we do, verify the modtime and destroy
+	;; the folder if needed so we can rescan it.
+	(when (setq inf (assoc group nnfolder-buffer-alist))
 	  (setq nnfolder-current-buffer (nth 1 inf)))
 
-      ;; If the buffer is not live, make sure it isn't in the alist.  If it
-      ;; is live, verify that nobody else has touched the file since last
-      ;; time.
-      (if (or (not (and nnfolder-current-buffer
-			(buffer-name nnfolder-current-buffer)))
-	      (not (and (bufferp nnfolder-current-buffer)
-			(verify-visited-file-modtime 
-			 nnfolder-current-buffer))))
-	  (progn
-	    (if (and nnfolder-current-buffer
-		     (buffer-name nnfolder-current-buffer)
-		     (bufferp nnfolder-current-buffer))
-		(kill-buffer nnfolder-current-buffer))
-	    (setq nnfolder-buffer-alist (delq inf nnfolder-buffer-alist))
-	    (setq inf nil)))
-      
-      (if inf
-	  ()
-	(save-excursion
-	  (setq file (concat (file-name-as-directory nnfolder-directory)
-			     group))
-	  (if (file-directory-p (file-truename file))
-	      ()
-	    (if (not (file-exists-p file))
-		(write-region 1 1 file t 'nomesg))
-	    (setq nnfolder-current-buffer 
-		  (set-buffer (nnfolder-read-folder file)))
-	    (setq nnfolder-buffer-alist (cons (list group (current-buffer))
-					      nnfolder-buffer-alist)))))))
-  (setq nnfolder-current-group group))
-
-(defun nnfolder-save-mail (&optional group)
+	;; If the buffer is not live, make sure it isn't in the alist.  If it
+	;; is live, verify that nobody else has touched the file since last
+	;; time.
+	(when (and nnfolder-current-buffer
+		   (not (gnus-buffer-live-p nnfolder-current-buffer)))
+	  (setq nnfolder-buffer-alist (delq inf nnfolder-buffer-alist)
+		nnfolder-current-buffer nil))
+
+	(setq nnfolder-current-group group)
+
+	(when (or (not nnfolder-current-buffer)
+		  (not (verify-visited-file-modtime nnfolder-current-buffer)))
+	  (save-excursion
+	    (setq file (nnfolder-group-pathname group))
+	    ;; See whether we need to create the new file.
+	    (unless (file-exists-p file)
+	      (gnus-make-directory (file-name-directory file))
+	      (nnmail-write-region 1 1 file t 'nomesg))
+	    (when (setq nnfolder-current-buffer (nnfolder-read-folder group))
+	      (set-buffer nnfolder-current-buffer)
+	      (push (list group nnfolder-current-buffer)
+		    nnfolder-buffer-alist))))))))
+
+(defun nnfolder-save-mail (group-art-list)
   "Called narrowed to an article."
-  (let* ((nnmail-split-methods 
-	  (if group (list (list group "")) nnmail-split-methods))
-	 (group-art-list
-	  (nreverse (nnmail-article-group 'nnfolder-active-number)))
-	 save-list group-art)
+  (let* (save-list group-art)
+    (goto-char (point-min))
+    ;; The From line may have been quoted by movemail.
+    (when (looking-at (concat ">" message-unix-mail-delimiter))
+      (delete-char 1))
+    ;; This might come from somewhere else.
+    (unless (looking-at message-unix-mail-delimiter)
+      (insert "From nobody " (current-time-string) "\n")
+      (goto-char (point-min)))
+    ;; Quote all "From " lines in the article.
+    (forward-line 1)
+    (let (case-fold-search)
+      (while (re-search-forward "^From " nil t)
+	(beginning-of-line)
+	(insert "> ")))
     (setq save-list group-art-list)
     (nnmail-insert-lines)
     (nnmail-insert-xref group-art-list)
+    (run-hooks 'nnmail-prepare-save-mail-hook)
     (run-hooks 'nnfolder-prepare-save-mail-hook)
 
     ;; Insert the mail into each of the destination groups.
-    (while group-art-list
-      (setq group-art (car group-art-list)
-	    group-art-list (cdr group-art-list))
-
-      ;; Kill the previous newsgroup markers.
+    (while (setq group-art (pop group-art-list))
+      ;; Kill any previous newsgroup markers.
       (goto-char (point-min))
       (search-forward "\n\n" nil t)
       (forward-line -1)
       (while (search-backward (concat "\n" nnfolder-article-marker) nil t)
-	(delete-region (point) (progn (forward-line 1) (point))))
+	(delete-region (1+ (point)) (progn (forward-line 2) (point))))
 
       ;; Insert the new newsgroup marker.
-      (nnfolder-possibly-change-group (car group-art))
       (nnfolder-insert-newsgroup-line group-art)
-      (let ((beg (point-min))
-	    (end (point-max))
-	    (obuf (current-buffer)))
-	(set-buffer nnfolder-current-buffer)
-	(goto-char (point-max))
-	(insert-buffer-substring obuf beg end)
-	(set-buffer obuf)))
+
+      (save-excursion
+	(let ((beg (point-min))
+	      (end (point-max))
+	      (obuf (current-buffer)))
+	  (nnfolder-possibly-change-folder (car group-art))
+	  (goto-char (point-max))
+	  (unless (eolp)
+	    (insert "\n"))
+	  (unless (bobp)
+	    (insert "\n"))
+	  (insert-buffer-substring obuf beg end))))
 
     ;; Did we save it anywhere?
     save-list))
@@ -527,36 +585,41 @@ such things as moving mail.  All buffers always get killed upon server close.")
 (defun nnfolder-insert-newsgroup-line (group-art)
   (save-excursion
     (goto-char (point-min))
-    (if (search-forward "\n\n" nil t)
-	(progn
-	  (forward-char -1)
-	  (insert (format (concat nnfolder-article-marker "%d   %s\n")
-			  (cdr group-art) (current-time-string)))))))
-
-(defun nnfolder-possibly-activate-groups (&optional group)
-  (save-excursion
-    ;; If we're looking for the activation of a specific group, find out
-    ;; it's real name and switch to it.
-    (if group (nnfolder-possibly-change-group group))
-    ;; If the group alist isn't active, activate it now.
-    (if (not nnfolder-group-alist)
-	(progn
-	  (nnfolder-request-list)
-	  (setq nnfolder-group-alist (nnmail-get-active))))))
+    (when (search-forward "\n\n" nil t)
+      (forward-char -1)
+      (insert (format (concat nnfolder-article-marker "%d   %s\n")
+		      (cdr group-art) (current-time-string))))))
 
 (defun nnfolder-active-number (group)
-  (save-excursion 
-    (nnfolder-possibly-activate-groups group)
-    (let ((active (car (cdr (assoc group nnfolder-group-alist)))))
-      (setcdr active (1+ (cdr active)))
-      (cdr active))))
+  ;; Find the next article number in GROUP.
+  (let ((active (cadr (assoc group nnfolder-group-alist))))
+    (if active
+	(setcdr active (1+ (cdr active)))
+      ;; This group is new, so we create a new entry for it.
+      ;; This might be a bit naughty... creating groups on the drop of
+      ;; a hat, but I don't know...
+      (push (list group (setq active (cons 1 1)))
+	    nnfolder-group-alist))
+    (cdr active)))
+
+(defun nnfolder-possibly-change-folder (group)
+  (let ((inf (assoc group nnfolder-buffer-alist)))
+    (if (and inf
+	     (gnus-buffer-live-p (cadr inf)))
+	(set-buffer (cadr inf))
+      (when inf
+	(setq nnfolder-buffer-alist (delq inf nnfolder-buffer-alist)))
+      (when nnfolder-group-alist
+	(nnmail-save-active nnfolder-group-alist nnfolder-active-file))
+      (push (list group (nnfolder-read-folder group))
+	    nnfolder-buffer-alist))))
 
 ;; This method has a problem if you've accidentally let the active list get
 ;; out of sync with the files.  This could happen, say, if you've
-;; accidentally gotten new mail with something other than (ding) (but why
+;; accidentally gotten new mail with something other than Gnus (but why
 ;; would _that_ ever happen? :-).  In that case, we will be in the middle of
 ;; processing the file, ready to add new X-Gnus article number markers, and
-;; we'll run accross a message with no ID yet - the active list _may_not_ be
+;; we'll run across a message with no ID yet - the active list _may_not_ be
 ;; ready for us yet.
 
 ;; To handle this, I'm modifying this routine to maintain the maximum ID seen
@@ -566,122 +629,130 @@ such things as moving mail.  All buffers always get killed upon server close.")
 ;; shouldn't cost us much extra time at all, but will be a lot less
 ;; vulnerable to glitches between the mbox and the active file.
 
-(defun nnfolder-read-folder (file)
-  (save-excursion
-    (nnfolder-possibly-activate-groups nil)
-    ;; We should be paranoid here and make sure the group is in the alist,
-    ;; and add it if it isn't.
-    ;;(if (not (assoc nnfoler-current-group nnfolder-group-alist)
-    (set-buffer (setq nnfolder-current-buffer (find-file-noselect file)))
-    (buffer-disable-undo (current-buffer))
-    (let ((delim (concat "^" rmail-unix-mail-delimiter))
-	  (marker (concat "\n" nnfolder-article-marker))
-	  (number "[0-9]+")
-	  (active (car (cdr (assoc nnfolder-current-group 
-				   nnfolder-group-alist))))
-	  activenumber activemin start end)
-      (goto-char (point-min))
-      ;;
-      ;; Anytime the active number is 1 or 0, it is supect.  In that case,
-      ;; search the file manually to find the active number.  Or, of course,
-      ;; if we're being paranoid.  (This would also be the place to build
-      ;; other lists from the header markers, such as expunge lists, etc., if
-      ;; we ever desired to abandon the active file entirely for mboxes.)
-      (setq activenumber (cdr active))
-      (if (or nnfolder-ignore-active-file
-	      (< activenumber 2))
-	  (progn
-	    (setq activemin (max (1- (lsh 1 23)) 
-				 (1- (lsh 1 24)) 
-				 (1- (lsh 1 25))))
+(defun nnfolder-read-folder (group)
+  (let* ((file (nnfolder-group-pathname group))
+	 (buffer (set-buffer (nnheader-find-file-noselect file))))
+    (if (equal (cadr (assoc group nnfolder-scantime-alist))
+	       (nth 5 (file-attributes file)))
+	;; This looks up-to-date, so we don't do any scanning.
+	buffer
+      ;; Parse the damn thing.
+      (save-excursion
+	(nnmail-activate 'nnfolder)
+	;; Read in the file.
+	(let ((delim (concat "^" message-unix-mail-delimiter))
+	      (marker (concat "\n" nnfolder-article-marker))
+	      (number "[0-9]+")
+	      (active (cadr (assoc group nnfolder-group-alist)))
+	      (scantime (assoc group nnfolder-scantime-alist))
+	      (minid (lsh -1 -1))
+	      maxid start end newscantime
+	      buffer-read-only)
+	  (buffer-disable-undo (current-buffer))
+	  (setq maxid (cdr active))
+	  (goto-char (point-min))
+
+	  ;; Anytime the active number is 1 or 0, it is suspect.  In that
+	  ;; case, search the file manually to find the active number.  Or,
+	  ;; of course, if we're being paranoid.  (This would also be the
+	  ;; place to build other lists from the header markers, such as
+	  ;; expunge lists, etc., if we ever desired to abandon the active
+	  ;; file entirely for mboxes.)
+	  (when (or nnfolder-ignore-active-file
+		    (< maxid 2))
 	    (while (and (search-forward marker nil t)
 			(re-search-forward number nil t))
-	      (let ((newnum (string-to-number (buffer-substring
-					      (match-beginning 0)
-					      (match-end 0)))))
-		(setq activenumber (max activenumber newnum))
-		(setq activemin (min activemin newnum))))
-	    (setcar active (min activemin activenumber))
-	    (setcdr active activenumber)
-	    (goto-char (point-min))))
-
-      ;; Keep track of the active number on our own, and insert it back into
-      ;; the active list when we're done. Also, prime the pump to cut down on
-      ;; the number of searches we do.
-      (setq end (point-marker))
-      (set-marker end (or (and (re-search-forward delim nil t)
-			       (match-beginning 0))
-			  (point-max)))
-      (while (not (= end (point-max)))
-	(setq start (marker-position end))
-	(goto-char end)
-	(end-of-line)
-	(set-marker end (or (and (re-search-forward delim nil t)
-				 (match-beginning 0))
-			    (point-max)))
-	(goto-char start)
-	(if (not (search-forward marker end t))
-	    (progn
+	      (let ((newnum (string-to-number (match-string 0))))
+		(setq maxid (max maxid newnum))
+		(setq minid (min minid newnum))))
+	    (setcar active (max 1 (min minid maxid)))
+	    (setcdr active (max maxid (cdr active)))
+	    (goto-char (point-min)))
+
+	  ;; As long as we trust that the user will only insert unmarked mail
+	  ;; at the end, go to the end and search backwards for the last
+	  ;; marker.  Find the start of that message, and begin to search for
+	  ;; unmarked messages from there.
+	  (when (not (or nnfolder-distrust-mbox
+			 (< maxid 2)))
+	    (goto-char (point-max))
+	    (if (not (re-search-backward marker nil t))
+		(goto-char (point-min))
+	      (when (not (nnmail-search-unix-mail-delim))
+		(goto-char (point-min)))))
+
+	  ;; Keep track of the active number on our own, and insert it back
+	  ;; into the active list when we're done.  Also, prime the pump to
+	  ;; cut down on the number of searches we do.
+	  (unless (nnmail-search-unix-mail-delim)
+	    (goto-char (point-max)))
+	  (setq end (point-marker))
+	  (while (not (= end (point-max)))
+	    (setq start (marker-position end))
+	    (goto-char end)
+	    ;; There may be more than one "From " line, so we skip past
+	    ;; them.
+	    (while (looking-at delim)
+	      (forward-line 1))
+	    (set-marker end (if (nnmail-search-unix-mail-delim)
+				(point)
+			      (point-max)))
+	    (goto-char start)
+	    (when (not (search-forward marker end t))
 	      (narrow-to-region start end)
 	      (nnmail-insert-lines)
-	      (setq activenumber (1+ activenumber))
-	      (nnfolder-insert-newsgroup-line (cons nil activenumber))
-	      (widen))))
+	      (nnfolder-insert-newsgroup-line
+	       (cons nil (nnfolder-active-number nnfolder-current-group)))
+	      (widen)))
 
-      ;; Make absolutely sure that the active list reflects reality!
-      (setcdr active activenumber)
-      (nnmail-save-active nnfolder-group-alist nnfolder-active-file)
-      (current-buffer))))
-
-(defun nnfolder-get-new-mail (&optional group)
-  "Read new incoming mail."
-  (let* ((spools (nnmail-get-spool-files group))
-	 (group-in group)
-	 incomings incoming)
-    (if (or (not nnfolder-get-new-mail) (not nnmail-spool-file))
-	()
-      ;; We first activate all the groups.
-      (nnfolder-possibly-activate-groups nil)
-      ;; The we go through all the existing spool files and split the
-      ;; mail from each.
-      (while spools
-	(and
-	 (file-exists-p (car spools))
-	 (> (nth 7 (file-attributes (car spools))) 0)
-	 (progn
-	   (and gnus-verbose-backends 
-		(message "nnfolder: Reading incoming mail..."))
-	   (setq incoming 
-		 (nnmail-move-inbox 
-		  (car spools) 
-		  (concat (file-name-as-directory nnfolder-directory)
-			  "Incoming")))
-	   (setq incomings (cons incoming incomings))
-	   (setq group (nnmail-get-split-group (car spools) group-in))
-	   (nnmail-split-incoming incoming 'nnfolder-save-mail nil group)))
-	(setq spools (cdr spools)))
-      ;; If we did indeed read any incoming spools, we save all info. 
-      (if incoming 
-	  (progn
-	    (nnmail-save-active nnfolder-group-alist nnfolder-active-file)
-	    (run-hooks 'nnmail-read-incoming-hook)
-	    (and gnus-verbose-backends
-		 (message "nnfolder: Reading incoming mail...done"))))
-      (let ((bufs nnfolder-buffer-alist))
-	(save-excursion
-	  (while bufs
-	    (if (not (buffer-name (nth 1 (car bufs))))
-		(setq nnfolder-buffer-alist 
-		      (delq (car bufs) nnfolder-buffer-alist))
-	      (set-buffer (nth 1 (car bufs)))
-	      (and (buffer-modified-p) (save-buffer)))
-	    (setq bufs (cdr bufs)))))
-      (while incomings
-	(and 
-	 nnmail-delete-incoming
-	 (file-writable-p incoming)
-	 (delete-file incoming))
-	(setq incomings (cdr incomings))))))
+	  (set-marker end nil)
+	  ;; Make absolutely sure that the active list reflects reality!
+	  (nnmail-save-active nnfolder-group-alist nnfolder-active-file)
+	  ;; Set the scantime for this group.
+	  (setq newscantime (visited-file-modtime))
+	  (if scantime
+	      (setcdr scantime (list newscantime))
+	    (push (list nnfolder-current-group newscantime)
+		  nnfolder-scantime-alist))
+	  (current-buffer))))))
+
+;;;###autoload
+(defun nnfolder-generate-active-file ()
+  "Look for mbox folders in the nnfolder directory and make them into groups."
+  (interactive)
+  (nnmail-activate 'nnfolder)
+  (let ((files (directory-files nnfolder-directory))
+        file)
+    (while (setq file (pop files))
+      (when (and (not (backup-file-name-p file))
+                 (message-mail-file-mbox-p
+		  (nnheader-concat nnfolder-directory file)))
+        (let ((oldgroup (assoc file nnfolder-group-alist)))
+          (if oldgroup
+              (nnheader-message 5 "Refreshing group %s..." file)
+            (nnheader-message 5 "Adding group %s..." file))
+          (setq nnfolder-group-alist (remove oldgroup nnfolder-group-alist))
+          (push (list file (cons 1 0)) nnfolder-group-alist)
+          (nnfolder-possibly-change-folder file)
+          (nnfolder-possibly-change-group file)
+          (nnfolder-close-group file))))
+    (message "")))
+
+(defun nnfolder-group-pathname (group)
+  "Make pathname for GROUP."
+  (let ((dir (file-name-as-directory (expand-file-name nnfolder-directory))))
+    ;; If this file exists, we use it directly.
+    (if (or nnmail-use-long-file-names
+	    (file-exists-p (concat dir group)))
+	(concat dir group)
+      ;; If not, we translate dots into slashes.
+      (concat dir (nnheader-replace-chars-in-string group ?. ?/)))))
+
+(defun nnfolder-save-buffer ()
+  "Save the buffer."
+  (when (buffer-modified-p)
+    (run-hooks 'nnfolder-save-buffer-hook)
+    (save-buffer)))
 
 (provide 'nnfolder)