X-Git-Url: https://cgit.sxemacs.org/?a=blobdiff_plain;f=lisp%2Fnnfolder.el;h=d782835aafc24c9f205c4202a4079d03a9aed9e8;hb=703193cc0d0cf8c79d6a3cbd16b8d3565dab46f3;hp=60ad4289bbb10a2614ea01771c4f2e8bdef8914c;hpb=507b285173baa14c25dc095f5c65d05a5474a8fe;p=gnus

diff --git a/lisp/nnfolder.el b/lisp/nnfolder.el
index 60ad4289b..d782835aa 100644
--- a/lisp/nnfolder.el
+++ b/lisp/nnfolder.el
@@ -1,8 +1,9 @@
 ;;; nnfolder.el --- mail folder access for Gnus
-;; Copyright (C) 1995,96,97 Free Software Foundation, Inc.
+;; Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000
+;;        Free Software Foundation, Inc.
 
 ;; Author: Scott Byer <byer@mv.us.adobe.com>
-;;	Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
+;;	Lars Magne Ingebrigtsen <larsi@gnus.org>
 ;; 	Masanobu UMEDA <umerin@flab.flab.fujitsu.junet>
 ;; Keywords: mail
 
@@ -31,7 +32,7 @@
 (require 'message)
 (require 'nnmail)
 (require 'nnoo)
-(require 'cl)
+(eval-when-compile (require 'cl))
 (require 'gnus-util)
 
 (nnoo-declare nnfolder)
@@ -40,27 +41,29 @@
   "The name of the nnfolder directory.")
 
 (defvoo nnfolder-active-file
-  (nnheader-concat nnfolder-directory "active")
+    (nnheader-concat nnfolder-directory "active")
   "The name of the active file.")
 
 ;; I renamed this variable to something more in keeping with the general GNU
 ;; style. -SLB
 
 (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.")
+  "If non-nil, the active file is ignores.
+This 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.")
+  "If non-nil, the folder will be distrusted.
+This means that nnfolder will 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")
+    (concat (file-name-as-directory nnfolder-directory) "newsgroups")
   "Mail newsgroups description file.")
 
 (defvoo nnfolder-get-new-mail t
@@ -90,6 +93,13 @@ time saver for large mailboxes.")
 (defvoo nnfolder-buffer-alist nil)
 (defvoo nnfolder-scantime-alist nil)
 (defvoo nnfolder-active-timestamp nil)
+(defvoo nnfolder-active-file-coding-system mm-text-coding-system)
+(defvoo nnfolder-active-file-coding-system-for-write 
+    nnmail-active-file-coding-system)
+(defvoo nnfolder-file-coding-system mm-text-coding-system)
+(defvoo nnfolder-file-coding-system-for-write nnheader-file-coding-system
+  "Coding system for save nnfolder file.
+If NIL, NNFOLDER-FILE-CODING-SYSTEM is used.")
 
 
 
@@ -101,33 +111,25 @@ time saver for large mailboxes.")
   (save-excursion
     (set-buffer nntp-server-buffer)
     (erase-buffer)
-    (let (article art-string start stop)
+    (let (article start stop)
       (nnfolder-possibly-change-group group server)
       (when nnfolder-current-buffer
 	(set-buffer nnfolder-current-buffer)
 	(goto-char (point-min))
 	(if (stringp (car articles))
 	    'headers
-	  (while articles
-	    (setq article (car articles))
-	    (setq art-string (nnfolder-article-string article))
+	  (while (setq article (pop articles))
 	    (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)
+	    (when (nnfolder-goto-article article)
 	      (setq start (point))
-	      (search-forward "\n\n" nil t)
-	      (setq stop (1- (point)))
+	      (setq stop (if (search-forward "\n\n" nil t)
+			     (1- (point))
+			   (point-max)))
 	      (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)))
+	      (insert ".\n")))
 
 	  (set-buffer nntp-server-buffer)
 	  (nnheader-fold-continuation-lines)
@@ -165,9 +167,8 @@ time saver for large mailboxes.")
   (save-excursion
     (set-buffer nnfolder-current-buffer)
     (goto-char (point-min))
-    (when (search-forward (nnfolder-article-string article) nil t)
+    (when (nnfolder-goto-article article)
       (let (start stop)
-	(nnmail-search-unix-mail-delim-backward)
 	(setq start (point))
 	(forward-line 1)
 	(unless (and (nnmail-search-unix-mail-delim)
@@ -186,11 +187,13 @@ time saver for large mailboxes.")
 	  (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)))))))))))
+		  (if (search-forward (concat "\n" nnfolder-article-marker) 
+				      nil t)
+		      (string-to-int
+		       (buffer-substring
+			(point) (progn (end-of-line) (point))))
+		    -1))))))))
 
 (deffoo nnfolder-request-group (group &optional server dont-check)
   (nnfolder-possibly-change-group group server t)
@@ -225,7 +228,7 @@ time saver for large mailboxes.")
        (let ((bufs nnfolder-buffer-alist))
 	 (save-excursion
 	   (while bufs
-	     (if (not (buffer-live-p (nth 1 (car bufs))))
+	     (if (not (gnus-buffer-live-p (nth 1 (car bufs))))
 		 (setq nnfolder-buffer-alist
 		       (delq (car bufs) nnfolder-buffer-alist))
 	       (set-buffer (nth 1 (car bufs)))
@@ -276,14 +279,16 @@ time saver for large mailboxes.")
   (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)))
+      (nnfolder-save-active nnfolder-group-alist nnfolder-active-file)
+      (nnfolder-read-folder group)))
   t)
 
 (deffoo nnfolder-request-list (&optional server)
   (nnfolder-possibly-change-group nil server)
   (save-excursion
-    (nnmail-find-file nnfolder-active-file)
-    (setq nnfolder-group-alist (nnmail-get-active))
+    (let ((nnmail-file-coding-system nnfolder-active-file-coding-system))
+      (nnmail-find-file nnfolder-active-file)
+      (setq nnfolder-group-alist (nnmail-get-active)))
     t))
 
 (deffoo nnfolder-request-newgroups (date &optional server)
@@ -293,111 +298,164 @@ time saver for large mailboxes.")
 (deffoo nnfolder-request-list-newsgroups (&optional server)
   (nnfolder-possibly-change-group nil server)
   (save-excursion
-    (nnmail-find-file nnfolder-newsgroups-file)))
+    (let ((nnmail-file-coding-system nnfolder-file-coding-system))
+      (nnmail-find-file nnfolder-newsgroups-file))))
+
+;; Return a list consisting of all article numbers existing in the
+;; current folder.
+
+(defun nnfolder-existing-articles ()
+  (save-excursion
+    (when nnfolder-current-buffer
+      (set-buffer nnfolder-current-buffer)
+      (goto-char (point-min))
+      (let ((marker (concat "\n" nnfolder-article-marker))
+	    (number "[0-9]+")
+	    numbers)
+      
+	(while (and (search-forward marker nil t)
+		    (re-search-forward number nil t))
+	  (let ((newnum (string-to-number (match-string 0))))
+	    (if (nnmail-within-headers-p)
+		(push newnum numbers))))
+	numbers))))
 
 (deffoo nnfolder-request-expire-articles
-  (articles newsgroup &optional server force)
+    (articles newsgroup &optional server force)
   (nnfolder-possibly-change-group newsgroup server)
   (let* ((is-old t)
-	 rest)
+	 ;; The articles we have deleted so far.
+	 (deleted-articles nil)
+	 ;; The articles that really exist and will
+	 ;; be expired if they are old enough.
+	 (maybe-expirable
+	  (gnus-intersection articles (nnfolder-existing-articles))))
     (nnmail-activate 'nnfolder)
 
     (save-excursion
       (set-buffer nnfolder-current-buffer)
-      (while (and articles is-old)
+      ;; Since messages are sorted in arrival order and expired in the
+      ;; same order, we can stop as soon as we find a message that is
+      ;; too old.
+      (while (and maybe-expirable is-old)
 	(goto-char (point-min))
-	(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)))
+	(when (and (nnfolder-goto-article (car maybe-expirable))
+		   (search-forward (concat "\n" nnfolder-article-marker)
+				   nil t))
+	  (forward-sexp)
+	  (when (setq is-old
+		      (nnmail-expired-article-p
+		       newsgroup
+		       (buffer-substring
+			(point) (progn (end-of-line) (point)))
+		       force nnfolder-inhibit-expiry))
+	    (nnheader-message 5 "Deleting article %d..."
+			      (car maybe-expirable) newsgroup)
+	    (nnfolder-delete-mail)
+	    ;; Must remember which articles were actually deleted
+	    (push (car maybe-expirable) deleted-articles)))
+	(setq maybe-expirable (cdr maybe-expirable)))
       (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))))
