;;; nnheader.el --- header access macros for Gnus and its backends
-;; Copyright (C) 1987,88,89,90,93,94,95 Free Software Foundation, Inc.
+;; Copyright (C) 1987,88,89,90,93,94,95,96,97 Free Software Foundation, Inc.
;; Author: Masanobu UMEDA <umerin@flab.flab.fujitsu.junet>
;; Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING. If not, write to
-;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+;; along with GNU Emacs; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
;;; Commentary:
-;; These macros may look very much like the ones in GNUS 4.1. They
+;; These macros may look very much like the ones in GNUS 4.1. They
;; are, in a way, but you should note that the indices they use have
-;; been changed from the internal GNUS format to the NOV format. Makes
-;; it possible to read headers from XOVER much faster.
+;; been changed from the internal GNUS format to the NOV format. The
+;; makes it possible to read headers from XOVER much faster.
;;
;; The format of a header is now:
;; [number subject from date id references chars lines xref]
;;; Code:
-(require 'mail-utils)
-(require 'sendmail)
(eval-when-compile (require 'cl))
+(require 'mail-utils)
+
(defvar nnheader-max-head-length 4096
"*Max length of the head of articles.")
-(defalias 'nntp-header-number 'mail-header-number)
+(defvar nnheader-head-chop-length 2048
+ "*Length of each read operation when trying to fetch HEAD headers.")
+
+(defvar nnheader-file-name-translation-alist nil
+ "*Alist that says how to translate characters in file names.
+For instance, if \":\" is illegal as a file character in file names
+on your system, you could say something like:
+
+\(setq nnheader-file-name-translation-alist '((?: . ?_)))")
+
+(eval-and-compile
+ (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"))
+
+;;; Header access macros.
+
(defmacro mail-header-number (header)
"Return article number in HEADER."
- (` (aref (, header) 0)))
+ `(aref ,header 0))
-(defalias 'nntp-set-header-number 'mail-header-set-number)
(defmacro mail-header-set-number (header number)
"Set article number of HEADER to NUMBER."
- (` (aset (, header) 0 (, number))))
+ `(aset ,header 0 ,number))
-(defalias 'nntp-header-subject 'mail-header-subject)
(defmacro mail-header-subject (header)
"Return subject string in HEADER."
- (` (aref (, header) 1)))
+ `(aref ,header 1))
-(defalias 'nntp-set-header-subject 'mail-header-set-subject)
(defmacro mail-header-set-subject (header subject)
"Set article subject of HEADER to SUBJECT."
- (` (aset (, header) 1 (, subject))))
+ `(aset ,header 1 ,subject))
-(defalias 'nntp-header-from 'mail-header-from)
(defmacro mail-header-from (header)
"Return author string in HEADER."
- (` (aref (, header) 2)))
+ `(aref ,header 2))
-(defalias 'nntp-set-header-from 'mail-header-set-from)
(defmacro mail-header-set-from (header from)
"Set article author of HEADER to FROM."
- (` (aset (, header) 2 (, from))))
+ `(aset ,header 2 ,from))
-(defalias 'nntp-header-date 'mail-header-date)
(defmacro mail-header-date (header)
"Return date in HEADER."
- (` (aref (, header) 3)))
+ `(aref ,header 3))
-(defalias 'nntp-set-header-date 'mail-header-set-date)
(defmacro mail-header-set-date (header date)
"Set article date of HEADER to DATE."
- (` (aset (, header) 3 (, date))))
+ `(aset ,header 3 ,date))
-(defalias 'nntp-header-id 'mail-header-id)
+(defalias 'mail-header-message-id 'mail-header-id)
(defmacro mail-header-id (header)
"Return Id in HEADER."
- (` (aref (, header) 4)))
+ `(aref ,header 4))
-(defalias 'nntp-set-header-id 'mail-header-set-id)
+(defalias 'mail-header-set-message-id 'mail-header-set-id)
(defmacro mail-header-set-id (header id)
"Set article Id of HEADER to ID."
- (` (aset (, header) 4 (, id))))
+ `(aset ,header 4 ,id))
-(defalias 'nntp-header-references 'mail-header-references)
(defmacro mail-header-references (header)
"Return references in HEADER."
- (` (aref (, header) 5)))
+ `(aref ,header 5))
-(defalias 'nntp-set-header-references 'mail-header-set-references)
(defmacro mail-header-set-references (header ref)
"Set article references of HEADER to REF."
- (` (aset (, header) 5 (, ref))))
+ `(aset ,header 5 ,ref))
-(defalias 'nntp-header-chars 'mail-header-chars)
(defmacro mail-header-chars (header)
"Return number of chars of article in HEADER."
- (` (aref (, header) 6)))
+ `(aref ,header 6))
-(defalias 'nntp-set-header-chars 'mail-header-set-chars)
(defmacro mail-header-set-chars (header chars)
"Set number of chars in article of HEADER to CHARS."
- (` (aset (, header) 6 (, chars))))
+ `(aset ,header 6 ,chars))
-(defalias 'nntp-header-lines 'mail-header-lines)
(defmacro mail-header-lines (header)
"Return lines in HEADER."
- (` (aref (, header) 7)))
+ `(aref ,header 7))
-(defalias 'nntp-set-header-lines 'mail-header-set-lines)
(defmacro mail-header-set-lines (header lines)
"Set article lines of HEADER to LINES."
- (` (aset (, header) 7 (, lines))))
+ `(aset ,header 7 ,lines))
-(defalias 'nntp-header-xref 'mail-header-xref)
(defmacro mail-header-xref (header)
"Return xref string in HEADER."
- (` (aref (, header) 8)))
+ `(aref ,header 8))
-(defalias 'nntp-set-header-xref 'mail-header-set-xref)
(defmacro mail-header-set-xref (header xref)
"Set article xref of HEADER to xref."
- (` (aset (, header) 8 (, xref))))
+ `(aset ,header 8 ,xref))
+
+(defun make-mail-header (&optional init)
+ "Create a new mail header structure initialized with INIT."
+ (make-vector 9 init))
+
+(defun make-full-mail-header (&optional number subject from date id
+ references chars lines xref)
+ "Create a new mail header structure initialized with the parameters given."
+ (vector number subject from date id references chars lines xref))
+
+;; fake message-ids: generation and detection
+
+(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-fake-message-id-p (id)
+ (save-match-data ; regular message-id's are <.*>
+ (string-match "\\`fake\\+none\\+[0-9]+\\'" id)))
+
+;; Parsing headers and NOV lines.
+
+(defsubst nnheader-header-value ()
+ (buffer-substring (match-end 0) (gnus-point-at-eol)))
+
+(defun nnheader-parse-head (&optional naked)
+ (let ((case-fold-search t)
+ (cur (current-buffer))
+ (buffer-read-only nil)
+ in-reply-to lines p)
+ (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.
+ (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 "<[^>]+>" in-reply-to))
+ (substring in-reply-to (match-beginning 0)
+ (match-end 0))
+ "")))
+ ;; 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)))))
+ (when naked
+ (goto-char (point-min))
+ (delete-char 1)))))
+
+(defmacro nnheader-nov-skip-field ()
+ '(search-forward "\t" eol 'move))
+
+(defmacro nnheader-nov-field ()
+ '(buffer-substring (point) (if (nnheader-nov-skip-field) (1- (point)) eol)))
+
+(defmacro nnheader-nov-read-integer ()
+ '(prog1
+ (if (= (following-char) ?\t)
+ 0
+ (let ((num (ignore-errors (read (current-buffer)))))
+ (if (numberp num) num 0)))
+ (or (eobp) (forward-char 1))))
+
+;; (defvar nnheader-none-counter 0)
+
+(defun nnheader-parse-nov ()
+ (let ((eol (gnus-point-at-eol)))
+ (vector
+ (nnheader-nov-read-integer) ; number
+ (nnheader-nov-field) ; subject
+ (nnheader-nov-field) ; from
+ (nnheader-nov-field) ; date
+ (or (nnheader-nov-field)
+ (nnheader-generate-fake-message-id)) ; id
+ (nnheader-nov-field) ; refs
+ (nnheader-nov-read-integer) ; chars
+ (nnheader-nov-read-integer) ; lines
+ (if (= (following-char) ?\n)
+ nil
+ (nnheader-nov-field)) ; misc
+ )))
+
+(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) "\t"))
+ (insert "\n"))
+
+(defun nnheader-insert-article-line (article)
+ (goto-char (point-min))
+ (insert "220 ")
+ (princ article (current-buffer))
+ (insert " Article retrieved.\n")
+ (search-forward "\n\n" nil 'move)
+ (delete-region (point) (point-max))
+ (forward-char -1)
+ (insert "."))
+
+(defun nnheader-nov-delete-outside-range (beg end)
+ "Delete all NOV lines that lie outside the BEG to END range."
+ ;; First we find the first wanted line.
+ (nnheader-find-nov-line beg)
+ (delete-region (point-min) (point))
+ ;; Then we find the last wanted line.
+ (when (nnheader-find-nov-line end)
+ (forward-line 1))
+ (delete-region (point) (point-max)))
+
+(defun nnheader-find-nov-line (article)
+ "Put point at the NOV line that start with ARTICLE.
+If ARTICLE doesn't exist, put point where that line
+would have been. The function will return non-nil if
+the line could be found."
+ ;; This function basically does a binary search.
+ (let ((max (point-max))
+ (min (goto-char (point-min)))
+ (cur (current-buffer))
+ (prev (point-min))
+ num found)
+ (while (not found)
+ (goto-char (/ (+ max min) 2))
+ (beginning-of-line)
+ (if (or (= (point) prev)
+ (eobp))
+ (setq found t)
+ (setq prev (point))
+ (while (and (not (numberp (setq num (read cur))))
+ (not (eobp)))
+ (gnus-delete-line))
+ (cond ((> num article)
+ (setq max (point)))
+ ((< num article)
+ (setq min (point)))
+ (t
+ (setq found 'yes)))))
+ ;; We may be at the first line.
+ (when (and (not num)
+ (not (eobp)))
+ (setq num (read cur)))
+ ;; Now we may have found the article we're looking for, or we
+ ;; may be somewhere near it.
+ (when (and (not (eq found 'yes))
+ (not (eq num article)))
+ (setq found (point))
+ (while (and (< (point) max)
+ (or (not (numberp num))
+ (< num article)))
+ (forward-line 1)
+ (setq found (point))
+ (or (eobp)
+ (= (setq num (read cur)) article)))
+ (unless (eq num article)
+ (goto-char found)))
+ (beginning-of-line)
+ (eq num article)))
;; Various cruft the backends and Gnus need to communicate.
(defvar nntp-server-buffer nil)
-(defvar gnus-verbose-backends t
- "*If non-nil, Gnus backends will generate lots of comments.")
+(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 news-reply-yank-from nil)
(defvar news-reply-yank-message-id nil)
-;; All backends use this function, so I moved it to this file.
+(defvar nnheader-callback-function nil)
(defun nnheader-init-server-buffer ()
+ "Initialize the Gnus-backend communication buffer."
(save-excursion
- (setq nntp-server-buffer (get-buffer-create " *nntpd*"))
+ (unless (gnus-buffer-live-p nntp-server-buffer)
+ (setq nntp-server-buffer (get-buffer-create " *nntpd*")))
(set-buffer nntp-server-buffer)
(buffer-disable-undo (current-buffer))
(erase-buffer)
(setq case-fold-search t) ;Should ignore case.
t))
-(defun nnheader-set-init-variables (server defs)
- (let ((s server)
- val)
- ;; First we set the server variables in the sequence required. We
- ;; use the definitions from the `defs' list where that is
- ;; possible.
- (while s
- (set (car (car s))
- (if (setq val (assq (car (car s)) defs))
- (nth 1 val)
- (nth 1 (car s))))
- (setq s (cdr s)))
- ;; The we go through the defs list and set any variables that were
- ;; not set in the first sweep.
- (while defs
- (if (not (assq (car (car defs)) server))
- (set (car (car defs))
- (if (and (symbolp (nth 1 (car defs)))
- (not (boundp (nth 1 (car defs)))))
- (nth 1 (car defs))
- (eval (nth 1 (car defs))))))
- (setq defs (cdr defs)))))
-
-(defun nnheader-save-variables (server)
- (let (out)
- (while server
- (setq out (cons (list (car (car server))
- (symbol-value (car (car server))))
- out))
- (setq server (cdr server)))
- (nreverse out)))
+;;; Various functions the backends use.
-(defun nnheader-restore-variables (state)
- (while state
- (set (car (car state)) (nth 1 (car state)))
- (setq state (cdr state))))
+(defun nnheader-file-error (file)
+ "Return a string that says what is wrong with FILE."
+ (format
+ (cond
+ ((not (file-exists-p file))
+ "%s does not exist")
+ ((file-directory-p file)
+ "%s is a directory")
+ ((not (file-readable-p file))
+ "%s is not readable"))
+ file))
-;; Read the head of an article.
(defun nnheader-insert-head (file)
- (if (eq nnheader-max-head-length t)
- ;; Just read the entire file.
- (nnheader-insert-file-contents-literally file)
- (let ((beg 0)
- (chop 1024))
+ "Insert the head of the article."
+ (when (file-exists-p 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.
- (while (and (eq chop (nth 1 (nnheader-insert-file-contents-literally
- file nil beg (setq beg (+ chop beg)))))
- (prog1 (not (search-backward "\n\n" nil t))
- (goto-char (point-max)))
- (or (null nnheader-max-head-length)
- (< beg nnheader-max-head-length)))))))
+ (let ((beg 0)
+ format-alist)
+ (while (and (eq nnheader-head-chop-length
+ (nth 1 (nnheader-insert-file-contents
+ file nil beg
+ (incf beg nnheader-head-chop-length))))
+ (prog1 (not (search-forward "\n\n" nil t))
+ (goto-char (point-max)))
+ (or (null nnheader-max-head-length)
+ (< beg nnheader-max-head-length))))))
+ t))
(defun nnheader-article-p ()
+ "Say whether the current buffer looks like an article."
(goto-char (point-min))
(if (not (search-forward "\n\n" nil t))
nil
(goto-char (match-end 0)))
(prog1
(eobp)
- (widen))))
-
-;; Written by Erik Naggum <erik@naggum.no>.
-(defun nnheader-insert-file-contents-literally (filename &optional visit beg end replace)
- "Like `insert-file-contents', q.v., but only reads in the file.
-A buffer may be modified in several ways after reading into the buffer due
-to advanced Emacs features, such as file-name-handlers, format decoding,
-find-file-hooks, etc.
- This function ensures that none of these modifications will take place."
- (let ( ; (file-name-handler-alist nil)
- (format-alist nil)
- (after-insert-file-functions nil)
- (find-buffer-file-type-function
- (if (fboundp 'find-buffer-file-type)
- (symbol-function 'find-buffer-file-type)
- nil)))
- (unwind-protect
- (progn
- (fset 'find-buffer-file-type (lambda (filename) t))
- (insert-file-contents filename visit beg end replace))
- (if find-buffer-file-type-function
- (fset 'find-buffer-file-type find-buffer-file-type-function)
- (fmakunbound 'find-buffer-file-type)))))
-
-(defun nnheader-find-file-noselect (filename &optional nowarn rawfile)
- "Read file FILENAME into a buffer and return the buffer.
-If a buffer exists visiting FILENAME, return that one, but
-verify that the file has not changed since visited or saved.
-The buffer is not selected, just returned to the caller."
- (setq filename
- (abbreviate-file-name
- (expand-file-name filename)))
- (if (file-directory-p filename)
- (if find-file-run-dired
- (dired-noselect filename)
- (error "%s is a directory." filename))
- (let* ((buf (get-file-buffer filename))
- (truename (abbreviate-file-name (file-truename filename)))
- (number (nthcdr 10 (file-attributes truename)))
- ;; Find any buffer for a file which has same truename.
- (other (and (not buf)
- (if (fboundp 'find-buffer-visiting)
- (find-buffer-visiting filename)
- (get-file-buffer filename))))
- error)
- ;; Let user know if there is a buffer with the same truename.
- (if other
- (progn
- (or nowarn
- (string-equal filename (buffer-file-name other))
- (message "%s and %s are the same file"
- filename (buffer-file-name other)))
- ;; Optionally also find that buffer.
- (if (or (and (boundp 'find-file-existing-other-name)
- find-file-existing-other-name)
- find-file-visit-truename)
- (setq buf other))))
- (if buf
- (or nowarn
- (verify-visited-file-modtime buf)
- (cond ((not (file-exists-p filename))
- (error "File %s no longer exists!" filename))
- ((yes-or-no-p
- (if (string= (file-name-nondirectory filename)
- (buffer-name buf))
- (format
- (if (buffer-modified-p buf)
- "File %s changed on disk. Discard your edits? "
- "File %s changed on disk. Reread from disk? ")
- (file-name-nondirectory filename))
- (format
- (if (buffer-modified-p buf)
- "File %s changed on disk. Discard your edits in %s? "
- "File %s changed on disk. Reread from disk into %s? ")
- (file-name-nondirectory filename)
- (buffer-name buf))))
- (save-excursion
- (set-buffer buf)
- (revert-buffer t t)))))
- (save-excursion
-;;; The truename stuff makes this obsolete.
-;;; (let* ((link-name (car (file-attributes filename)))
-;;; (linked-buf (and (stringp link-name)
-;;; (get-file-buffer link-name))))
-;;; (if (bufferp linked-buf)
-;;; (message "Symbolic link to file in buffer %s"
-;;; (buffer-name linked-buf))))
- (setq buf (create-file-buffer filename))
- ;; (set-buffer-major-mode buf)
- (set-buffer buf)
- (erase-buffer)
- (if rawfile
- (condition-case ()
- (nnheader-insert-file-contents-literally filename t)
- (file-error
- ;; Unconditionally set error
- (setq error t)))
- (condition-case ()
- (insert-file-contents filename t)
- (file-error
- ;; Run find-file-not-found-hooks until one returns non-nil.
- (or t ; (run-hook-with-args-until-success 'find-file-not-found-hooks)
- ;; If they fail too, set error.
- (setq error t)))))
- ;; Find the file's truename, and maybe use that as visited name.
- (setq buffer-file-truename truename)
- (setq buffer-file-number number)
- ;; On VMS, we may want to remember which directory in a search list
- ;; the file was found in.
- (and (eq system-type 'vax-vms)
- (let (logical)
- (if (string-match ":" (file-name-directory filename))
- (setq logical (substring (file-name-directory filename)
- 0 (match-beginning 0))))
- (not (member logical find-file-not-true-dirname-list)))
- (setq buffer-file-name buffer-file-truename))
- (if find-file-visit-truename
- (setq buffer-file-name
- (setq filename
- (expand-file-name buffer-file-truename))))
- ;; Set buffer's default directory to that of the file.
- (setq default-directory (file-name-directory filename))
- ;; Turn off backup files for certain file names. Since
- ;; this is a permanent local, the major mode won't eliminate it.
- (and (not (funcall backup-enable-predicate buffer-file-name))
- (progn
- (make-local-variable 'backup-inhibited)
- (setq backup-inhibited t)))
- (if rawfile
- nil
- (after-find-file error (not nowarn)))))
- buf)))
+ (widen))))
(defun nnheader-insert-references (references message-id)
- (if (and (not references) (not message-id))
- () ; This is illegal, but not all articles have Message-IDs.
- ;; Fold long references line to follow RFC1036.
- (mail-position-on-field "References")
- (let ((begin (save-excursion (beginning-of-line) (point)))
- (fill-column 78)
- (fill-prefix "\t"))
- (if references (insert references))
- (if (and references message-id) (insert " "))
- (if message-id (insert message-id))
- ;; The region must end with a newline to fill the region
- ;; without inserting extra newline.
- (fill-region-as-paragraph begin (1+ (point))))))
-
-(defun nnheader-remove-header (header &optional is-regexp first)
- "Remove HEADER.
-If FIRST, only remove the first instance if the header.
-Return the number of headers removed."
- (goto-char (point-min))
- (let ((regexp (if is-regexp header (concat "^" header ":")))
- (number 0)
- (case-fold-search t)
- last)
- (while (and (re-search-forward regexp nil t)
- (not last))
- (incf number)
- (when first
- (setq last t))
- (delete-region
- (match-beginning 0)
- ;; There might be a continuation header, so we have to search
- ;; until we find a new non-continuation line.
- (if (re-search-forward "^[^ \t]" nil t)
- (match-beginning 0)
- (point-max))))
- number))
-
-(defun nnheader-set-temp-buffer (name)
+ "Insert a References header based on REFERENCES and MESSAGE-ID."
+ (if (and (not references) (not message-id))
+ () ; This is illegal, but not all articles have Message-IDs.
+ (mail-position-on-field "References")
+ (let ((begin (save-excursion (beginning-of-line) (point)))
+ (fill-column 78)
+ (fill-prefix "\t"))
+ (when references
+ (insert references))
+ (when (and references message-id)
+ (insert " "))
+ (when message-id
+ (insert message-id))
+ ;; Fold long References lines to conform to RFC1036 (sort of).
+ ;; The region must end with a newline to fill the region
+ ;; without inserting extra newline.
+ (fill-region-as-paragraph begin (1+ (point))))))
+
+(defun nnheader-replace-header (header new-value)
+ "Remove HEADER and insert the NEW-VALUE."
+ (save-excursion
+ (save-restriction
+ (nnheader-narrow-to-headers)
+ (prog1
+ (message-remove-header header)
+ (goto-char (point-max))
+ (insert header ": " new-value "\n")))))
+
+(defun nnheader-narrow-to-headers ()
+ "Narrow to the head of an article."
+ (widen)
+ (narrow-to-region
+ (goto-char (point-min))
+ (if (search-forward "\n\n" nil t)
+ (1- (point))
+ (point-max)))
+ (goto-char (point-min)))
+
+(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))
(buffer-disable-undo (current-buffer))
- (erase-buffer))
+ (unless noerase
+ (erase-buffer))
+ (current-buffer))
+
+(defmacro nnheader-temp-write (file &rest forms)
+ "Create a new buffer, evaluate FORMS there, and write the buffer to FILE.
+Return the value of FORMS.
+If FILE is nil, just evaluate FORMS and don't save anything.
+If FILE is t, return the buffer contents as a string."
+ (let ((temp-file (make-symbol "temp-file"))
+ (temp-buffer (make-symbol "temp-buffer"))
+ (temp-results (make-symbol "temp-results")))
+ `(save-excursion
+ (let* ((,temp-file ,file)
+ (default-major-mode 'fundamental-mode)
+ (,temp-buffer
+ (set-buffer
+ (get-buffer-create
+ (generate-new-buffer-name " *nnheader temp*"))))
+ ,temp-results)
+ (unwind-protect
+ (progn
+ (setq ,temp-results (progn ,@forms))
+ (cond
+ ;; Don't save anything.
+ ((null ,temp-file)
+ ,temp-results)
+ ;; Return the buffer contents.
+ ((eq ,temp-file t)
+ (set-buffer ,temp-buffer)
+ (buffer-string))
+ ;; Save a file.
+ (t
+ (set-buffer ,temp-buffer)
+ ;; Make sure the directory where this file is
+ ;; to be saved exists.
+ (when (not (file-directory-p
+ (file-name-directory ,temp-file)))
+ (make-directory (file-name-directory ,temp-file) t))
+ ;; Save the file.
+ (write-region (point-min) (point-max)
+ ,temp-file nil 'nomesg)
+ ,temp-results)))
+ ;; Kill the buffer.
+ (when (buffer-name ,temp-buffer)
+ (kill-buffer ,temp-buffer)))))))
+
+(put 'nnheader-temp-write 'lisp-indent-function 1)
+(put 'nnheader-temp-write 'edebug-form-spec '(form body))
(defvar jka-compr-compression-info-list)
(defvar nnheader-numerical-files
(if (boundp 'jka-compr-compression-info-list)
- (concat "\\([0-9]+\\)\\("
+ (concat "\\([0-9]+\\)\\("
(mapconcat (lambda (i) (aref i 0))
jka-compr-compression-info-list "\\|")
"\\)?")
(defvar nnheader-numerical-full-files (concat "/" nnheader-numerical-files)
"Regexp that matches numerical full file paths.")
-(defun nnheader-file-to-number (file)
+(defsubst nnheader-file-to-number (file)
+ "Take a file name and return the article number."
(if (not (boundp 'jka-compr-compression-info-list))
(string-to-int file)
(string-match nnheader-numerical-short-files file)
- (match-string 1 file)))
+ (string-to-int (match-string 0 file))))
+
+(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.
+ (let ((first (apply 'directory-files args))
+ (second (apply 'directory-files args)))
+ (if (> (length first) (length second))
+ first
+ second)))
(defun nnheader-directory-articles (dir)
+ "Return a list of all article files in a directory."
(mapcar 'nnheader-file-to-number
- (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))
+ (nnheader-directory-files-safe
+ dir nil nnheader-numerical-short-files t)))
+
+(defun nnheader-fold-continuation-lines ()
+ "Fold continuation lines in the current buffer."
+ (nnheader-replace-regexp "\\(\r?\n[ \t]+\\)+" " "))
+
+(defun nnheader-translate-file-chars (file)
+ (if (null nnheader-file-name-translation-alist)
+ ;; No translation is necessary.
+ file
+ ;; We translate -- but only the file name. We leave the directory
+ ;; alone.
+ (let* ((i 0)
+ trans leaf path len)
+ (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.
+ (setq leaf (file-name-nondirectory file)
+ path (file-name-directory file)))
+ (setq len (length leaf))
+ (while (< i len)
+ (when (setq trans (cdr (assq (aref leaf i)
+ nnheader-file-name-translation-alist)))
+ (aset leaf i trans))
+ (incf i))
+ (concat path leaf))))
+
+(defun nnheader-report (backend &rest args)
+ "Report an error from the BACKEND.
+The first string in ARGS can be a format string."
+ (set (intern (format "%s-status-string" backend))
+ (if (< (length args) 2)
+ (car args)
+ (apply 'format args)))
+ nil)
+
+(defun nnheader-get-report (backend)
+ "Get the most recent report from BACKEND."
+ (condition-case ()
+ (message "%s" (symbol-value (intern (format "%s-status-string"
+ backend))))
+ (error (message ""))))
+
+(defun nnheader-insert (format &rest args)
+ "Clear the communication buffer and insert FORMAT and ARGS into the buffer.
+If FORMAT isn't a format string, it and all ARGS will be inserted
+without formatting."
+ (save-excursion
+ (set-buffer nntp-server-buffer)
+ (erase-buffer)
+ (if (string-match "%" format)
+ (insert (apply 'format format args))
+ (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))
+
+(defun nnheader-file-to-group (file &optional top)
+ "Return a group name based on FILE and TOP."
+ (nnheader-replace-chars-in-string
+ (if (not top)
+ file
+ (condition-case ()
+ (substring (expand-file-name file)
+ (length
+ (expand-file-name
+ (file-name-as-directory top))))
+ (error "")))
+ ?/ ?.))
+
+(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)
+ (apply 'format args)))
+
+(defun nnheader-be-verbose (level)
+ "Return whether the backends should be verbose on LEVEL."
+ (or (not (numberp gnus-verbose-backends))
+ (<= level gnus-verbose-backends)))
+
+(defvar nnheader-pathname-coding-system 'iso-8859-1
+ "*Coding system for pathname.")
+
+(defun nnheader-group-pathname (group dir &optional file)
+ "Make pathname for GROUP."
+ (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
+ (gnus-encode-coding-string
+ (nnheader-replace-chars-in-string group ?. ?/)
+ nnheader-pathname-coding-system)
+ "/")))
+ (cond ((null 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 FILE."
+ (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))))
+
+(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."
+ (let ((path load-path)
+ dir result)
+ ;; We try to find the dir by looking at the load path,
+ ;; stripping away the last component and adding "etc/".
+ (while path
+ (if (and (car path)
+ (file-exists-p
+ (setq dir (concat
+ (file-name-directory
+ (directory-file-name (car path)))
+ "etc/" package
+ (if file "" "/"))))
+ (or file (file-directory-p dir)))
+ (setq result dir
+ path nil)
+ (setq path (cdr path))))
+ result))
+
+(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))
+ (when (string-match efs-path-regexp path)
+ (efs-re-read-dir path))
+ (when (and (fboundp 'ange-ftp-re-read-dir) (boundp 'ange-ftp-path-format))
+ (when (string-match (car ange-ftp-path-format) path)
+ (ange-ftp-re-read-dir path)))))
+
+;; 1997/5/4 by MORIOKA Tomohiko <morioka@jaist.ac.jp>
+(defvar nnheader-file-coding-system 'raw-text
+ "Coding system used in file backends of Gnus.")
+
+(defun nnheader-insert-file-contents (filename &optional visit beg end replace)
+ "Like `insert-file-contents', q.v., but only reads in the file.
+A buffer may be modified in several ways after reading into the buffer due
+to advanced Emacs features, such as file-name-handlers, format decoding,
+find-file-hooks, etc.
+ This function ensures that none of these modifications will take place."
+ (let ((format-alist nil)
+ (auto-mode-alist (nnheader-auto-mode-alist))
+ (default-major-mode 'fundamental-mode)
+ (after-insert-file-functions nil)
+ ;; 1997/5/4 by MORIOKA Tomohiko <morioka@jaist.ac.jp>
+ (coding-system-for-read nnheader-file-coding-system))
+ (insert-file-contents filename visit beg end replace)))
+
+(defun nnheader-find-file-noselect (&rest args)
+ (let ((format-alist nil)
+ (auto-mode-alist (nnheader-auto-mode-alist))
+ (default-major-mode 'fundamental-mode)
+ (enable-local-variables nil)
+ (after-insert-file-functions nil)
+ ;; 1997/5/16 by MORIOKA Tomohiko <morioka@jaist.ac.jp>
+ (coding-system-for-read nnheader-file-coding-system))
+ (apply 'find-file-noselect args)))
+
+(defun nnheader-auto-mode-alist ()
+ "Return an `auto-mode-alist' with only the .gz (etc) thingies."
+ (let ((alist auto-mode-alist)
+ out)
+ (while alist
+ (when (listp (cdar alist))
+ (push (car alist) out))
+ (pop alist))
+ (nreverse out)))
+
+(defun nnheader-directory-regular-files (dir)
+ "Return a list of all regular files in DIR."
+ (let ((files (directory-files dir t))
+ out)
+ (while files
+ (when (file-regular-p (car files))
+ (push (car files) out))
+ (pop files))
+ (nreverse out)))
+
+(defun nnheader-directory-files (&rest args)
+ "Same as `directory-files', but prune \".\" and \"..\"."
+ (let ((files (apply 'directory-files args))
+ out)
+ (while files
+ (unless (member (file-name-nondirectory (car files)) '("." ".."))
+ (push (car files) out))
+ (pop files))
+ (nreverse out)))
+
+(defmacro nnheader-skeleton-replace (from &optional to regexp)
+ `(let ((new (generate-new-buffer " *nnheader replace*"))
+ (cur (current-buffer))
+ (start (point-min)))
+ (set-buffer new)
+ (buffer-disable-undo (current-buffer))
+ (set-buffer cur)
+ (goto-char (point-min))
+ (while (,(if regexp 're-search-forward 'search-forward)
+ ,from nil t)
+ (insert-buffer-substring
+ cur start (prog1 (match-beginning 0) (set-buffer new)))
+ (goto-char (point-max))
+ ,(when to `(insert ,to))
+ (set-buffer cur)
+ (setq start (point)))
+ (insert-buffer-substring
+ cur start (prog1 (point-max) (set-buffer new)))
+ (copy-to-buffer cur (point-min) (point-max))
+ (kill-buffer (current-buffer))
+ (set-buffer cur)))
+
+(defun nnheader-replace-string (from to)
+ "Do a fast replacement of FROM to TO from point to point-max."
+ (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."
+ (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)
+
+(when (string-match "XEmacs\\|Lucid" emacs-version)
+ (require 'nnheaderxm))
+
+(run-hooks 'nnheader-load-hook)
(provide 'nnheader)
projects / gnus / blobdiff