Merge from emacs--devo--0, emacs--rel--22

[gnus] / lisp / nnheader.el

diff --git a/lisp/nnheader.el b/lisp/nnheader.el
index ec17496..11cb4bf 100644 (file)
--- a/lisp/nnheader.el
+++ b/lisp/nnheader.el
@@ -1,18 +1,18 @@
 ;;; nnheader.el --- header access macros for Gnus and its backends
 
 ;;; nnheader.el --- header access macros for Gnus and its backends
 

-;; Copyright (C) 1987, 1988, 1989, 1990, 1993, 1994, 1995, 1996,
-;;        1997, 1998, 2000, 2001
-;;        Free Software Foundation, Inc.
+;; Copyright (C) 1987, 1988, 1989, 1990, 1993, 1994,
+;;   1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003,
+;;   2004, 2005, 2006, 2007 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.
 
 ;; GNU Emacs is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
 ;; Keywords: news
 
 ;; This file is part of GNU Emacs.
 
 ;; GNU Emacs is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by

-;; the Free Software Foundation; either version 2, or (at your option)
+;; the Free Software Foundation; either version 3, or (at your option)

 ;; any later version.
 
 ;; GNU Emacs is distributed in the hope that it will be useful,
 ;; any later version.
 
 ;; GNU Emacs is distributed in the hope that it will be useful,


@@ -22,8 +22,8 @@
 
 ;; 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
 
 ;; 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, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.

 
 ;;; Commentary:
 
 
 ;;; Commentary:
 


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

+(defvar nnmail-extra-headers)
+(defvar gnus-newsgroup-name)
+(defvar nnheader-file-coding-system)
+(defvar jka-compr-compression-info-list)
+

 ;; Requiring `gnus-util' at compile time creates a circular
 ;; dependency between nnheader.el and gnus-util.el.
 ;; Requiring `gnus-util' at compile time creates a circular
 ;; dependency between nnheader.el and gnus-util.el.

