;;; nnheader.el --- header access macros for Gnus and its backends
-;; Copyright (C) 1987, 1988, 1989, 1990, 1993, 1994, 1995, 1996,
-;; 1997, 1998, 2000, 2001, 2002
-;; 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>
;; Lars Magne Ingebrigtsen <larsi@gnus.org>
;; 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,
;; 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:
(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.
- ;(eval-when-compile (require 'gnus-util))
+;;(eval-when-compile (require 'gnus-util))
(require 'mail-utils)
(require 'mm-util)
+(require 'gnus-util)
(eval-and-compile
(autoload 'gnus-sorted-intersection "gnus-range")
(autoload 'gnus-intersection "gnus-range")
: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
(defvar nnheader-head-chop-length 2048
"*Length of each read operation when trying to fetch HEAD headers.")
+(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
\(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")
- (autoload 'gnus-point-at-eol "gnus-util")
(autoload 'gnus-buffer-live-p "gnus-util"))
;;; Header access macros.
"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."
- `(aset ,header 9 ',extra))
+ (aset header 9 extra))
(defsubst make-mail-header (&optional init)
"Create a new mail header structure initialized with INIT."
(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 <.*>
- (string-match "\\`fake\\+none\\+[0-9]+\\'" id)))
+ (string-match "\\`fake\\+none\\+.*\\+[0-9]+\\'" id)))
;; Parsing headers and NOV lines.
(defsubst nnheader-header-value ()
(skip-chars-forward " \t")
- (buffer-substring (point) (gnus-point-at-eol)))
+ (buffer-substring (point) (point-at-eol)))
+
+(autoload 'ietf-drums-unfold-fws "ietf-drums")
(defun nnheader-parse-naked-head (&optional number)
;; This function unfolds continuation lines in this buffer
(goto-char p)
(if (search-forward "\nmessage-id:" nil t)
(buffer-substring
- (1- (or (search-forward "<" (gnus-point-at-eol) t)
+ (1- (or (search-forward "<" (point-at-eol) t)
(point)))
- (or (search-forward ">" (gnus-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)))
+ (nnheader-generate-fake-message-id number)))
;; References.
(progn
(goto-char p)
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)
- 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 ()
- (let ((eol (gnus-point-at-eol)))
+ (let ((eol (point-at-eol))
+ (number (nnheader-nov-read-integer)))
(vector
- (nnheader-nov-read-integer) ; number
+ number ; number
(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
(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))
(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)
(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)
- 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
- (nth 1 (nnheader-insert-file-contents
+ (nth 1 (mm-insert-file-contents
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)
- (< 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 ()
;; 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
(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))
(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]+\\)\\("
"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]+$")
- (string-to-int file)
+ (string-to-number 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)
- (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,
;; We translate -- but only the file name. We leave the directory
;; 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.
(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))
- (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)
(<= 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)
- "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.
((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))
"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)
- 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
"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))))
- 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-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))))))
+ (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)
- (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."
"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)
+(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))
(provide 'nnheader)
+;;; arch-tag: a9c4b7d9-52ae-4ec9-b196-dfd93124d202
;;; nnheader.el ends here
projects / gnus / blobdiff