-
-(deffoo nnfolder-request-move-article
-  (article group server accept-form &optional last)
-  (let ((buf (get-buffer-create " *nnfolder move*"))
-	result)
-    (and
-     (nnfolder-request-article article group server)
-     (save-excursion
-       (set-buffer buf)
-       (buffer-disable-undo (current-buffer))
-       (erase-buffer)
-       (insert-buffer-substring nntp-server-buffer)
-       (goto-char (point-min))
-       (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))))
-       (setq result (eval accept-form))
-       (kill-buffer buf)
-       result)
-     (save-excursion
-       (nnfolder-possibly-change-group group server)
-       (set-buffer nnfolder-current-buffer)
-       (goto-char (point-min))
-       (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))
+      (nnfolder-save-active nnfolder-group-alist nnfolder-active-file)
+      (gnus-sorted-complement articles (nreverse deleted-articles)))))
+
+(deffoo nnfolder-request-move-article (article group server
+					       accept-form &optional last)
+  (save-excursion
+    (let ((buf (get-buffer-create " *nnfolder move*"))
+	  result)
+      (and
+       (nnfolder-request-article article group server)
+       (save-excursion
+	 (set-buffer buf)
+	 (erase-buffer)
+	 (insert-buffer-substring nntp-server-buffer)
+	 (goto-char (point-min))
+	 (while (re-search-forward
+		 (concat "^" nnfolder-article-marker)
+		 (save-excursion (and (search-forward "\n\n" nil t) (point))) 
+		 t)
+	   (delete-region (progn (beginning-of-line) (point))
+			  (progn (forward-line 1) (point))))
+	 (setq result (eval accept-form))
+	 (kill-buffer buf)
+	 result)
+       (save-excursion
+	 (nnfolder-possibly-change-group group server)
+	 (set-buffer nnfolder-current-buffer)
+	 (goto-char (point-min))
+	 (when (nnfolder-goto-article article)
+	   (nnfolder-delete-mail))
+	 (when last
+	   (nnfolder-save-buffer)
+	   (nnfolder-adjust-min-active group)
+	   (nnfolder-save-active nnfolder-group-alist nnfolder-active-file))))
+      result)))
 
 (deffoo nnfolder-request-accept-article (group &optional server last)
-  (nnfolder-possibly-change-group group server)
-  (nnmail-check-syntax)
-  (let ((buf (current-buffer))
-	result art-group)
-    (goto-char (point-min))
-    (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 (concat "^" nnfolder-article-marker) nil t)
-	 (delete-region (point) (progn (forward-line 1) (point))))
-       (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-group group server)
+    (nnmail-check-syntax)
+    (let ((buf (current-buffer))
+	  result art-group)
+      (goto-char (point-min))
+      (when (looking-at "X-From-Line: ")
+	(replace-match "From "))
+      (and
+       (nnfolder-request-list)
        (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))
+	 (set-buffer buf)
+	 (goto-char (point-min))
+	 (if (search-forward "\n\n" nil t)
+	     (forward-line -1)
+	   (goto-char (point-max)))
+	 (while (re-search-backward (concat "^" nnfolder-article-marker) nil t)
+	   (delete-region (point) (progn (forward-line 1) (point))))
+	 (when nnmail-cache-accepted-message-ids
+	   (nnmail-cache-insert (nnmail-fetch-field "message-id")))
+	 (setq result (if (stringp group)
+			  (list (cons group (nnfolder-active-number group)))
+			(setq art-group
+			      (nnmail-article-group 'nnfolder-active-number))))
+	 (if (and (null result)
+		  (yes-or-no-p "Moved to `junk' group; delete article? "))
+	     (setq result 'junk)
+	   (setq result
+		 (car (nnfolder-save-mail result)))))
+       (when last
+	 (save-excursion
+	   (nnfolder-possibly-change-folder (or (caar art-group) group))
+	   (nnfolder-save-buffer)
+	   (when nnmail-cache-accepted-message-ids
+	     (nnmail-cache-close)))))
+      (nnfolder-save-active nnfolder-group-alist nnfolder-active-file)
+      (unless result
+	(nnheader-report 'nnfolder "Couldn't store article"))
+      result)))
 
 (deffoo nnfolder-request-replace-article (article group buffer)
   (nnfolder-possibly-change-group group)
   (save-excursion
+    (set-buffer buffer)
+    (goto-char (point-min))
+    (let (xfrom)
+      (while (re-search-forward "^X-From-Line: \\(.*\\)$" nil t)
+	(setq xfrom (match-string 1))
+	(gnus-delete-line))
+      (goto-char (point-min))
+      (if xfrom
+	  (insert "From " xfrom "\n")
+	(unless (looking-at "From ")
+	  (insert "From nobody " (current-time-string) "\n"))))
+    (nnfolder-normalize-buffer)
     (set-buffer nnfolder-current-buffer)
     (goto-char (point-min))
-    (if (not (search-forward (nnfolder-article-string article) nil t))
+    (if (not (nnfolder-goto-article article))
 	nil
-      (nnfolder-delete-mail t t)
+      (nnfolder-delete-mail)
       (insert-buffer-substring buffer)
       (nnfolder-save-buffer)
       t)))
@@ -416,7 +474,7 @@ time saver for large mailboxes.")
 	nnfolder-current-group nil
 	nnfolder-current-buffer nil)
   ;; Save the active file.
-  (nnmail-save-active nnfolder-group-alist nnfolder-active-file)
+  (nnfolder-save-active nnfolder-group-alist nnfolder-active-file)
   t)
 
 (deffoo nnfolder-request-rename-group (group new-name &optional server)
@@ -427,7 +485,9 @@ time saver for large mailboxes.")
 	 (ignore-errors
 	   (rename-file
 	    buffer-file-name
-	    (nnfolder-group-pathname new-name))
+	    (let ((new-file (nnfolder-group-pathname new-name)))
+	      (gnus-make-directory (file-name-directory new-file))
+	      new-file))
 	   t)
 	 ;; That went ok, so we change the internal structures.
 	 (let ((entry (assoc group nnfolder-group-alist)))
@@ -435,11 +495,16 @@ time saver for large mailboxes.")
 	   (setq nnfolder-current-buffer nil
 		 nnfolder-current-group nil)
 	   ;; Save the new group alist.
-	   (nnmail-save-active nnfolder-group-alist nnfolder-active-file)
+	   (nnfolder-save-active nnfolder-group-alist nnfolder-active-file)
 	   ;; We kill the buffer instead of renaming it and stuff.
 	   (kill-buffer (current-buffer))
 	   t))))
 
