* nnheader.el (nnheader-remove-body): Fix an error of detecting boundary

[gnus] / lisp / nnheader.el

diff --git a/lisp/nnheader.el b/lisp/nnheader.el
index 8c0b075..84da0da 100644 (file)
--- a/lisp/nnheader.el
+++ b/lisp/nnheader.el
@@ -1,9 +1,11 @@
-

 ;;; nnheader.el --- header access macros for Gnus and its backends
 ;;; nnheader.el --- header access macros for Gnus and its backends

-;; Copyright (C) 1987-1990,1993-1999 Free Software Foundation, Inc.
+
+;; Copyright (C) 1987, 1988, 1989, 1990, 1993, 1994, 1995, 1996,
+;;        1997, 1998, 2000, 2001, 2002
+;;        Free Software Foundation, Inc.

 
 ;; Author: Masanobu UMEDA <umerin@flab.flab.fujitsu.junet>
 
 ;; Author: Masanobu UMEDA <umerin@flab.flab.fujitsu.junet>

-;;     Lars Magne Ingebrigtsen <larsi@gnus.org>
+;;     Lars Magne Ingebrigtsen <larsi@gnus.org>

 ;; Keywords: news
 
 ;; This file is part of GNU Emacs.
 ;; Keywords: news
 
 ;; This file is part of GNU Emacs.


