+Sun Sep 6 21:19:26 1998 Lars Magne Ingebrigtsen <larsi@menja.ifi.uio.no>
+
+ * gnus.el: Pterodactyl Gnus v0.17 is released.
+
+1998-09-06 05:45:17 Lars Magne Ingebrigtsen <larsi@gnus.org>
+
+ * time-date.el: Renamed from "date".
+
+ * gnus.el: Removed all timezone dependencies.
+
+ * score-mode.el: Removed.
+ (gnus-score-edit-insert-date): Use date.
+
+ * date.el (float-to-time): New function.
+
+ * nnspool.el (nnspool-seconds-since-epoch): Removed.
+
+ * date.el (time-to-float): New function.
+
+ * message.el (message-make-date): Use format-time-string.
+ (message-make-expires): Use make-date.
+
+ * gnus-xmas.el (gnus-xmas-seconds-since-epoch): Removed.
+
+ * gnus-util.el (gnus-dd-mmm): Use date.
+ (gnus-sortable-date): Ditto.
+
+ * message.el (message-make-date): Take an optional time.
+
+ * gnus: Applied patches from 5.6.43.
+
+ * date.el (if): Use parse-time.
+
+ * gnus-score.el (gnus-summary-score-entry): Make into a command
+ again.
+
+ * gnus-group.el (gnus-group-get-new-news-this-group): Only call if
+ gnus-agent.
+
+ * gnus.el (gnus-agent-meta-information-header): Moved here.
+
+1998-09-05 Mike McEwan <mike@lotusland.demon.co.uk>
+
+ * gnus-agent.el (gnus-agent-scoreable-headers): New variable.
+ (gnus-agent-fetch-group-1): Score article headers using normal
+ group score files if the download score rule of a category/group
+ is `file'.
+ (gnus-agent-fetch-group-1): Don't parse the entire .overview when
+ deciding what articles to download.
+ (gnus-agent-fetch-group-1): Don't push headers through scoring and
+ predicate processing if predicate is `true' or `false'.
+
+1998-09-06 01:56:02 Lars Magne Ingebrigtsen <larsi@gnus.org>
+
+ * gnus-score.el (gnus-score-load-score-alist): Bind coding system.
+
+ * gnus-art.el (gnus-article-setup-buffer): Enable multibyte.
+
+ * score-mode.el (score-mode-coding-system): New variable.
+ (gnus-score-edit-exit): Use it.
+
+1998-09-04 Jason R Mastaler <jason@4b.org>
+
+ * drums.el: Corrected typo.
+
+1998-09-05 23:24:43 Hallvard B. Furuseth <h.b.furuseth@usit.uio.no>
+
+ * mm-bodies.el (mm-body-encoding): Faster version.
+
+1998-09-05 22:23:03 Lars Magne Ingebrigtsen <larsi@gnus.org>
+
+ * gnus-art.el (gnus-article-decode-charset): Only decode text
+ things.
+
+ * message.el (message-output): Use rmail.
+
+ * rfc2047.el (rfc2047-encoded-word-regexp): Allow spaces in the
+ word part.
+
+ * mm-util.el (mm-charset-to-coding-system): Use
+ rfc2047-default-charset.
+ (mm-known-charsets): New variable.
+
+ * message.el (message-caesar-region): Bugged out.
+
Sat Sep 5 21:55:01 1998 Lars Magne Ingebrigtsen <larsi@menja.ifi.uio.no>
* gnus.el: Pterodactyl Gnus v0.16 is released.
;;; Commentary:
-;; DRUMS is and IETF Working Group that works (or worked) on the
+;; DRUMS is an IETF Working Group that works (or worked) on the
;; successor to RFC822, "Standard For The Format Of Arpa Internet Text
;; Messages". This library is based on
;; draft-ietf-drums-msg-fmt-05.txt, released on 1998-08-05.
;;; Code:
-(require 'date)
+(require 'time-date)
(defvar drums-no-ws-ctl-token "\001-\010\013\014\016-\037\177"
"US-ASCII control characters excluding CR, LF and white space.")
(require 'gnus-cache)
(require 'nnvirtual)
(require 'gnus-sum)
-(eval-when-compile (require 'cl))
+(eval-when-compile (require 'cl)
+ (require 'gnus-score))
(defcustom gnus-agent-directory (nnheader-concat gnus-directory "agent/")
"Where the Gnus agent will store its files."
;;; Internal variables
-(defvar gnus-agent-meta-information-header "X-Gnus-Agent-Meta-Information")
-
(defvar gnus-agent-history-buffers nil)
(defvar gnus-agent-buffer-alist nil)
(defvar gnus-agent-article-alist nil)
(defvar gnus-agent-send-mail-function nil)
(defvar gnus-agent-article-file-coding-system 'no-conversion)
+(defconst gnus-agent-scoreable-headers
+ (list
+ "subject" "from" "date" "message-id"
+ "references" "chars" "lines" "xref")
+ "Headers that are considered when scoring articles
+for download via the Agent.")
+
;; Dynamic variables
(defvar gnus-headers)
(defvar gnus-score)
(pop gnus-agent-group-alist))))
(defun gnus-agent-fetch-headers (group &optional force)
- (when (gnus-agent-load-alist group)
- (let ((articles (gnus-uncompress-range
- (cons (1+ (caar (last (gnus-agent-load-alist group))))
- (cdr (gnus-active group))))))
- ;; Fetch them.
- (when articles
- (gnus-message 7 "Fetching headers for %s..." group)
- (save-excursion
- (set-buffer nntp-server-buffer)
- (unless (eq 'nov (gnus-retrieve-headers articles group))
- (nnvirtual-convert-headers))
- ;; Save these headers for later processing.
- (copy-to-buffer gnus-agent-overview-buffer (point-min) (point-max))
- (let (file)
- (when (file-exists-p
- (setq file (gnus-agent-article-name ".overview" group)))
- (gnus-agent-braid-nov group articles file))
- (gnus-make-directory (nnheader-translate-file-chars
- (file-name-directory file)))
- (write-region (point-min) (point-max) file nil 'silent)
- (gnus-agent-save-alist group articles nil)
- (gnus-agent-enter-history
- "last-header-fetched-for-session"
- (list (cons group (nth (- (length articles) 1) articles)))
- (time-to-day (current-time)))
- articles))))))
+ (let ((articles (if (gnus-agent-load-alist group)
+ (gnus-sorted-intersection
+ (gnus-list-of-unread-articles group)
+ (gnus-uncompress-range
+ (cons (1+ (caar (last gnus-agent-article-alist)))
+ (cdr (gnus-active group)))))
+ (gnus-list-of-unread-articles group))))
+ ;; Fetch them.
+ (when articles
+ (gnus-message 7 "Fetching headers for %s..." group)
+ (save-excursion
+ (set-buffer nntp-server-buffer)
+ (unless (eq 'nov (gnus-retrieve-headers articles group))
+ (nnvirtual-convert-headers))
+ ;; Save these headers for later processing.
+ (copy-to-buffer gnus-agent-overview-buffer (point-min) (point-max))
+ (let (file)
+ (when (file-exists-p
+ (setq file (gnus-agent-article-name ".overview" group)))
+ (gnus-agent-braid-nov group articles file))
+ (gnus-make-directory (nnheader-translate-file-chars
+ (file-name-directory file)))
+ (write-region (point-min) (point-max) file nil 'silent)
+ (gnus-agent-save-alist group articles nil)
+ (gnus-agent-enter-history
+ "last-header-fetched-for-session"
+ (list (cons group (nth (- (length articles) 1) articles)))
+ (time-to-day (current-time)))
+ articles)))))
(defsubst gnus-agent-copy-nov-line (article)
(let (b e)
;; Parse them and see which articles we want to fetch.
(setq gnus-newsgroup-dependencies
(make-vector (length articles) 0))
- (setq gnus-newsgroup-headers
- (gnus-get-newsgroup-headers-xover articles nil nil group))
+ ;; No need to call `gnus-get-newsgroup-headers-xover' with
+ ;; the entire .overview for group as we still have the just
+ ;; downloaded headers in `gnus-agent-overview-buffer'.
+ (let ((nntp-server-buffer gnus-agent-overview-buffer))
+ (setq gnus-newsgroup-headers
+ (gnus-get-newsgroup-headers-xover articles nil nil group)))
(setq category (gnus-group-category group))
(setq predicate
(gnus-get-predicate
(or (gnus-group-get-parameter group 'agent-predicate)
(cadr category))))
- (setq score-param
- (or (gnus-group-get-parameter group 'agent-score)
- (caddr category)))
- (when score-param
- (gnus-score-headers (list (list score-param))))
- (setq arts nil)
- (while (setq gnus-headers (pop gnus-newsgroup-headers))
- (setq gnus-score
- (or (cdr (assq (mail-header-number gnus-headers)
- gnus-newsgroup-scored))
- gnus-summary-default-score))
- (when (funcall predicate)
- (push (mail-header-number gnus-headers)
- arts)))
+ ;; Do we want to download everything, or nothing?
+ (if (or (eq (caaddr predicate) 'gnus-agent-true)
+ (eq (caaddr predicate) 'gnus-agent-false))
+ ;; Yes.
+ (setq arts (symbol-value
+ (cadr (assoc (caaddr predicate)
+ '((gnus-agent-true articles)
+ (gnus-agent-false nil))))))
+ ;; No, we need to decide what we want.
+ (setq score-param
+ (let ((score-method (or
+ (gnus-group-get-parameter group 'agent-score t)
+ (caddr category))))
+ (when score-method
+ (require 'gnus-score)
+ (if (eq score-method 'file)
+ (let ((entries
+ (gnus-score-load-files
+ (gnus-all-score-files group)))
+ list score-file)
+ (while (setq list (car entries))
+ (push (car list) score-file)
+ (setq list (cdr list))
+ (while list
+ (when (member (caar list)
+ gnus-agent-scoreable-headers)
+ (push (car list) score-file))
+ (setq list (cdr list)))
+ (setq score-param
+ (append score-param (list (nreverse score-file)))
+ score-file nil entries (cdr entries)))
+ (list score-param))
+ (if (stringp (car score-method))
+ score-method
+ (list (list score-method)))))))
+ (when score-param
+ (gnus-score-headers score-param))
+ (setq arts nil)
+ (while (setq gnus-headers (pop gnus-newsgroup-headers))
+ (setq gnus-score
+ (or (cdr (assq (mail-header-number gnus-headers)
+ gnus-newsgroup-scored))
+ gnus-summary-default-score))
+ (when (funcall predicate)
+ (push (mail-header-number gnus-headers)
+ arts))))
;; Fetch the articles.
(when arts
(gnus-agent-fetch-articles group arts)))
(sort gnus-agent-article-alist 'car-less-than-car))
(let* ((alist gnus-agent-article-alist)
(prev (cons nil alist))
- (first prev))
+ (first prev)
+ expired)
(while (and alist
(<= (caar alist) article))
(if (or (not (cdar alist))
(number-to-string
(caar alist))
group))))
- (setcdr prev (setq alist (cdr alist)))
+ (progn
+ (push (caar alist) expired)
+ (setcdr prev (setq alist (cdr alist))))
(setq prev alist
alist (cdr alist))))
(setq gnus-agent-article-alist (cdr first))
- ;;; Mark all articles up to the first article
- ;;; in `gnus-article-alist' as read.
+ (gnus-agent-save-alist group)
+ ;; Mark all articles up to the first article
+ ;; in `gnus-article-alist' as read.
(when (caar gnus-agent-article-alist)
(setcar (nthcdr 2 info)
(gnus-range-add
(nth 2 info)
(cons 1 (- (caar gnus-agent-article-alist) 1)))))
+ ;; Maybe everything has been expired from `gnus-article-alist'
+ ;; and so the above marking as read could not be conducted,
+ ;; or there are expired article within the range of the alist.
+ (when (or (not (caar gnus-agent-article-alist))
+ (> (car expired) (caar gnus-agent-article-alist)))
+ (setcar (nthcdr 2 info)
+ (gnus-add-to-range
+ (nth 2 info)
+ (nreverse expired))))
(gnus-dribble-enter
(concat "(gnus-group-set-info '"
(gnus-prin1-to-string info)
- ")"))
- (gnus-agent-save-alist group)))
+ ")"))))
expiry-hashtb)
(set-buffer history)
(setq histories (nreverse (sort histories '<)))
(goto-char (point-max))
(widen)
(narrow-to-region (point) (point-max))
- (mm-decode-body
- charset (and cte (intern (downcase (gnus-strip-whitespace cte)))))))))
+ (when (or (not ct)
+ (string-match "text/plain" ct))
+ (mm-decode-body
+ charset (and cte (intern (downcase
+ (gnus-strip-whitespace cte))))))))))
(defalias 'gnus-decode-rfc1522 'article-decode-rfc1522)
(defalias 'gnus-article-decode-rfc1522 'article-decode-rfc1522)
;; Init original article buffer.
(save-excursion
(set-buffer (gnus-get-buffer-create gnus-original-article-buffer))
- (buffer-disable-undo (current-buffer))
+ (mm-enable-multibyte)
(setq major-mode 'gnus-original-article-mode)
(make-local-variable 'gnus-original-article))
(if (get-buffer name)
(defvar gnus-inhibit-demon nil
"*If non-nil, no daemonic function will be run.")
-(eval-and-compile
- (autoload 'timezone-parse-date "timezone")
- (autoload 'timezone-make-arpa-date "timezone"))
-
;;; Functions.
(defun gnus-demon-add-handler (function time idle)
time
(let* ((now (current-time))
;; obtain NOW as discrete components -- make a vector for speed
- (nowParts (apply 'vector (decode-time now)))
+ (nowParts (decode-time now))
;; obtain THEN as discrete components
- (thenParts (timezone-parse-time time))
+ (thenParts (parse-time-string time))
(thenHour (string-to-int (elt thenParts 0)))
(thenMin (string-to-int (elt thenParts 1)))
;; convert time as elements into number of seconds since EPOCH.
(require 'gnus-range)
(require 'gnus-win)
(require 'gnus-undo)
+(require 'time-date)
(defcustom gnus-group-archive-directory
"*ftp@ftp.hpc.uh.edu:/pub/emacs/ding-list/"
(gnus-get-info group) (gnus-active group) t)
(unless (gnus-virtual-group-p group)
(gnus-close-group group))
- (gnus-agent-save-group-info
- method (gnus-group-real-name group) (gnus-active group))
+ (when gnus-agent
+ (gnus-agent-save-group-info
+ method (gnus-group-real-name group) (gnus-active group)))
(gnus-group-update-group group))
(if (eq (gnus-server-status (gnus-find-method-for-group group))
'denied)
;; Stripping headers should be specified with mail-yank-ignored-headers.
(when yank
(gnus-summary-goto-subject (car yank)))
- (let ((gnus-article-reply t)
- (gnus-inhibit-posting-styles t))
+ (let ((gnus-article-reply t))
(gnus-setup-message (if yank 'reply-yank 'reply)
(gnus-summary-select-article)
(set-buffer (gnus-copy-article-buffer))
(?l "lines" nil nil number)
(?d "date" nil nil date)
(?f "followup" nil nil string)
- (?t "thread" nil nil string)))
+ (?t "thread" "message-id" nil string)))
(char-to-type
'((?s s "substring" string)
(?e e "exact string" string)
;; It was a majuscule, so we end reading and use the default.
(if mimic (message "%c %c %c" prefix hchar tchar)
(message ""))
- (setq pchar (or pchar ?p)))
+ (setq pchar (or pchar ?t)))
;; We continue reading.
(while (not pchar)
(defun gnus-summary-score-entry (header match type score date
&optional prompt silent)
+ (interactive)
"Enter score file entry.
HEADER is the header being scored.
MATCH is the string we are looking for.
;; Couldn't read file.
(setq gnus-score-alist nil)
;; Read file.
- (save-excursion
- (gnus-set-work-buffer)
- (insert-file-contents file)
+ (with-temp-buffer
+ (let ((coding-system-for-write score-mode-coding-system))
+ (insert-file-contents file))
(goto-char (point-min))
;; Only do the loading if the score file isn't empty.
(when (save-excursion (re-search-forward "[()0-9a-zA-Z]" nil t))
(delete-file file)
;; There are scores, so we write the file.
(when (file-writable-p file)
- (gnus-write-buffer file)
+ (let ((coding-system-for-write score-mode-coding-system))
+ (gnus-write-buffer file))
(when gnus-score-after-write-file-function
(funcall gnus-score-after-write-file-function file)))))
(and gnus-score-uncacheable-files
(while (re-search-forward
"\\(^[^ \t]+\\)[ \t]+[0-9]+[ \t]+[0-9]+" nil t)
(goto-char (match-end 1))
- (push (cons (match-string 1)
- (max 0 (- (1+ (read cur)) (read cur))))
- groups))))
+ (condition-case ()
+ (push (cons (match-string 1)
+ (max 0 (- (1+ (read cur)) (read cur))))
+ groups)
+ (error nil)))))
(setq groups (sort groups
(lambda (l1 l2)
(string< (car l1) (car l2)))))
(let ((data gnus-newsgroup-data))
(save-excursion
(gnus-save-hidden-threads
+ (gnus-summary-show-all-threads)
(goto-char (point-min))
(while data
(while (get-text-property (point) 'gnus-intangible)
(while thread
(gnus-remove-thread-1 (car thread))
(setq thread (cdr thread))))
+ (gnus-summary-show-all-threads)
(gnus-remove-thread-1 thread))))))))
(defun gnus-remove-thread-1 (thread)
(gnus-kill-buffer buf)))
(setq gnus-current-select-method gnus-select-method)
(pop-to-buffer gnus-group-buffer)
- ;; Clear the current group name.
(if (not quit-config)
(progn
(goto-char group-point)
(gnus-configure-windows 'group 'force))
(gnus-handle-ephemeral-exit quit-config))
+ ;; Clear the current group name.
(unless quit-config
(setq gnus-newsgroup-name nil)))))
lines (count-lines (point-min) (point-max)))
(insert "From: " (read-string "From: ") "\n"
"Subject: " (read-string "Subject: ") "\n"
- "Date: " (timezone-make-date-arpa-standard
- (current-time-string (nth 5 atts))
- (current-time-zone now)
- (current-time-zone now))
+ "Date: " (message-make-date (nth 5 atts))
"\n"
"Message-ID: " (message-make-message-id) "\n"
"Lines: " (int-to-string lines) "\n"
(= mark gnus-read-mark) (= mark gnus-souped-mark)
(= mark gnus-duplicate-mark)))
(setq mark gnus-expirable-mark)
+ ;; Let the backend know about the mark change.
+ (setq mark (gnus-request-update-mark gnus-newsgroup-name article mark))
(push article gnus-newsgroup-expirable))
;; Set the mark in the buffer.
(gnus-summary-update-mark mark 'unread)
"Mark the current article quickly as unread with MARK."
(let* ((article (gnus-summary-article-number))
(old-mark (gnus-summary-article-mark article)))
+ ;; Allow the backend to change the mark.
+ (setq mark (gnus-request-update-mark gnus-newsgroup-name article mark))
(if (eq mark old-mark)
t
(if (<= article 0)
(let* ((mark (or mark gnus-del-mark))
(article (or article (gnus-summary-article-number)))
(old-mark (gnus-summary-article-mark article)))
+ ;; Allow the backend to change the mark.
+ (setq mark (gnus-request-update-mark gnus-newsgroup-name article mark))
(if (eq mark old-mark)
t
(unless article
(eval-when-compile (require 'cl))
(require 'nnheader)
(require 'message)
-(require 'date)
+(require 'time-date)
(eval-and-compile
(autoload 'rmail-insert-rmail-file-header "rmail")
(defun gnus-dd-mmm (messy-date)
"Return a string like DD-MMM from a big messy string."
- (let ((datevec (ignore-errors (timezone-parse-date messy-date))))
- (if (or (not datevec)
- (string-equal "0" (aref datevec 1)))
- "??-???"
- (format "%2s-%s"
- (condition-case ()
- ;; Make sure leading zeroes are stripped.
- (number-to-string (string-to-number (aref datevec 2)))
- (error "??"))
- (capitalize
- (or (car
- (nth (1- (string-to-number (aref datevec 1)))
- timezone-months-assoc))
- "???"))))))
+ (format-time-string "%2d-%b" (date-to-time messy-date)))
(defmacro gnus-date-get-time (date)
"Convert DATE string to Emacs time.
(cons (and (numberp event) event) event)))
(defun gnus-sortable-date (date)
- "Make sortable string by string-lessp from DATE.
-Timezone package is used."
- (condition-case ()
- (progn
- (setq date (inline (timezone-fix-time
- date nil
- (aref (inline (timezone-parse-date date)) 4))))
- (inline
- (timezone-make-sortable-date
- (aref date 0) (aref date 1) (aref date 2)
- (inline
- (timezone-make-time-string
- (aref date 3) (aref date 4) (aref date 5))))))
- (error "")))
+ "Make string suitable for sorting from DATE."
+ (gnus-time-iso8601 (date-to-time date)))
(defun gnus-copy-file (file &optional to)
"Copy FILE to TO."
(event-to-character event))
event)))
-(defun gnus-xmas-seconds-since-epoch (date)
- "Return a floating point number that says how many seconds have lapsed between Jan 1 12:00:00 1970 and DATE."
- (let* ((tdate (mapcar (lambda (ti) (and ti (string-to-int ti)))
- (timezone-parse-date date)))
- (ttime (mapcar (lambda (ti) (and ti (string-to-int ti)))
- (timezone-parse-time
- (aref (timezone-parse-date date) 3))))
- (edate (mapcar (lambda (ti) (and ti (string-to-int ti)))
- (timezone-parse-date "Jan 1 12:00:00 1970")))
- (tday (- (timezone-absolute-from-gregorian
- (nth 1 tdate) (nth 2 tdate) (nth 0 tdate))
- (timezone-absolute-from-gregorian
- (nth 1 edate) (nth 2 edate) (nth 0 edate)))))
- (+ (nth 2 ttime)
- (* (nth 1 ttime) 60)
- (* (float (nth 0 ttime)) 60 60)
- (* (float tday) 60 60 24))))
-
(defun gnus-xmas-define ()
(setq gnus-mouse-2 [button2])
(defvar gnus-mouse-face-prop 'highlight)
- (unless (fboundp 'encode-time)
- (defun encode-time (sec minute hour day month year &optional zone)
- (let ((seconds
- (gnus-xmas-seconds-since-epoch
- (timezone-make-arpa-date
- year month day (timezone-make-time-string hour minute sec)
- zone))))
- (list (floor (/ seconds (expt 2 16)))
- (round (mod seconds (expt 2 16)))))))
-
(defun gnus-byte-code (func)
"Return a form that can be `eval'ed based on FUNC."
(let ((fval (indirect-function func)))
:link '(custom-manual "(gnus)Exiting Gnus")
:group 'gnus)
-(defconst gnus-version-number "0.16"
+(defconst gnus-version-number "0.17"
"Version number for this version of Gnus.")
(defconst gnus-version (format "Pterodactyl Gnus v%s" gnus-version-number)
\f
;;; Internal variables
+(defvar gnus-agent-meta-information-header "X-Gnus-Agent-Meta-Information")
(defvar gnus-group-get-parameter-function 'gnus-group-get-parameter)
(defvar gnus-original-article-buffer " *Original Article*")
(defvar gnus-newsgroup-name nil)
message-send-and-exit message-yank-original)
("nnmail" nnmail-split-fancy nnmail-article-group)
("nnvirtual" nnvirtual-catchup-group nnvirtual-convert-headers)
- ("timezone" timezone-make-date-arpa-standard timezone-fix-time
- timezone-make-sortable-date timezone-make-time-string)
("rmailout" rmail-output)
("rmail" rmail-insert-rmail-file-header rmail-count-new-messages
rmail-show-message rmail-output-to-rmail-file)
gnus-post-news gnus-summary-reply gnus-summary-reply-with-original
gnus-summary-mail-forward gnus-summary-mail-other-window
gnus-summary-resend-message gnus-summary-resend-bounced-mail
- gnus-summary-wide-reply
- gnus-bug)
+ gnus-summary-wide-reply gnus-summary-followup-to-mail
+ gnus-summary-followup-to-mail-with-original gnus-bug)
("gnus-picon" :interactive t gnus-article-display-picons
gnus-group-display-picons gnus-picons-article-display-x-face
gnus-picons-display-x-face)
(require 'mailheader)
(require 'nnheader)
-(require 'timezone)
(require 'easymenu)
(require 'custom)
(if (string-match "XEmacs\\|Lucid" emacs-version)
(autoload 'gnus-point-at-eol "gnus-util")
(autoload 'gnus-point-at-bol "gnus-util")
(autoload 'gnus-output-to-mail "gnus-util")
- (autoload 'gnus-output-to-rmail "gnus-util")
(autoload 'mail-abbrev-in-expansion-header-p "mailabbrev")
(autoload 'nndraft-request-associate-buffer "nndraft")
(autoload 'nndraft-request-expire-articles "nndraft")
;; Then we translate the region. Do it this way to retain
;; text properties.
(while (< b e)
- (subst-char-in-region
- (when (< (char-after b) 255)
+ (when (< (char-after b) 255)
+ (subst-char-in-region
b (1+ b) (char-after b)
(aref message-caesar-translation-table (char-after b))))
(incf b))))
"Append this article to Unix/babyl mail file.."
(if (and (file-readable-p filename)
(mail-file-babyl-p filename))
- (gnus-output-to-rmail filename t)
+ (rmail-output-to-rmail-file filename t)
(gnus-output-to-mail filename t)))
(defun message-cleanup-headers ()
(when (re-search-forward ",+$" nil t)
(replace-match "" t t))))))
-(defun message-make-date ()
- "Make a valid data header."
- (let ((now (current-time)))
- (timezone-make-date-arpa-standard
- (current-time-string now) (current-time-zone now))))
+(defun message-make-date (&optional now)
+ "Make a valid data header.
+If NOW, use that time instead."
+ (format-time-string "%d %b %Y %H:%M:%S %z" (or now (current-time))))
(defun message-make-message-id ()
"Make a unique Message-ID."
;; Add the future to current.
(setcar current (+ (car current) (round (/ future (expt 2 16)))))
(setcar (cdr current) (+ (nth 1 current) (% (round future) (expt 2 16))))
- ;; Return the date in the future in UT.
- (timezone-make-date-arpa-standard
- (current-time-string current) (current-time-zone current) '(0 "UT"))))
+ (message-make-date current)))
(defun message-make-path ()
"Return uucp path."
(widen)
(message-narrow-to-headers)
(goto-char (point-max))
- (mm-insert-rfc822-headers
- (or charset (mm-mule-charset-to-mime-charset 'ascii))
- encoding)
+ (setq charset (or charset (mm-mule-charset-to-mime-charset 'ascii)))
+ ;; We don't insert MIME headers if they only say the default.
+ (unless (and (eq charset 'ascii)
+ (eq encoding '7bit))
+ (mm-insert-rfc822-headers charset encoding))
(mm-encode-body))))))
(run-hooks 'message-load-hook)
;;;!!!above seems to return the wrong result under Emacs 20.3.
;;;!!!Sometimes.
(save-excursion
- (let (found)
- (goto-char (point-min))
- (while (and (not found)
- (not (eobp)))
- (when (> (mm-char-int (following-char)) 127)
- (setq found t))
- (forward-char 1))
- (not found))))
+ (goto-char (point-min))
+ (skip-chars-forward "\0-\177")
+ (eobp)))
'7bit
'8bit))
;;; Code:
+(defvar mm-known-charsets '(iso-8859-1)
+ "List of known charsets.")
+
(defvar mm-mime-mule-charset-alist
'((us-ascii ascii)
(iso-8859-1 latin-iso8859-1)
(cond
;; Running in a non-MULE environment.
((and (null (mm-coding-system-list))
- (eq charset 'iso-8859-1))
+ (memq charset mm-known-charsets))
charset)
;; Check to see whether we can handle this charset.
((memq charset (mm-coding-system-list))
(autoload 'cancel-timer "timer")
(autoload 'telnet "telnet" nil t)
(autoload 'telnet-send-input "telnet" nil t)
- (autoload 'timezone-parse-date "timezone")
(autoload 'gnus-declare-backend "gnus-start"))
;; Declare nndb as derived from nntp
(eval-when-compile (require 'cl))
(require 'nnheader)
-(require 'timezone)
(require 'message)
(require 'custom)
(require 'gnus-util)
(require 'nnheader)
(require 'nntp)
-(require 'timezone)
(require 'nnoo)
(eval-when-compile (require 'cl))
(while (and (not (looking-at
"\\([^ ]+\\) +\\([0-9]+\\)[0-9][0-9][0-9] "))
(zerop (forward-line -1))))
- (let ((seconds (nnspool-seconds-since-epoch date))
+ (let ((seconds (time-to-float (date-to-time date)))
groups)
;; Go through lines and add the latest groups to a list.
(while (and (looking-at "\\([^ ]+\\) +[0-9]+ ")
"Find the path for GROUP."
(nnheader-group-pathname group nnspool-spool-directory article))
-(defun nnspool-seconds-since-epoch (date)
- (let* ((tdate (mapcar (lambda (ti) (and ti (string-to-int ti)))
- (timezone-parse-date date)))
- (ttime (mapcar (lambda (ti) (and ti (string-to-int ti)))
- (timezone-parse-time
- (aref (timezone-parse-date date) 3))))
- (unix (encode-time (nth 2 ttime) (nth 1 ttime) (nth 0 ttime)
- (nth 2 tdate) (nth 1 tdate) (nth 0 tdate)
- (nth 4 tdate))))
- (+ (* (car unix) 65536.0)
- (cadr unix))))
-
(provide 'nnspool)
;;; nnspool.el ends here
(nnoo-declare nntp)
-(eval-and-compile
- (unless (fboundp 'open-network-stream)
- (require 'tcp)))
-
(eval-when-compile (require 'cl))
(defvoo nntp-address nil
;;;
(defvar rfc2047-encoded-word-regexp
- "=\\?\\([^][\000-\040()<>@,\;:\\\"/?.=]+\\)\\?\\(B\\|Q\\)\\?\\([!->@-~]+\\)\\?=")
+ "=\\?\\([^][\000-\040()<>@,\;:\\\"/?.=]+\\)\\?\\(B\\|Q\\)\\?\\([!->@-~ ]+\\)\\?=")
;;;###autoload
(defun rfc2047-decode-region (start end)
;;; Code:
(require 'easymenu)
-(require 'timezone)
(eval-when-compile (require 'cl))
(defvar gnus-score-mode-hook nil
table)
"Syntax table used in score-mode buffers.")
+(defvar score-mode-coding-system 'binary)
+
;;;###autoload
(defun gnus-score-mode ()
"Mode for editing Gnus score files.
(defun gnus-score-edit-insert-date ()
"Insert date in numerical format."
(interactive)
- (princ (gnus-score-day-number (current-time)) (current-buffer)))
+ (princ (time-to-day (current-time)) (current-buffer)))
(defun gnus-score-pretty-print ()
"Format the current score file."
(interactive)
(unless (file-exists-p (file-name-directory (buffer-file-name)))
(make-directory (file-name-directory (buffer-file-name)) t))
- (save-buffer)
+ (let ((coding-system-for-write score-mode-coding-system))
+ (save-buffer))
(bury-buffer (current-buffer))
(let ((buf (current-buffer)))
(when gnus-score-edit-exit-function
(when (eq buf (current-buffer))
(switch-to-buffer (other-buffer (current-buffer))))))
-(defun gnus-score-day-number (time)
- (let ((dat (decode-time time)))
- (timezone-absolute-from-gregorian
- (nth 4 dat) (nth 3 dat) (nth 5 dat))))
-
(provide 'score-mode)
;;; score-mode.el ends here
-;;; date.el --- Date and time handling functions
+;;; time-date.el --- Date and time handling functions
;; Copyright (C) 1998 Free Software Foundation, Inc.
;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
;;; Code:
-(require 'timezone)
-
-(defun parse-time-string (date)
- "Convert DATE into time."
- (decode-time
- (condition-case ()
- (let* ((d1 (timezone-parse-date date))
- (t1 (timezone-parse-time (aref d1 3))))
- (apply 'encode-time
- (mapcar (lambda (el)
- (and el (string-to-number el)))
- (list
- (aref t1 2) (aref t1 1) (aref t1 0)
- (aref d1 2) (aref d1 1) (aref d1 0)
- (number-to-string
- (* 60 (timezone-zone-to-minute (aref d1 4))))))))
- ;; If we get an error, then we just return a 0 time.
- (error (list 0 0)))))
+(eval-and-compile
+ (eval
+ '(if (not (string-match "XEmacs" emacs-version))
+ (require 'parse-time)
+
+ (require 'timezone)
+ (defun parse-time-string (date)
+ "Convert DATE into time."
+ (decode-time
+ (condition-case ()
+ (let* ((d1 (timezone-parse-date date))
+ (t1 (timezone-parse-time (aref d1 3))))
+ (apply 'encode-time
+ (mapcar (lambda (el)
+ (and el (string-to-number el)))
+ (list
+ (aref t1 2) (aref t1 1) (aref t1 0)
+ (aref d1 2) (aref d1 1) (aref d1 0)
+ (number-to-string
+ (* 60 (timezone-zone-to-minute (aref d1 4))))))))
+ ;; If we get an error, then we just return a 0 time.
+ (error (list 0 0))))))))
(defun date-to-time (date)
"Convert DATE into time."
(apply 'encode-time (parse-time-string date)))
+(defun time-to-float (time)
+ "Convert TIME to a floating point number."
+ (+ (* (car time) 65536.0)
+ (cadr time)))
+
+(defun float-to-time (float)
+ "Convert FLOAT (a floating point number) to an Emacs time structure."
+ (list (floor float 65536)
+ (floor (mod float 65536))))
+
(defun time-less-p (t1 t2)
"Say whether time T1 is less than time T2."
(or (< (car t1) (car t2))
(- (/ (1- year) 100)) ; - century years
(/ (1- year) 400)))) ; + Gregorian leap years
-(provide 'date)
+(provide 'time-date)
-;;; date.el ends here
+;;; time-date.el ends here
1998-09-05 17:36:14 Lars Magne Ingebrigtsen <larsi@gnus.org>
* gnus.texi (Sorting Groups): Change.
+ (Various Summary Stuff): Addition.
1998-09-04 00:40:07 David S. Goldberg <dsg@mitre.org>
\input texinfo @c -*-texinfo-*-
@setfilename gnus
-@settitle Pterodactyl Gnus 0.16 Manual
+@settitle Pterodactyl Gnus 0.17 Manual
@synindex fn cp
@synindex vr cp
@synindex pg cp
@tex
@titlepage
-@title Pterodactyl Gnus 0.16 Manual
+@title Pterodactyl Gnus 0.17 Manual
@author by Lars Magne Ingebrigtsen
@page
spool or your mbox file. All at the same time, if you want to push your
luck.
-This manual corresponds to Pterodactyl Gnus 0.16.
+This manual corresponds to Pterodactyl Gnus 0.17.
@end ifinfo
@item gnus-parse-headers-hook
@vindex gnus-parse-headers-hook
-Hook run before parsing any headers. The default value is
-@code{(gnus-decode-rfc1522)}, which means that QPized headers will be
-slightly decoded in a hackish way. This is likely to change in the
-future when Gnus becomes @sc{MIME}ified.
+Hook run before parsing any headers.
@item gnus-alter-header-function
@vindex gnus-alter-header-function
it to, for instance, highlight lines or modify the look of the buffer in
some other ungodly manner. I don't care.
+@vindex gnus-summary-prepared-hook
+@item gnus-summary-prepared-hook
+A hook called as the very last thing after the summary buffer has been
+generated.
+
@vindex gnus-summary-ignore-duplicates
@item gnus-summary-ignore-duplicates
When Gnus discovers two articles that have the same @code{Message-ID},
(signature my-funny-signature-randomizer))
((equal (system-name) "gnarly")
(signature my-quote-randomizer))
- (message-this-is-new
+ (message-this-is-news
(signature my-news-signature))
(posting-from-work-p
(signature-file "~/.work-signature")
@table @emph
@item MIME
-Gnus does no MIME handling, and this standard-to-be seems to think that
-MIME is the bees' knees, so we have major breakage here.
+Gnus does not yet fully handle MIME, and this standard-to-be seems to
+think that MIME is the bees' knees, so we have major breakage here.
@item X-Newsreader
This is considered to be a ``vanity header'', while I consider it to be
for the @code{X-Newsreader} header.
@end table
+@item USEFOR
+@cindex USEFOR
+USEFOR is an IETF working group writing a successor to RFC 1036, based
+on Son-of-RFC 1036. They have produced a number of drafts proposing
+various changes to the format of news articles. The Gnus towers will
+look into implementing the changes when the draft is accepted as an RFC.
+
@end table
If you ever notice Gnus acting non-compliant with regards to the texts
@itemize @bullet
@item
-Emacs 19.32 and up.
-
-@item
-XEmacs 19.14 and up.
+Emacs 20.2 and up.
@item
-Mule versions based on Emacs 19.32 and up.
+XEmacs 20.4 and up.
@end itemize
\input texinfo @c -*-texinfo-*-
@setfilename message
-@settitle Pterodactyl Message 0.16 Manual
+@settitle Pterodactyl Message 0.17 Manual
@synindex fn cp
@synindex vr cp
@synindex pg cp
@tex
@titlepage
-@title Pterodactyl Message 0.16 Manual
+@title Pterodactyl Message 0.17 Manual
@author by Lars Magne Ingebrigtsen
@page
* Key Index:: List of Message mode keys.
@end menu
-This manual corresponds to Pterodactyl Message 0.16. Message is
+This manual corresponds to Pterodactyl Message 0.17. Message is
distributed with the Gnus distribution bearing the same version number
as this manual has.
projects / gnus / commitdiff