+(defun nnfolder-request-regenerate (server)
+  (nnfolder-possibly-change-group nil server)
+  (nnfolder-generate-active-file)
+  t)
+
 
 ;;; Internal functions.
 
@@ -454,10 +519,9 @@ time saver for large mailboxes.")
       (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))))))
+	(let ((newnum (string-to-number (match-string 0))))
+	  (if (nnmail-within-headers-p)
+	      (setq activemin (min activemin newnum)))))
       (setcar active activemin))))
 
 (defun nnfolder-article-string (article)
@@ -465,21 +529,49 @@ time saver for large mailboxes.")
       (concat "\n" nnfolder-article-marker (int-to-string article) " ")
     (concat "\nMessage-ID: " article)))
 
-(defun nnfolder-delete-mail (&optional force leave-delim)
-  "Delete the message that point is in."
-  (save-excursion
-    (delete-region
+(defun nnfolder-goto-article (article)
+  "Place point at the start of the headers of ARTICLE.
+ARTICLE can be an article number or a Message-ID.
+Returns t if successful, nil otherwise."
+  (let ((art-string (nnfolder-article-string article))
+	start found)
+    ;; It is likely that we are at or before the delimiter line.
+    ;; We therefore go to the end of the previous line, and start
+    ;; searching from there.
+    (beginning-of-line)
+    (unless (bobp)
+      (forward-char -1))
+    (setq start (point))
+    ;; First search forward.
+    (while (and (setq found (search-forward art-string nil t))
+		(not (nnmail-within-headers-p))))
+    ;; If unsuccessful, search backward from where we started,
+    (unless found
+      (goto-char start)
+      (while (and (setq found (search-backward art-string nil t))
+		  (not (nnmail-within-headers-p)))))
+    (when found
+      (nnmail-search-unix-mail-delim-backward))))
+
+(defun nnfolder-delete-mail (&optional leave-delim)
+  "Delete the message that point is in.
+If optional argument LEAVE-DELIM is t, then mailbox delimiter is not
+deleted.  Point is left where the deleted region was."
+  (save-restriction
+    (narrow-to-region
      (save-excursion
+       ;; In case point is at the beginning of the message already.
+       (forward-line 1)
        (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))))))
+	   (point)
+	 (point-max))))
+    (run-hooks 'nnfolder-delete-mail-hook)
+    (delete-region (point-min) (point-max))))
 
 (defun nnfolder-possibly-change-group (group &optional server dont-check)
   ;; Change servers.
@@ -492,55 +584,61 @@ time saver for large mailboxes.")
   ;; 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.
-	(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))))))))
+    (let ((file-name-coding-system nnmail-pathname-coding-system))
+      (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)
+	(nnfolder-save-active nnfolder-group-alist nnfolder-active-file))
+
+      (if dont-check
+	  (setq nnfolder-current-group group
+		nnfolder-current-buffer nil)
+	(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.
+	  (setq nnfolder-current-buffer
+		(nth 1 (assoc group nnfolder-buffer-alist)))
+
+	  ;; 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))
+		(let ((nnmail-file-coding-system 
+		       (or nnfolder-file-coding-system-for-write
+			   nnfolder-file-coding-system-for-write)))
+		  (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* (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))
+    (when (looking-at ">From")
       (delete-char 1))
     ;; This might come from somewhere else.
-    (unless (looking-at message-unix-mail-delimiter)
+    (unless (looking-at "From ")
       (insert "From nobody " (current-time-string) "\n")
       (goto-char (point-min)))
     ;; Quote all "From " lines in the article.
@@ -559,8 +657,9 @@ time saver for large mailboxes.")
     (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)
+      (if (search-forward "\n\n" nil t)
+	  (forward-line -1)
+	(goto-char (point-max)))
       (while (search-backward (concat "\n" nnfolder-article-marker) nil t)
 	(delete-region (1+ (point)) (progn (forward-line 2) (point))))
 
@@ -572,23 +671,29 @@ time saver for large mailboxes.")
 	      (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))))