@@ -29,16 +31,57 @@
 
 (eval-when-compile (require 'cl))
 
 
 (eval-when-compile (require 'cl))
 

+;; Requiring `gnus-util' at compile time creates a circular
+;; dependency between nnheader.el and gnus-util.el.
+                            ;(eval-when-compile (require 'gnus-util))
+

 (require 'mail-utils)
 (require 'mm-util)
 (require 'mail-utils)
 (require 'mm-util)

+(eval-and-compile
+  (autoload 'gnus-sorted-intersection "gnus-range")
+  (autoload 'gnus-intersection "gnus-range")
+  (autoload 'gnus-sorted-complement "gnus-range")
+  (autoload 'gnus-sorted-difference "gnus-range"))
+
+(defcustom gnus-verbose-backends 7
+  "Integer that says how verbose the Gnus backends should be.
+The higher the number, the more messages the Gnus backends will flash
+to say what it's doing.  At zero, the Gnus backends will be totally
+mute; at five, they will display most important messages; and at ten,
+they will keep on jabbering all the time."
+  :group 'gnus-start
+  :type 'integer)
+
+(defcustom gnus-nov-is-evil nil
+  "If non-nil, Gnus backends will never output headers in the NOV format."
+  :group 'gnus-server
+  :type 'boolean)

 
 (defvar nnheader-max-head-length 4096
 
 (defvar nnheader-max-head-length 4096

-  "*Max length of the head of articles.")
+  "*Max length of the head of articles.
+
+Value is an integer, nil, or t.  nil means read in chunks of a file
+indefinitely until a complete head is found\; t means always read the
+entire file immediately, disregarding `nnheader-head-chop-length'.
+
+Integer values will in effect be rounded up to the nearest multiple of
+`nnheader-head-chop-length'.")

 
 (defvar nnheader-head-chop-length 2048
   "*Length of each read operation when trying to fetch HEAD headers.")
 
 
 (defvar nnheader-head-chop-length 2048
   "*Length of each read operation when trying to fetch HEAD headers.")
 

-(defvar nnheader-file-name-translation-alist nil
+(defvar nnheader-file-name-translation-alist
+  (let ((case-fold-search t))
+    (cond
+     ((string-match "windows-nt\\|os/2\\|emx\\|cygwin"
+                   (symbol-name system-type))
+      (append (mapcar (lambda (c) (cons c ?_))
+                     '(?: ?* ?\" ?< ?> ??))
+             (if (string-match "windows-nt\\|cygwin"
+                               (symbol-name system-type))
+                 nil
+               '((?+ . ?-)))))
+     (t nil)))

   "*Alist that says how to translate characters in file names.
 For instance, if \":\" is invalid as a file character in file names
 on your system, you could say something like:
   "*Alist that says how to translate characters in file names.
 For instance, if \":\" is invalid as a file character in file names
 on your system, you could say something like:


@@ -49,9 +92,7 @@ on your system, you could say something like:
   (autoload 'nnmail-message-id "nnmail")
   (autoload 'mail-position-on-field "sendmail")
   (autoload 'message-remove-header "message")
   (autoload 'nnmail-message-id "nnmail")
   (autoload 'mail-position-on-field "sendmail")
   (autoload 'message-remove-header "message")

-  (autoload 'cancel-function-timers "timers")

   (autoload 'gnus-point-at-eol "gnus-util")
   (autoload 'gnus-point-at-eol "gnus-util")

-  (autoload 'gnus-delete-line "gnus-util")

   (autoload 'gnus-buffer-live-p "gnus-util"))
 
 ;;; Header access macros.
   (autoload 'gnus-buffer-live-p "gnus-util"))
 
 ;;; Header access macros.


@@ -138,7 +179,7 @@ on your system, you could say something like:
   `(aref ,header 8))
 
 (defmacro mail-header-set-xref (header xref)
   `(aref ,header 8))
 
 (defmacro mail-header-set-xref (header xref)

-  "Set article xref of HEADER to xref."
+  "Set article XREF of HEADER to xref."

   `(aset ,header 8 ,xref))
 
 (defmacro mail-header-extra (header)
   `(aset ,header 8 ,xref))
 
 (defmacro mail-header-extra (header)


@@ -167,124 +208,140 @@ on your system, you could say something like:
   (concat "fake+none+" (int-to-string (incf nnheader-fake-message-id))))
 
 (defsubst nnheader-fake-message-id-p (id)
   (concat "fake+none+" (int-to-string (incf nnheader-fake-message-id))))
 
 (defsubst nnheader-fake-message-id-p (id)

-  (save-match-data                     ; regular message-id's are <.*>
+  (save-match-data                    ; regular message-id's are <.*>

     (string-match "\\`fake\\+none\\+[0-9]+\\'" id)))
 
 ;; Parsing headers and NOV lines.
 
     (string-match "\\`fake\\+none\\+[0-9]+\\'" id)))
 
 ;; Parsing headers and NOV lines.
 

+(defsubst nnheader-remove-cr-followed-by-lf ()
+  (goto-char (point-max))
+  (while (search-backward "\r\n" nil t)
+    (delete-char 1)))
+

 (defsubst nnheader-header-value ()
 (defsubst nnheader-header-value ()

-  (buffer-substring (match-end 0) (gnus-point-at-eol)))
+  (skip-chars-forward " \t")
+  (buffer-substring (point) (gnus-point-at-eol)))

 
 

-(defun nnheader-parse-head (&optional naked)
+(defun nnheader-parse-naked-head (&optional number)
+  ;; This function unfolds continuation lines in this buffer
+  ;; destructively.  When this side effect is unwanted, use
+  ;; `nnheader-parse-head' instead of this function.

   (let ((case-fold-search t)
   (let ((case-fold-search t)

-       (cur (current-buffer))

        (buffer-read-only nil)
        (buffer-read-only nil)

-       in-reply-to lines p ref)
-    (goto-char (point-min))
-    (when naked
-      (insert "\n"))
-    ;; Search to the beginning of the next header.  Error messages
-    ;; do not begin with 2 or 3.
+       (cur (current-buffer))
+       (p (point-min))
+       in-reply-to lines ref)
+    (nnheader-remove-cr-followed-by-lf)
+    (ietf-drums-unfold-fws)
+    (subst-char-in-region (point-min) (point-max) ?\t ? )
+    (goto-char p)
+    (insert "\n")

     (prog1
     (prog1

-       (when (or naked (re-search-forward "^[23][0-9]+ " nil t))
-         ;; This implementation of this function, with nine
-         ;; search-forwards instead of the one re-search-forward and
-         ;; a case (which basically was the old function) is actually
-         ;; about twice as fast, even though it looks messier.  You
-         ;; can't have everything, I guess.  Speed and elegance
-         ;; don't always go hand in hand.
-         (vector
-          ;; Number.
-          (if naked
-              (progn
-                (setq p (point-min))
-                0)
-            (prog1
-                (read cur)
-              (end-of-line)
-              (setq p (point))
-              (narrow-to-region (point)
-                                (or (and (search-forward "\n.\n" nil t)
-                                         (- (point) 2))
-                                    (point)))))
-          ;; Subject.
-          (progn
-            (goto-char p)
-            (if (search-forward "\nsubject: " nil t)
-                (nnheader-header-value) "(none)"))
-          ;; From.
-          (progn
-            (goto-char p)
-            (if (search-forward "\nfrom: " nil t)
-                (nnheader-header-value) "(nobody)"))
-          ;; Date.
-          (progn
-            (goto-char p)
-            (if (search-forward "\ndate: " nil t)
-                (nnheader-header-value) ""))
-          ;; Message-ID.
-          (progn
-            (goto-char p)
-            (if (search-forward "\nmessage-id:" nil t)
-                (buffer-substring
-                 (1- (or (search-forward "<" (gnus-point-at-eol) t)
-                         (point)))
-                 (or (search-forward ">" (gnus-point-at-eol) t) (point)))
-              ;; If there was no message-id, we just fake one to make
-              ;; subsequent routines simpler.
-              (nnheader-generate-fake-message-id)))
-          ;; References.
-          (progn
-            (goto-char p)
-            (if (search-forward "\nreferences: " nil t)
-                (nnheader-header-value)
-              ;; Get the references from the in-reply-to header if there
-              ;; were no references and the in-reply-to header looks
-              ;; promising.
-              (if (and (search-forward "\nin-reply-to: " nil t)
-                       (setq in-reply-to (nnheader-header-value))
-                       (string-match "<[^\n>]+>" in-reply-to))
-                  (let (ref2)
-                    (setq ref (substring in-reply-to (match-beginning 0)
-                                         (match-end 0)))
-                    (while (string-match "<[^\n>]+>"
-                                         in-reply-to (match-end 0))
-                      (setq ref2 (substring in-reply-to (match-beginning 0)
-                                            (match-end 0)))
-                      (when (> (length ref2) (length ref))
-                        (setq ref ref2)))
-                     ref)
-                nil)))
-          ;; Chars.
-          0
-          ;; Lines.
-          (progn
-            (goto-char p)
-            (if (search-forward "\nlines: " nil t)
-                (if (numberp (setq lines (read cur)))
-                    lines 0)
-              0))
-          ;; Xref.
-          (progn
-            (goto-char p)
-            (and (search-forward "\nxref: " nil t)
-                 (nnheader-header-value)))
-
-          ;; Extra.
-          (when nnmail-extra-headers
-            (let ((extra nnmail-extra-headers)
-                  out)
-              (while extra
-                (goto-char p)
-                (when (search-forward
-                       (concat "\n" (symbol-name (car extra)) ": ") nil t)
-                  (push (cons (car extra) (nnheader-header-value))
-                        out))
-                (pop extra))
-              out))))
-      (when naked
-       (goto-char (point-min))
-       (delete-char 1)))))
+       ;; This implementation of this function, with nine
+       ;; search-forwards instead of the one re-search-forward and a
+       ;; case (which basically was the old function) is actually
+       ;; about twice as fast, even though it looks messier.  You
+       ;; can't have everything, I guess.  Speed and elegance don't
+       ;; always go hand in hand.
+       (vector
+        ;; Number.
+        (or number 0)
+        ;; Subject.
+        (progn
+          (goto-char p)
+          (if (search-forward "\nsubject:" nil t)
+              (nnheader-header-value) "(none)"))
+        ;; From.
+        (progn
+          (goto-char p)
+          (if (search-forward "\nfrom:" nil t)
+              (nnheader-header-value) "(nobody)"))
+        ;; Date.
+        (progn
+          (goto-char p)
+          (if (search-forward "\ndate:" nil t)
+              (nnheader-header-value) ""))
+        ;; Message-ID.
+        (progn
+          (goto-char p)
+          (if (search-forward "\nmessage-id:" nil t)
+              (buffer-substring
+               (1- (or (search-forward "<" (gnus-point-at-eol) t)
+                       (point)))
+               (or (search-forward ">" (gnus-point-at-eol) t) (point)))
+            ;; If there was no message-id, we just fake one to make
+            ;; subsequent routines simpler.
+            (nnheader-generate-fake-message-id)))
+        ;; References.
+        (progn
+          (goto-char p)
+          (if (search-forward "\nreferences:" nil t)
+              (nnheader-header-value)
+            ;; Get the references from the in-reply-to header if
+            ;; there were no references and the in-reply-to header
+            ;; looks promising.
+            (if (and (search-forward "\nin-reply-to:" nil t)
+                     (setq in-reply-to (nnheader-header-value))
+                     (string-match "<[^\n>]+>" in-reply-to))
+                (let (ref2)
+                  (setq ref (substring in-reply-to (match-beginning 0)
+                                       (match-end 0)))
+                  (while (string-match "<[^\n>]+>"
+                                       in-reply-to (match-end 0))
+                    (setq ref2 (substring in-reply-to (match-beginning 0)
+                                          (match-end 0)))
+                    (when (> (length ref2) (length ref))
+                      (setq ref ref2)))
+                  ref)
+              nil)))
+        ;; Chars.
+        0
+        ;; Lines.
+        (progn
+          (goto-char p)
+          (if (search-forward "\nlines: " nil t)
+              (if (numberp (setq lines (read cur)))
+                  lines 0)
+            0))
+        ;; Xref.
+        (progn
+          (goto-char p)
+          (and (search-forward "\nxref:" nil t)
+               (nnheader-header-value)))
+        ;; Extra.
+        (when nnmail-extra-headers
+          (let ((extra nnmail-extra-headers)
+                out)
+            (while extra
+              (goto-char p)
+              (when (search-forward
+                     (concat "\n" (symbol-name (car extra)) ":") nil t)
+                (push (cons (car extra) (nnheader-header-value))
+                      out))
+              (pop extra))
+            out)))
+      (goto-char p)
+      (delete-char 1))))
+
+(defun nnheader-parse-head (&optional naked)
+  (let ((cur (current-buffer)) num beg end)
+    (when (if naked
+             (setq num 0
+                   beg (point-min)
+                   end (point-max))
+           (goto-char (point-min))
+           ;; Search to the beginning of the next header.  Error
+           ;; messages do not begin with 2 or 3.
+           (when (re-search-forward "^[23][0-9]+ " nil t)
+             (end-of-line)
+             (setq num (read cur)
+                   beg (point)
+                   end (if (search-forward "\n.\n" nil t)
+                           (- (point) 2)
+                         (point)))))
+      (with-temp-buffer
+       (insert-buffer-substring cur beg end)
+       (nnheader-parse-naked-head num)))))

 
 (defmacro nnheader-nov-skip-field ()
   '(search-forward "\t" eol 'move))
 
 (defmacro nnheader-nov-skip-field ()
   '(search-forward "\t" eol 'move))


@@ -296,7 +353,9 @@ on your system, you could say something like:
   '(prog1
        (if (eq (char-after) ?\t)
           0
   '(prog1
        (if (eq (char-after) ?\t)
           0

-        (let ((num (ignore-errors (read (current-buffer)))))
+        (let ((num (condition-case nil
+                       (read (current-buffer))
+                     (error nil))))

           (if (numberp num) num 0)))
      (or (eobp) (forward-char 1))))
 
           (if (numberp num) num 0)))
      (or (eobp) (forward-char 1))))
 


@@ -329,36 +388,59 @@ on your system, you could say something like:
      (nnheader-nov-read-integer)       ; lines
      (if (eq (char-after) ?\n)
         nil
      (nnheader-nov-read-integer)       ; lines
      (if (eq (char-after) ?\n)
         nil

-       (nnheader-nov-field))           ; misc
+       (if (looking-at "Xref: ")
+          (goto-char (match-end 0)))
+       (nnheader-nov-field))           ; Xref

      (nnheader-nov-parse-extra))))     ; extra
 
 (defun nnheader-insert-nov (header)
   (princ (mail-header-number header) (current-buffer))
      (nnheader-nov-parse-extra))))     ; extra
 
 (defun nnheader-insert-nov (header)
   (princ (mail-header-number header) (current-buffer))

-  (insert
-   "\t"
-   (or (mail-header-subject header) "(none)") "\t"
-   (or (mail-header-from header) "(nobody)") "\t"
-   (or (mail-header-date header) "") "\t"
-   (or (mail-header-id header)
-       (nnmail-message-id))
-   "\t"
-   (or (mail-header-references header) "") "\t")
-  (princ (or (mail-header-chars header) 0) (current-buffer))
-  (insert "\t")
-  (princ (or (mail-header-lines header) 0) (current-buffer))
-  (insert "\t")
-  (when (mail-header-xref header)
-    (insert "Xref: " (mail-header-xref header)))
-  (when (or (mail-header-xref header)
-           (mail-header-extra header))
-    (insert "\t"))
-  (when (mail-header-extra header)
-    (let ((extra (mail-header-extra header)))
-      (while extra
-       (insert (symbol-name (caar extra))
-               ": " (cdar extra) "\t")
-        (pop extra))))
-  (insert "\n"))
+  (let ((p (point)))
+    (insert
+     "\t"
+     (or (mail-header-subject header) "(none)") "\t"
+     (or (mail-header-from header) "(nobody)") "\t"
+     (or (mail-header-date header) "") "\t"
+     (or (mail-header-id header)
+        (nnmail-message-id))
+     "\t"
+     (or (mail-header-references header) "") "\t")
+    (princ (or (mail-header-chars header) 0) (current-buffer))
+    (insert "\t")
+    (princ (or (mail-header-lines header) 0) (current-buffer))
+    (insert "\t")
+    (when (mail-header-xref header)
+      (insert "Xref: " (mail-header-xref header)))
+    (when (or (mail-header-xref header)
+             (mail-header-extra header))
+      (insert "\t"))
+    (when (mail-header-extra header)
+      (let ((extra (mail-header-extra header)))
+       (while extra
+         (insert (symbol-name (caar extra))
+                 ": " (cdar extra) "\t")
+         (pop extra))))
+    (insert "\n")
+    (backward-char 1)
+    (while (search-backward "\n" p t)
+      (delete-char 1))
+    (forward-line 1)))
+
+(defun nnheader-parse-overview-file (file)
+  "Parse FILE and return a list of headers."
+  (mm-with-unibyte-buffer
+    (nnheader-insert-file-contents file)
+    (goto-char (point-min))
+    (let (headers)
+      (while (not (eobp))
+       (push (nnheader-parse-nov) headers)
+       (forward-line 1))
+      (nreverse headers))))
+
+(defun nnheader-write-overview-file (file headers)
+  "Write HEADERS to FILE."
+  (with-temp-file file
+    (mapcar 'nnheader-insert-nov headers)))

 
 (defun nnheader-insert-header (header)
   (insert
 
 (defun nnheader-insert-header (header)
   (insert


@@ -411,7 +493,8 @@ the line could be found."
        (setq prev (point))
        (while (and (not (numberp (setq num (read cur))))
                    (not (eobp)))
        (setq prev (point))
        (while (and (not (numberp (setq num (read cur))))
                    (not (eobp)))

-         (gnus-delete-line))
+         (delete-region (progn (beginning-of-line) (point))
+                        (progn (forward-line 1) (point))))

        (cond ((> num article)
               (setq max (point)))
              ((< num article)
        (cond ((> num article)
               (setq max (point)))
              ((< num article)


@@ -442,10 +525,7 @@ the line could be found."
 ;; Various cruft the backends and Gnus need to communicate.
 
 (defvar nntp-server-buffer nil)
 ;; Various cruft the backends and Gnus need to communicate.
 
 (defvar nntp-server-buffer nil)

-(defvar gnus-verbose-backends 7
-  "*A number that says how talkative the Gnus backends should be.")
-(defvar gnus-nov-is-evil nil
-  "If non-nil, Gnus backends will never output headers in the NOV format.")
+(defvar nntp-process-response nil)

 (defvar news-reply-yank-from nil)
 (defvar news-reply-yank-message-id nil)
 
 (defvar news-reply-yank-from nil)
 (defvar news-reply-yank-message-id nil)
 


@@ -456,11 +536,12 @@ the line could be found."
   (save-excursion
     (unless (gnus-buffer-live-p nntp-server-buffer)
       (setq nntp-server-buffer (get-buffer-create " *nntpd*")))
   (save-excursion
     (unless (gnus-buffer-live-p nntp-server-buffer)
       (setq nntp-server-buffer (get-buffer-create " *nntpd*")))

-    (mm-enable-multibyte)

     (set-buffer nntp-server-buffer)
     (set-buffer nntp-server-buffer)

+    (mm-enable-multibyte)

     (erase-buffer)
     (kill-all-local-variables)
     (setq case-fold-search t)          ;Should ignore case.
     (erase-buffer)
     (kill-all-local-variables)
     (setq case-fold-search t)          ;Should ignore case.

+    (set (make-local-variable 'nntp-process-response) nil)

     t))
 
 ;;; Various functions the backends use.
     t))
 
 ;;; Various functions the backends use.


@@ -549,6 +630,12 @@ the line could be found."
      (point-max)))
   (goto-char (point-min)))
 
      (point-max)))
   (goto-char (point-min)))
 

+(defun nnheader-remove-body ()
+  "Remove the body from an article in this current buffer."
+  (goto-char (point-min))
+  (when (re-search-forward "\n\r?\n" nil t)
+    (delete-region (point) (point-max))))
+

 (defun nnheader-set-temp-buffer (name &optional noerase)
   "Set-buffer to an empty (possibly new) buffer called NAME with undo disabled."
   (set-buffer (get-buffer-create name))
 (defun nnheader-set-temp-buffer (name &optional noerase)
   "Set-buffer to an empty (possibly new) buffer called NAME with undo disabled."
   (set-buffer (get-buffer-create name))


@@ -557,7 +644,7 @@ the line could be found."
     (erase-buffer))
   (current-buffer))
 
     (erase-buffer))
   (current-buffer))
 

-(defvar jka-compr-compression-info-list)
+(eval-when-compile (defvar jka-compr-compression-info-list))

 (defvar nnheader-numerical-files
   (if (boundp 'jka-compr-compression-info-list)
       (concat "\\([0-9]+\\)\\("
 (defvar nnheader-numerical-files
   (if (boundp 'jka-compr-compression-info-list)
       (concat "\\([0-9]+\\)\\("


@@ -574,17 +661,23 @@ the line could be found."
   "Regexp that matches numerical full file paths.")
 
 (defsubst nnheader-file-to-number (file)
   "Regexp that matches numerical full file paths.")
 
 (defsubst nnheader-file-to-number (file)

-  "Take a file name and return the article number."
+  "Take a FILE name and return the article number."

   (if (string= nnheader-numerical-short-files "^[0-9]+$")
       (string-to-int file)
     (string-match nnheader-numerical-short-files file)
     (string-to-int (match-string 0 file))))
 
   (if (string= nnheader-numerical-short-files "^[0-9]+$")
       (string-to-int file)
     (string-match nnheader-numerical-short-files file)
     (string-to-int (match-string 0 file))))
 

+(defvar nnheader-directory-files-is-safe
+  (or (eq system-type 'windows-nt)
+      (and (not (featurep 'xemacs))
+          (> emacs-major-version 20)))
+  "If non-nil, Gnus believes `directory-files' is safe.
+It has been reported numerous times that `directory-files' fails with
+an alarming frequency on NFS mounted file systems. If it is nil,
+`nnheader-directory-files-safe' is used.")
+

 (defun nnheader-directory-files-safe (&rest args)
 (defun nnheader-directory-files-safe (&rest args)

-  ;; It has been reported numerous times that `directory-files'
-  ;; fails with an alarming frequency on NFS mounted file systems.
-  ;; This function executes that function twice and returns
-  ;; the longest result.
+  "Execute `directory-files' twice and returns the longer result."

   (let ((first (apply 'directory-files args))
        (second (apply 'directory-files args)))
     (if (> (length first) (length second))
   (let ((first (apply 'directory-files args))
        (second (apply 'directory-files args)))
     (if (> (length first) (length second))


@@ -592,16 +685,22 @@ the line could be found."
       second)))
 
 (defun nnheader-directory-articles (dir)
       second)))
 
 (defun nnheader-directory-articles (dir)

-  "Return a list of all article files in a directory."
+  "Return a list of all article files in directory DIR."

   (mapcar 'nnheader-file-to-number
   (mapcar 'nnheader-file-to-number

-         (nnheader-directory-files-safe
-          dir nil nnheader-numerical-short-files t)))
+         (if nnheader-directory-files-is-safe
+             (directory-files
+              dir nil nnheader-numerical-short-files t)
+           (nnheader-directory-files-safe
+            dir nil nnheader-numerical-short-files t))))

 
 (defun nnheader-article-to-file-alist (dir)
   "Return an alist of article/file pairs in DIR."
   (mapcar (lambda (file) (cons (nnheader-file-to-number file) file))
 
 (defun nnheader-article-to-file-alist (dir)
   "Return an alist of article/file pairs in DIR."
   (mapcar (lambda (file) (cons (nnheader-file-to-number file) file))

-         (nnheader-directory-files-safe
-          dir nil nnheader-numerical-short-files t)))
+         (if nnheader-directory-files-is-safe
+             (directory-files
+              dir nil nnheader-numerical-short-files t)
+           (nnheader-directory-files-safe
+            dir nil nnheader-numerical-short-files t))))

 
 (defun nnheader-fold-continuation-lines ()
   "Fold continuation lines in the current buffer."
 
 (defun nnheader-fold-continuation-lines ()
   "Fold continuation lines in the current buffer."


@@ -618,14 +717,31 @@ If FULL, translate everything."
       (if full
          ;; Do complete translation.
          (setq leaf (copy-sequence file)
       (if full
          ;; Do complete translation.
          (setq leaf (copy-sequence file)

-               path "")
+               path ""
+               i (if (and (< 1 (length leaf)) (eq ?: (aref leaf 1)))
+                     2 0))

        ;; We translate -- but only the file name.  We leave the directory
        ;; alone.
        ;; We translate -- but only the file name.  We leave the directory
        ;; alone.

-       (if (string-match "/[^/]+\\'" file)
-           ;; This is needed on NT's and stuff.
-           (setq leaf (substring file (1+ (match-beginning 0)))
-                 path (substring file 0 (1+ (match-beginning 0))))
-         ;; Fall back on this.
+       (if (and (featurep 'xemacs)
+                (memq system-type '(cygwin32 win32 w32 mswindows windows-nt)))
+           ;; This is needed on NT and stuff, because
+           ;; file-name-nondirectory is not enough to split
+           ;; file names, containing ':', e.g.
+           ;; "d:\\Work\\News\\nntp+news.fido7.ru:fido7.ru.gnu.SCORE"
+           ;;
+           ;; we are trying to correctly split such names:
+           ;; "d:file.name" -> "a:" "file.name"
+           ;; "aaa:bbb.ccc" -> "" "aaa:bbb.ccc"
+           ;; "d:aaa\\bbb:ccc"   -> "d:aaa\\" "bbb:ccc"
+           ;; etc.
+           ;; to translate then only the file name part.
+           (progn
+             (setq leaf file
+                   path "")
+             (if (string-match "\\(^\\w:\\|[/\\]\\)\\([^/\\]+\\)$" file)
+                 (setq leaf (substring file (match-beginning 2))
+                       path (substring file 0 (match-beginning 2)))))
+         ;; Emacs DTRT, says andrewi.

          (setq leaf (file-name-nondirectory file)
                path (file-name-directory file))))
       (setq len (length leaf))
          (setq leaf (file-name-nondirectory file)
                path (file-name-directory file))))
       (setq len (length leaf))


@@ -664,17 +780,8 @@ without formatting."
       (apply 'insert format args))
     t))
 
       (apply 'insert format args))
     t))
 

-(defun nnheader-replace-chars-in-string (string from to)
-  "Replace characters in STRING from FROM to TO."
-  (let ((string (substring string 0))  ;Copy string.
-       (len (length string))
-       (idx 0))
-    ;; Replace all occurrences of FROM with TO.
-    (while (< idx len)
-      (when (= (aref string idx) from)
-       (aset string idx to))
-      (setq idx (1+ idx)))
-    string))
+(defsubst nnheader-replace-chars-in-string (string from to)
+  (mm-subst-char-in-string from to string))

 
 (defun nnheader-replace-duplicate-chars-in-string (string from to)
   "Replace characters in STRING from FROM to TO."
 
 (defun nnheader-replace-duplicate-chars-in-string (string from to)
   "Replace characters in STRING from FROM to TO."


@@ -716,7 +823,7 @@ without formatting."
   (or (not (numberp gnus-verbose-backends))
       (<= level gnus-verbose-backends)))
 
   (or (not (numberp gnus-verbose-backends))
       (<= level gnus-verbose-backends)))
 

-(defvar nnheader-pathname-coding-system 'binary
+(defvar nnheader-pathname-coding-system 'iso-8859-1

   "*Coding system for pathname.")
 
 (defun nnheader-group-pathname (group dir &optional file)
   "*Coding system for pathname.")
 
 (defun nnheader-group-pathname (group dir &optional file)


@@ -724,14 +831,14 @@ without formatting."
   (concat
    (let ((dir (file-name-as-directory (expand-file-name dir))))
      ;; If this directory exists, we use it directly.
   (concat
    (let ((dir (file-name-as-directory (expand-file-name dir))))
      ;; If this directory exists, we use it directly.

-     (if (file-directory-p (concat dir group))
-        (concat dir group "/")
-       ;; If not, we translate dots into slashes.
-       (concat dir
-              (mm-encode-coding-string
-               (nnheader-replace-chars-in-string group ?. ?/)
-               nnheader-pathname-coding-system)
-              "/")))
+     (file-name-as-directory
+      (if (file-directory-p (concat dir group))
+         (expand-file-name group dir)
+       ;; If not, we translate dots into slashes.
+       (expand-file-name (mm-encode-coding-string
+                          (nnheader-replace-chars-in-string group ?. ?/)
+                          nnheader-pathname-coding-system)
+                         dir))))

    (cond ((null file) "")
         ((numberp file) (int-to-string file))
         (t file))))
    (cond ((null file) "")
         ((numberp file) (int-to-string file))
         (t file))))


@@ -742,15 +849,13 @@ without formatting."
       (and (listp form) (eq (car form) 'lambda))))
 
 (defun nnheader-concat (dir &rest files)
       (and (listp form) (eq (car form) 'lambda))))
 
 (defun nnheader-concat (dir &rest files)

-  "Concat DIR as directory to FILE."
+  "Concat DIR as directory to FILES."

   (apply 'concat (file-name-as-directory dir) files))
 
 (defun nnheader-ms-strip-cr ()
   "Strip ^M from the end of all lines."
   (save-excursion
   (apply 'concat (file-name-as-directory dir) files))
 
 (defun nnheader-ms-strip-cr ()
   "Strip ^M from the end of all lines."
   (save-excursion

-    (goto-char (point-min))
-    (while (re-search-forward "\r$" nil t)
-      (delete-backward-char 1))))
+    (nnheader-remove-cr-followed-by-lf)))

 
 (defun nnheader-file-size (file)
   "Return the file size of FILE or 0."
 
 (defun nnheader-file-size (file)
   "Return the file size of FILE or 0."


@@ -777,8 +882,9 @@ If FILE, find the \".../etc/PACKAGE\" file instead."
        (setq path (cdr path))))
     result))
 
        (setq path (cdr path))))
     result))
 

-(defvar ange-ftp-path-format)
-(defvar efs-path-regexp)
+(eval-when-compile
+  (defvar ange-ftp-path-format)
+  (defvar efs-path-regexp))

 (defun nnheader-re-read-dir (path)
   "Re-read directory PATH if PATH is on a remote system."
   (if (and (fboundp 'efs-re-read-dir) (boundp 'efs-path-regexp))
 (defun nnheader-re-read-dir (path)
   "Re-read directory PATH if PATH is on a remote system."
   (if (and (fboundp 'efs-re-read-dir) (boundp 'efs-path-regexp))


@@ -800,12 +906,31 @@ find-file-hooks, etc.
   (let ((coding-system-for-read nnheader-file-coding-system))
     (mm-insert-file-contents filename visit beg end replace)))
 
   (let ((coding-system-for-read nnheader-file-coding-system))
     (mm-insert-file-contents filename visit beg end replace)))
 

+(defun nnheader-insert-nov-file (file first)
+  (let ((size (nth 7 (file-attributes file)))
+       (cutoff (* 32 1024)))
+    (if (< size cutoff)
+       ;; If the file is small, we just load it.
+       (nnheader-insert-file-contents file)
+      ;; We start on the assumption that FIRST is pretty recent.  If
+      ;; not, we just insert the rest of the file as well.
+      (let (current)
+       (nnheader-insert-file-contents file nil (- size cutoff) size)
+       (goto-char (point-min))
+       (delete-region (point) (or (search-forward "\n" nil 'move) (point)))
+       (setq current (ignore-errors (read (current-buffer))))
+       (if (and (numberp current)
+                (< current first))
+           t
+         (delete-region (point-min) (point-max))
+         (nnheader-insert-file-contents file))))))
+

 (defun nnheader-find-file-noselect (&rest args)
   (let ((format-alist nil)
        (auto-mode-alist (mm-auto-mode-alist))
        (default-major-mode 'fundamental-mode)
        (enable-local-variables nil)
 (defun nnheader-find-file-noselect (&rest args)
   (let ((format-alist nil)
        (auto-mode-alist (mm-auto-mode-alist))
        (default-major-mode 'fundamental-mode)
        (enable-local-variables nil)

-        (after-insert-file-functions nil)
+       (after-insert-file-functions nil)

        (enable-local-eval nil)
        (find-file-hooks nil)
        (coding-system-for-read nnheader-file-coding-system))
        (enable-local-eval nil)
        (find-file-hooks nil)
        (coding-system-for-read nnheader-file-coding-system))


@@ -852,22 +977,23 @@ find-file-hooks, etc.
      (set-buffer cur)))
 
 (defun nnheader-replace-string (from to)
      (set-buffer cur)))
 
 (defun nnheader-replace-string (from to)

-  "Do a fast replacement of FROM to TO from point to point-max."
+  "Do a fast replacement of FROM to TO from point to `point-max'."

   (nnheader-skeleton-replace from to))
 
 (defun nnheader-replace-regexp (from to)
   (nnheader-skeleton-replace from to))
 
 (defun nnheader-replace-regexp (from to)

-  "Do a fast regexp replacement of FROM to TO from point to point-max."
+  "Do a fast regexp replacement of FROM to TO from point to `point-max'."

   (nnheader-skeleton-replace from to t))
 
 (defun nnheader-strip-cr ()
   "Strip all \r's from the current buffer."
   (nnheader-skeleton-replace "\r"))
 
   (nnheader-skeleton-replace from to t))
 
 (defun nnheader-strip-cr ()
   "Strip all \r's from the current buffer."
   (nnheader-skeleton-replace "\r"))
 

-(fset 'nnheader-run-at-time 'run-at-time)
-(fset 'nnheader-cancel-timer 'cancel-timer)
-(fset 'nnheader-cancel-function-timers 'cancel-function-timers)
+(defalias 'nnheader-run-at-time 'run-at-time)
+(defalias 'nnheader-cancel-timer 'cancel-timer)
+(defalias 'nnheader-cancel-function-timers 'cancel-function-timers)
+(defalias 'nnheader-string-as-multibyte 'string-as-multibyte)

 
 

-(when (string-match "XEmacs\\|Lucid" emacs-version)
+(when (featurep 'xemacs)

   (require 'nnheaderxm))
 
 (run-hooks 'nnheader-load-hook)
   (require 'nnheaderxm))
 
 (run-hooks 'nnheader-load-hook)