-                            ;(eval-when-compile (require 'gnus-util))
+;;(eval-when-compile (require 'gnus-util))

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

+(require 'gnus-util)

 (eval-and-compile
   (autoload 'gnus-sorted-intersection "gnus-range")
   (autoload 'gnus-intersection "gnus-range")
 (eval-and-compile
   (autoload 'gnus-sorted-intersection "gnus-range")
   (autoload 'gnus-intersection "gnus-range")

-  (autoload 'gnus-sorted-complement "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.
 
 (defcustom gnus-verbose-backends 7
   "Integer that says how verbose the Gnus backends should be.


@@ -56,7 +63,7 @@ they will keep on jabbering all the time."
   :group 'gnus-server
   :type 'boolean)
 
   :group 'gnus-server
   :type 'boolean)
 

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

   "*Max length of the head of articles.
 
 Value is an integer, nil, or t.  nil means read in chunks of a file
   "*Max length of the head of articles.
 
 Value is an integer, nil, or t.  nil means read in chunks of a file


@@ -69,18 +76,48 @@ Integer values will in effect be rounded up to the nearest multiple of
 (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-read-timeout
+  (if (string-match "windows-nt\\|os/2\\|emx\\|cygwin"
+                   (symbol-name system-type))
+      ;; http://thread.gmane.org/v9655t3pjo.fsf@marauder.physik.uni-ulm.de
+      ;;
+      ;; IIRC, values lower than 1.0 didn't/don't work on Windows/DOS.
+      ;;
+      ;; There should probably be a runtime test to determine the timing
+      ;; resolution, or a primitive to report it.  I don't know off-hand
+      ;; what's possible.  Perhaps better, maybe the Windows/DOS primitive
+      ;; could round up non-zero timeouts to a minimum of 1.0?
+      1.0
+    0.1)
+  "How long nntp should wait between checking for the end of output.
+Shorter values mean quicker response, but are more CPU intensive.")
+
+(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:
 
 \(setq nnheader-file-name-translation-alist '((?: . ?_)))")
 
   "*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:
 
 \(setq nnheader-file-name-translation-alist '((?: . ?_)))")
 

+(defvar nnheader-directory-separator-character
+  (string-to-char (substring (file-name-as-directory ".") -1))
+  "*A character used to a directory separator.")
+

 (eval-and-compile
   (autoload 'nnmail-message-id "nnmail")
   (autoload 'mail-position-on-field "sendmail")
   (autoload 'message-remove-header "message")
 (eval-and-compile
   (autoload 'nnmail-message-id "nnmail")
   (autoload 'mail-position-on-field "sendmail")
   (autoload 'message-remove-header "message")

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

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


@@ -174,9 +211,9 @@ on your system, you could say something like:
   "Return the extra headers in HEADER."
   `(aref ,header 9))
 
   "Return the extra headers in HEADER."
   `(aref ,header 9))
 

-(defmacro mail-header-set-extra (header extra)
+(defun mail-header-set-extra (header extra)

   "Set the extra headers in HEADER to EXTRA."
   "Set the extra headers in HEADER to EXTRA."

-  `(aset ,header 9 ',extra))
+  (aset header 9 extra))

 
 (defsubst make-mail-header (&optional init)
   "Create a new mail header structure initialized with INIT."
 
 (defsubst make-mail-header (&optional init)
   "Create a new mail header structure initialized with INIT."


@@ -192,129 +229,148 @@ on your system, you could say something like:
 
 (defvar nnheader-fake-message-id 1)
 
 
 (defvar nnheader-fake-message-id 1)
 

-(defsubst nnheader-generate-fake-message-id ()
-  (concat "fake+none+" (int-to-string (incf nnheader-fake-message-id))))
+(defsubst nnheader-generate-fake-message-id (&optional number)
+  (if (numberp number)
+      (format "fake+none+%s+%d" gnus-newsgroup-name number)
+    (format "fake+none+%s+%s"
+           gnus-newsgroup-name
+           (int-to-string (incf nnheader-fake-message-id)))))

 
 (defsubst nnheader-fake-message-id-p (id)
   (save-match-data                    ; regular message-id's are <.*>
 
 (defsubst nnheader-fake-message-id-p (id)
   (save-match-data                    ; regular message-id's are <.*>

-    (string-match "\\`fake\\+none\\+[0-9]+\\'" id)))
+    (string-match "\\`fake\\+none\\+.*\\+[0-9]+\\'" id)))

 
 ;; Parsing headers and NOV lines.
 
 
 ;; 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 ()
   (skip-chars-forward " \t")
 (defsubst nnheader-header-value ()
   (skip-chars-forward " \t")

-  (buffer-substring (point) (gnus-point-at-eol)))
+  (buffer-substring (point) (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 "<" (point-at-eol) t)
+                       (point)))
+               (or (search-forward ">" (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 number)))
+        ;; 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))


@@ -342,20 +398,29 @@ on your system, you could say something like:
               out)))
      out))
 
               out)))
      out))
 

-(defmacro nnheader-nov-read-message-id ()
-  '(let ((id (nnheader-nov-field)))
+(eval-and-compile
+  (defvar nnheader-uniquify-message-id nil))
+
+(defmacro nnheader-nov-read-message-id (&optional number)
+  `(let ((id (nnheader-nov-field)))

      (if (string-match "^<[^>]+>$" id)
      (if (string-match "^<[^>]+>$" id)

-        id
-       (nnheader-generate-fake-message-id))))
+        ,(if nnheader-uniquify-message-id
+             `(if (string-match "__[^@]+@" id)
+                  (concat (substring id 0 (match-beginning 0))
+                          (substring id (1- (match-end 0))))
+                id)
+           'id)
+       (nnheader-generate-fake-message-id ,number))))

 
 (defun nnheader-parse-nov ()
 
 (defun nnheader-parse-nov ()

-  (let ((eol (gnus-point-at-eol)))
+  (let ((eol (point-at-eol))
+       (number (nnheader-nov-read-integer)))

     (vector
     (vector

-     (nnheader-nov-read-integer)       ; number
+     number                            ; number

      (nnheader-nov-field)              ; subject
      (nnheader-nov-field)              ; from
      (nnheader-nov-field)              ; date
      (nnheader-nov-field)              ; subject
      (nnheader-nov-field)              ; from
      (nnheader-nov-field)              ; date

-     (nnheader-nov-read-message-id)    ; id
+     (nnheader-nov-read-message-id number) ; id

      (nnheader-nov-field)              ; refs
      (nnheader-nov-read-integer)       ; chars
      (nnheader-nov-read-integer)       ; lines
      (nnheader-nov-field)              ; refs
      (nnheader-nov-read-integer)       ; chars
      (nnheader-nov-read-integer)       ; lines


@@ -399,6 +464,22 @@ on your system, you could say something like:
       (delete-char 1))
     (forward-line 1)))
 
       (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
    "Subject: " (or (mail-header-subject header) "(none)") "\n"
 (defun nnheader-insert-header (header)
   (insert
    "Subject: " (or (mail-header-subject header) "(none)") "\n"


@@ -442,7 +523,7 @@ the line could be found."
        (prev (point-min))
        num found)
     (while (not found)
        (prev (point-min))
        num found)
     (while (not found)

-      (goto-char (/ (+ max min) 2))
+      (goto-char (+ min (/ (- max min) 2)))

       (beginning-of-line)
       (if (or (= (point) prev)
              (eobp))
       (beginning-of-line)
       (if (or (= (point) prev)
              (eobp))


@@ -450,8 +531,7 @@ 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)))

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

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


@@ -521,17 +601,27 @@ the line could be found."
     (if (eq nnheader-max-head-length t)
        ;; Just read the entire file.
        (nnheader-insert-file-contents file)
     (if (eq nnheader-max-head-length t)
        ;; Just read the entire file.
        (nnheader-insert-file-contents file)

-      ;; Read 1K blocks until we find a separator.
+      ;; Read blocks of the size specified by `nnheader-head-chop-length'
+      ;; until we find a separator.

       (let ((beg 0)
       (let ((beg 0)

-           format-alist)
+           (start (point))
+           ;; Use `binary' to prevent the contents from being decoded,
+           ;; or it will change the number of characters that
+           ;; `insert-file-contents' returns.
+           (coding-system-for-read 'binary))

        (while (and (eq nnheader-head-chop-length
        (while (and (eq nnheader-head-chop-length

-                       (nth 1 (nnheader-insert-file-contents
+                       (nth 1 (mm-insert-file-contents

                                file nil beg
                                (incf beg nnheader-head-chop-length))))
                                file nil beg
                                (incf beg nnheader-head-chop-length))))

-                   (prog1 (not (search-forward "\n\n" nil t))
+                   ;; CRLF or CR might be used for the line-break code.
+                   (prog1 (not (re-search-forward "\n\r?\n\\|\r\r" nil t))

                      (goto-char (point-max)))
                    (or (null nnheader-max-head-length)
                      (goto-char (point-max)))
                    (or (null nnheader-max-head-length)

-                       (< beg nnheader-max-head-length))))))
+                       (< beg nnheader-max-head-length))))
+       ;; Finally decode the contents.
+       (when (mm-coding-system-p nnheader-file-coding-system)
+         (mm-decode-coding-region start (point-max)
+                                  nnheader-file-coding-system))))

     t))
 
 (defun nnheader-article-p ()
     t))
 
 (defun nnheader-article-p ()


@@ -553,7 +643,7 @@ the line could be found."
       ;; This is invalid, but not all articles have Message-IDs.
       ()
     (mail-position-on-field "References")
       ;; This is invalid, but not all articles have Message-IDs.
       ()
     (mail-position-on-field "References")

-    (let ((begin (save-excursion (beginning-of-line) (point)))
+    (let ((begin (point-at-bol))

          (fill-column 78)
          (fill-prefix "\t"))
       (when references
          (fill-column 78)
          (fill-prefix "\t"))
       (when references


@@ -587,6 +677,20 @@ the line could be found."
      (point-max)))
   (goto-char (point-min)))
 
      (point-max)))
   (goto-char (point-min)))
 

+(defun nnheader-get-lines-and-char ()
+  "Return the number of lines and chars in the article body."
+  (goto-char (point-min))
+  (if (not (re-search-forward "\n\r?\n" nil t))
+      (list 0 0)
+    (list (count-lines (point) (point-max))
+         (- (point-max) (point)))))
+
+(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))


@@ -595,7 +699,6 @@ the line could be found."
     (erase-buffer))
   (current-buffer))
 
     (erase-buffer))
   (current-buffer))
 

-(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]+\\)\\("


@@ -609,19 +712,18 @@ the line could be found."
   "Regexp that matches numerical file names.")
 
 (defvar nnheader-numerical-full-files (concat "/" nnheader-numerical-files)
   "Regexp that matches numerical file names.")
 
 (defvar nnheader-numerical-full-files (concat "/" nnheader-numerical-files)

-  "Regexp that matches numerical full file paths.")
+  "Regexp that matches numerical full file names.")

 
 (defsubst nnheader-file-to-number (file)
   "Take a FILE name and return the article number."
   (if (string= nnheader-numerical-short-files "^[0-9]+$")
 
 (defsubst nnheader-file-to-number (file)
   "Take a FILE name and return the article number."
   (if (string= nnheader-numerical-short-files "^[0-9]+$")

-      (string-to-int file)
+      (string-to-number file)

     (string-match nnheader-numerical-short-files file)
     (string-match nnheader-numerical-short-files file)

-    (string-to-int (match-string 0 file))))
+    (string-to-number (match-string 0 file))))

 
 (defvar nnheader-directory-files-is-safe
   (or (eq system-type 'windows-nt)
 
 (defvar nnheader-directory-files-is-safe
   (or (eq system-type 'windows-nt)

-      (and (not (featurep 'xemacs))
-          (> emacs-major-version 20)))
+      (not (featurep 'xemacs)))

   "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,
   "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,


@@ -671,10 +773,11 @@ If FULL, translate everything."
                path ""
                i (if (and (< 1 (length leaf)) (eq ?: (aref leaf 1)))
                      2 0))
                path ""
                i (if (and (< 1 (length leaf)) (eq ?: (aref leaf 1)))
                      2 0))

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

        ;; alone.
        (if (and (featurep 'xemacs)
        ;; alone.
        (if (and (featurep 'xemacs)

-                (memq system-type '(cygwin32 win32 w32 mswindows windows-nt)))
+                (memq system-type '(cygwin32 win32 w32 mswindows windows-nt
+                                             cygwin)))

            ;; This is needed on NT and stuff, because
            ;; file-name-nondirectory is not enough to split
            ;; file names, containing ':', e.g.
            ;; This is needed on NT and stuff, because
            ;; file-name-nondirectory is not enough to split
            ;; file names, containing ':', e.g.


@@ -760,13 +863,15 @@ without formatting."
                     (expand-file-name
                      (file-name-as-directory top))))
        (error "")))
                     (expand-file-name
                      (file-name-as-directory top))))
        (error "")))

-   ?/ ?.))
+   nnheader-directory-separator-character ?.))

 
 (defun nnheader-message (level &rest args)
   "Message if the Gnus backends are talkative."
   (if (or (not (numberp gnus-verbose-backends))
          (<= level gnus-verbose-backends))
 
 (defun nnheader-message (level &rest args)
   "Message if the Gnus backends are talkative."
   (if (or (not (numberp gnus-verbose-backends))
          (<= level gnus-verbose-backends))

-      (apply 'message args)
+      (if gnus-add-timestamp-to-message
+         (apply 'gnus-message-with-timestamp args)
+       (apply 'message args))

     (apply 'format args)))
 
 (defun nnheader-be-verbose (level)
     (apply 'format args)))
 
 (defun nnheader-be-verbose (level)


@@ -775,10 +880,10 @@ without formatting."
       (<= level gnus-verbose-backends)))
 
 (defvar nnheader-pathname-coding-system 'iso-8859-1
       (<= level gnus-verbose-backends)))
 
 (defvar nnheader-pathname-coding-system 'iso-8859-1

-  "*Coding system for pathname.")
+  "*Coding system for file name.")

 
 (defun nnheader-group-pathname (group dir &optional file)
 
 (defun nnheader-group-pathname (group dir &optional file)

-  "Make pathname for GROUP."
+  "Make file name for GROUP."

   (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.


@@ -794,11 +899,6 @@ without formatting."
         ((numberp file) (int-to-string file))
         (t file))))
 
         ((numberp file) (int-to-string file))
         (t file))))
 

-(defun nnheader-functionp (form)
-  "Return non-nil if FORM is funcallable."
-  (or (and (symbolp form) (fboundp form))
-      (and (listp form) (eq (car form) 'lambda))))
-

 (defun nnheader-concat (dir &rest files)
   "Concat DIR as directory to FILES."
   (apply 'concat (file-name-as-directory dir) files))
 (defun nnheader-concat (dir &rest files)
   "Concat DIR as directory to FILES."
   (apply 'concat (file-name-as-directory dir) files))


@@ -806,19 +906,21 @@ without formatting."
 (defun nnheader-ms-strip-cr ()
   "Strip ^M from the end of all lines."
   (save-excursion
 (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."
   (or (nth 7 (file-attributes file)) 0))
 
 
 (defun nnheader-file-size (file)
   "Return the file size of FILE or 0."
   (or (nth 7 (file-attributes file)) 0))
 

-(defun nnheader-find-etc-directory (package &optional file)
-  "Go through the path and find the \".../etc/PACKAGE\" directory.
-If FILE, find the \".../etc/PACKAGE\" file instead."
+(defun nnheader-find-etc-directory (package &optional file first)
+  "Go through `load-path' and find the \"../etc/PACKAGE\" directory.
+This function will look in the parent directory of each `load-path'
+entry, and look for the \"etc\" directory there.
+If FILE, find the \".../etc/PACKAGE\" file instead.
+If FIRST is non-nil, return the directory or the file found at the
+first.  Otherwise, find the newest one, though it may take a time."

   (let ((path load-path)
   (let ((path load-path)

-       dir result)
+       dir results)

     ;; We try to find the dir by looking at the load path,
     ;; stripping away the last component and adding "etc/".
     (while path
     ;; We try to find the dir by looking at the load path,
     ;; stripping away the last component and adding "etc/".
     (while path


@@ -830,14 +932,17 @@ If FILE, find the \".../etc/PACKAGE\" file instead."
                           "etc/" package
                           (if file "" "/"))))
               (or file (file-directory-p dir)))
                           "etc/" package
                           (if file "" "/"))))
               (or file (file-directory-p dir)))

-         (setq result dir
-               path nil)
+         (progn
+           (or (member dir results)
+               (push dir results))
+           (setq path (if first nil (cdr path))))

        (setq path (cdr path))))
        (setq path (cdr path))))

-    result))
+    (if (or first (not (cdr results)))
+       (car results)
+      (car (sort results 'file-newer-than-file-p)))))

 
 

-(eval-when-compile
-  (defvar ange-ftp-path-format)
-  (defvar efs-path-regexp))
+(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))


@@ -859,16 +964,45 @@ 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)))
+    (when size
+      (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)
 (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)
-       (enable-local-eval nil)
-       (find-file-hooks nil)
-       (coding-system-for-read nnheader-file-coding-system))
-    (apply 'find-file-noselect args)))
+  "Open a file with some variables bound.
+See `find-file-noselect' for the arguments."
+  (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)
+        (enable-local-eval nil)
+        (coding-system-for-read nnheader-file-coding-system)
+        (version-control 'never)
+        (ffh (if (boundp 'find-file-hook)
+                 'find-file-hook
+               'find-file-hooks))
+        (val (symbol-value ffh)))
+    (set ffh nil)
+    (unwind-protect
+       (apply 'find-file-noselect args)
+      (set ffh val))))

 
 (defun nnheader-directory-regular-files (dir)
   "Return a list of all regular files in DIR."
 
 (defun nnheader-directory-regular-files (dir)
   "Return a list of all regular files in DIR."


@@ -922,11 +1056,18 @@ find-file-hooks, etc.
   "Strip all \r's from the current buffer."
   (nnheader-skeleton-replace "\r"))
 
   "Strip all \r's from the current buffer."
   (nnheader-skeleton-replace "\r"))
 

-(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)
 
 (defalias 'nnheader-cancel-timer 'cancel-timer)
 (defalias 'nnheader-cancel-function-timers 'cancel-function-timers)
 (defalias 'nnheader-string-as-multibyte 'string-as-multibyte)
 

+(defun nnheader-accept-process-output (process)
+  (accept-process-output
+   process
+   (truncate nnheader-read-timeout)
+   (truncate (* (- nnheader-read-timeout
+                  (truncate nnheader-read-timeout))
+               1000))))
+

 (when (featurep 'xemacs)
   (require 'nnheaderxm))
 
 (when (featurep 'xemacs)
   (require 'nnheaderxm))
 


@@ -934,4 +1075,5 @@ find-file-hooks, etc.
 
 (provide 'nnheader)
 
 
 (provide 'nnheader)
 

+;;; arch-tag: a9c4b7d9-52ae-4ec9-b196-dfd93124d202

 ;;; nnheader.el ends here
 ;;; nnheader.el ends here