+	  (let ((buffer-read-only nil))
+	    (nnfolder-normalize-buffer)
+	    (insert-buffer-substring obuf beg end)))))
 
     ;; Did we save it anywhere?
     save-list))
 
+(defun nnfolder-normalize-buffer ()
+  "Make sure there are two newlines at the end of the buffer."
+  (goto-char (point-max))
+  (skip-chars-backward "\n")
+  (delete-region (point) (point-max))
+  (insert "\n\n"))
+
 (defun nnfolder-insert-newsgroup-line (group-art)
   (save-excursion
     (goto-char (point-min))
-    (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))))))
+    (unless (search-forward "\n\n" nil t)
+      (goto-char (point-max))
+      (insert "\n"))
+    (forward-char -1)
+    (insert (format (concat nnfolder-article-marker "%d   %s\n")
+		    (cdr group-art) (current-time-string)))))
 
 (defun nnfolder-active-number (group)
   ;; Find the next article number in GROUP.
@@ -610,7 +715,7 @@ time saver for large mailboxes.")
       (when inf
 	(setq nnfolder-buffer-alist (delq inf nnfolder-buffer-alist)))
       (when nnfolder-group-alist
-	(nnmail-save-active nnfolder-group-alist nnfolder-active-file))
+	(nnfolder-save-active nnfolder-group-alist nnfolder-active-file))
       (push (list group (nnfolder-read-folder group))
 	    nnfolder-buffer-alist))))
 
@@ -631,24 +736,36 @@ time saver for large mailboxes.")
 
 (defun nnfolder-read-folder (group)
   (let* ((file (nnfolder-group-pathname group))
-	 (buffer (set-buffer (nnheader-find-file-noselect file))))
+	 (buffer (set-buffer
+		  (let ((nnheader-file-coding-system 
+			 nnfolder-file-coding-system))
+		    (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
+	(if (file-exists-p file)
+	    buffer
+	  (push (list group buffer) nnfolder-buffer-alist)
+	  (set-buffer-modified-p t)
+	  (nnfolder-save-buffer))
       ;; Parse the damn thing.
       (save-excursion
+	(goto-char (point-min))
+	;; Remove any blank lines at the start.
+	(while (eq (following-char) ?\n)
+	  (delete-char 1))
 	(nnmail-activate 'nnfolder)
 	;; Read in the file.
-	(let ((delim (concat "^" message-unix-mail-delimiter))
+	(let ((delim "^From ")
 	      (marker (concat "\n" nnfolder-article-marker))
 	      (number "[0-9]+")
-	      (active (cadr (assoc group nnfolder-group-alist)))
+	      (active (or (cadr (assoc group nnfolder-group-alist))
+			  (cons 1 0)))
 	      (scantime (assoc group nnfolder-scantime-alist))
 	      (minid (lsh -1 -1))
 	      maxid start end newscantime
 	      buffer-read-only)
-	  (buffer-disable-undo (current-buffer))
+	  (buffer-disable-undo)
 	  (setq maxid (cdr active))
 	  (goto-char (point-min))
 
@@ -663,8 +780,9 @@ time saver for large mailboxes.")
 	    (while (and (search-forward marker nil t)
 			(re-search-forward number nil t))
 	      (let ((newnum (string-to-number (match-string 0))))
-		(setq maxid (max maxid newnum))
-		(setq minid (min minid newnum))))
+		(if (nnmail-within-headers-p)
+		    (setq maxid (max maxid newnum)
+		          minid (min minid newnum)))))
 	    (setcar active (max 1 (min minid maxid)))
 	    (setcdr active (max maxid (cdr active)))
 	    (goto-char (point-min)))
@@ -676,10 +794,10 @@ time saver for large mailboxes.")
 	  (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)))))
+	    (unless (re-search-backward marker nil t)
+	      (goto-char (point-min)))
+	    (when (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
@@ -707,7 +825,7 @@ time saver for large mailboxes.")
 
 	  (set-marker end nil)
 	  ;; Make absolutely sure that the active list reflects reality!
-	  (nnmail-save-active nnfolder-group-alist nnfolder-active-file)
+	  (nnfolder-save-active nnfolder-group-alist nnfolder-active-file)
 	  ;; Set the scantime for this group.
 	  (setq newscantime (visited-file-modtime))
 	  (if scantime
@@ -718,7 +836,8 @@ time saver for large mailboxes.")
 
 ;;;###autoload
 (defun nnfolder-generate-active-file ()
-  "Look for mbox folders in the nnfolder directory and make them into groups."
+  "Look for mbox folders in the nnfolder directory and make them into groups.
+This command does not work if you use short group names."
   (interactive)
   (nnmail-activate 'nnfolder)
   (let ((files (directory-files nnfolder-directory))
@@ -731,15 +850,19 @@ time saver for large mailboxes.")
           (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))
+	  (if oldgroup
+	      (setq nnfolder-group-alist
+		    (delq oldgroup (copy-sequence 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 "")))
+    (nnheader-message 5 "")))
 
 (defun nnfolder-group-pathname (group)
   "Make pathname for GROUP."
+  (setq group
+	(mm-encode-coding-string group nnmail-pathname-coding-system))
   (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
@@ -752,7 +875,17 @@ time saver for large mailboxes.")
   "Save the buffer."
   (when (buffer-modified-p)
     (run-hooks 'nnfolder-save-buffer-hook)
-    (save-buffer)))
+    (gnus-make-directory (file-name-directory (buffer-file-name)))
+    (let ((coding-system-for-write 
+	   (or nnfolder-file-coding-system-for-write
+	       nnfolder-file-coding-system)))
+      (save-buffer))))
+
+(defun nnfolder-save-active (group-alist active-file)
+  (let ((nnmail-active-file-coding-system
+	 (or nnfolder-active-file-coding-system-for-write
+	     nnfolder-active-file-coding-system)))
+    (nnmail-save-active group-alist active-file)))
 
 (provide 'nnfolder)