;;; gnus-start.el --- startup functions for Gnus
-;; Copyright (C) 1996 Free Software Foundation, Inc.
+;; Copyright (C) 1996,97,98 Free Software Foundation, Inc.
;; Author: Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
;; Keywords: news
;;; Code:
-(require 'gnus-load)
(require 'gnus)
(require 'gnus-win)
(require 'gnus-int)
(require 'gnus-spec)
(require 'gnus-range)
+(require 'gnus-util)
(require 'message)
-
-(defvar gnus-startup-file "~/.newsrc"
- "*Your `.newsrc' file.
-`.newsrc-SERVER' will be used instead if that exists.")
-
-(defvar gnus-init-file "~/.gnus"
- "*Your Gnus elisp startup file.
-If a file with the .el or .elc suffixes exist, it will be read
-instead.")
-
-(defvar gnus-site-init-file
- (condition-case ()
- (concat (file-name-directory
+(eval-when-compile (require 'cl))
+
+(defcustom gnus-startup-file (nnheader-concat gnus-home-directory ".newsrc")
+ "Your `.newsrc' file.
+`.newsrc-SERVER' will be used instead if that exists."
+ :group 'gnus-start
+ :type 'file)
+
+(defcustom gnus-init-file (nnheader-concat gnus-home-directory ".gnus")
+ "Your Gnus Emacs-Lisp startup file name.
+If a file with the `.el' or `.elc' suffixes exists, it will be read instead."
+ :group 'gnus-start
+ :type 'file)
+
+(defcustom gnus-site-init-file
+ (condition-case nil
+ (concat (file-name-directory
(directory-file-name installation-directory))
"site-lisp/gnus-init")
(error nil))
- "*The site-wide Gnus elisp startup file.
-If a file with the .el or .elc suffixes exist, it will be read
-instead.")
-
-(defvar gnus-default-subscribed-newsgroups nil
- "*This variable lists what newsgroups should be subscribed the first time Gnus is used.
-It should be a list of strings.
-If it is `t', Gnus will not do anything special the first time it is
-started; it'll just use the normal newsgroups subscription methods.")
-
-(defvar gnus-use-dribble-file t
+ "*The site-wide Gnus Emacs-Lisp startup file name, or nil if none.
+If a file with the `.el' or `.elc' suffixes exists, it will be read instead."
+ :group 'gnus-start
+ :type '(choice file (const nil)))
+
+(defcustom gnus-default-subscribed-newsgroups nil
+ "List of newsgroups to subscribe, when a user runs Gnus the first time.
+The value should be a list of strings.
+If it is t, Gnus will not do anything special the first time it is
+started; it'll just use the normal newsgroups subscription methods."
+ :group 'gnus-start
+ :type '(choice (repeat string) (const :tag "Nothing special" t)))
+
+(defcustom gnus-use-dribble-file t
"*Non-nil means that Gnus will use a dribble file to store user updates.
If Emacs should crash without saving the .newsrc files, complete
-information can be restored from the dribble file.")
+information can be restored from the dribble file."
+ :group 'gnus-dribble-file
+ :type 'boolean)
-(defvar gnus-dribble-directory nil
+(defcustom gnus-dribble-directory nil
"*The directory where dribble files will be saved.
If this variable is nil, the directory where the .newsrc files are
-saved will be used.")
+saved will be used."
+ :group 'gnus-dribble-file
+ :type '(choice directory (const nil)))
-(defvar gnus-check-new-newsgroups t
- "*Non-nil means that Gnus will run gnus-find-new-newsgroups at startup.
+(defcustom gnus-check-new-newsgroups 'ask-server
+ "*Non-nil means that Gnus will run `gnus-find-new-newsgroups' at startup.
This normally finds new newsgroups by comparing the active groups the
servers have already reported with those Gnus already knows, either alive
or killed.
-When any of the following are true, gnus-find-new-newsgroups will instead
+When any of the following are true, `gnus-find-new-newsgroups' will instead
ask the servers (primary, secondary, and archive servers) to list new
groups since the last time it checked:
1. This variable is `ask-server'.
2. This variable is a list of select methods (see below).
3. `gnus-read-active-file' is nil or `some'.
- 4. A prefix argument is given to gnus-find-new-newsgroups interactively.
+ 4. A prefix argument is given to `gnus-find-new-newsgroups' interactively.
Thus, if this variable is `ask-server' or a list of select methods or
`gnus-read-active-file' is nil or `some', then the killed list is no
'((nntp \"some.server\") (nntp \"other.server\")))
If this variable is nil, then you have to tell Gnus explicitly to
-check for new newsgroups with \\<gnus-group-mode-map>\\[gnus-find-new-newsgroups].")
-
-(defvar gnus-check-bogus-newsgroups nil
+check for new newsgroups with \\<gnus-group-mode-map>\\[gnus-find-new-newsgroups]."
+ :group 'gnus-start
+ :type '(choice (const :tag "no" nil)
+ (const :tag "by brute force" t)
+ (const :tag "ask servers" ask-server)
+ (repeat :menu-tag "ask additional servers"
+ :tag "ask additional servers"
+ :value ((nntp ""))
+ (sexp :format "%v"))))
+
+(defcustom gnus-check-bogus-newsgroups nil
"*Non-nil means that Gnus will check and remove bogus newsgroup at startup.
If this variable is nil, then you have to tell Gnus explicitly to
-check for bogus newsgroups with \\<gnus-group-mode-map>\\[gnus-group-check-bogus-groups].")
+check for bogus newsgroups with \\<gnus-group-mode-map>\\[gnus-group-check-bogus-groups]."
+ :group 'gnus-start-server
+ :type 'boolean)
-(defvar gnus-read-active-file t
+(defcustom gnus-read-active-file 'some
"*Non-nil means that Gnus will read the entire active file at startup.
If this variable is nil, Gnus will only know about the groups in your
`.newsrc' file.
If you set this variable to nil or `some', you probably still want to
be told about new newsgroups that arrive. To do that, set
`gnus-check-new-newsgroups' to `ask-server'. This may not work
-properly with all servers.")
-
-(defvar gnus-level-subscribed 5
- "*Groups with levels less than or equal to this variable are subscribed.")
-
-(defvar gnus-level-unsubscribed 7
+properly with all servers."
+ :group 'gnus-start-server
+ :type '(choice (const nil)
+ (const some)
+ (const t)))
+
+(defcustom gnus-level-subscribed 5
+ "*Groups with levels less than or equal to this variable are subscribed."
+ :group 'gnus-group-levels
+ :type 'integer)
+
+(defcustom gnus-level-unsubscribed 7
"*Groups with levels less than or equal to this variable are unsubscribed.
Groups with levels less than `gnus-level-subscribed', which should be
-less than this variable, are subscribed.")
-
-(defvar gnus-level-zombie 8
- "*Groups with this level are zombie groups.")
-
-(defvar gnus-level-killed 9
- "*Groups with this level are killed.")
-
-(defvar gnus-level-default-subscribed 3
- "*New subscribed groups will be subscribed at this level.")
-
-(defvar gnus-level-default-unsubscribed 6
- "*New unsubscribed groups will be unsubscribed at this level.")
-
-(defvar gnus-activate-level (1+ gnus-level-subscribed)
+less than this variable, are subscribed."
+ :group 'gnus-group-levels
+ :type 'integer)
+
+(defcustom gnus-level-zombie 8
+ "*Groups with this level are zombie groups."
+ :group 'gnus-group-levels
+ :type 'integer)
+
+(defcustom gnus-level-killed 9
+ "*Groups with this level are killed."
+ :group 'gnus-group-levels
+ :type 'integer)
+
+(defcustom gnus-level-default-subscribed 3
+ "*New subscribed groups will be subscribed at this level."
+ :group 'gnus-group-levels
+ :type 'integer)
+
+(defcustom gnus-level-default-unsubscribed 6
+ "*New unsubscribed groups will be unsubscribed at this level."
+ :group 'gnus-group-levels
+ :type 'integer)
+
+(defcustom gnus-activate-level (1+ gnus-level-subscribed)
"*Groups higher than this level won't be activated on startup.
Setting this variable to something low might save lots of time when
-you have many groups that you aren't interested in.")
+you have many groups that you aren't interested in."
+ :group 'gnus-group-levels
+ :type 'integer)
-(defvar gnus-activate-foreign-newsgroups 4
+(defcustom gnus-activate-foreign-newsgroups 4
"*If nil, Gnus will not check foreign newsgroups at startup.
If it is non-nil, it should be a number between one and nine. Foreign
newsgroups that have a level lower or equal to this number will be
If you subscribe to lots of newsgroups from different servers, startup
might take a while. By setting this variable to nil, you'll save time,
but you won't be told how many unread articles there are in the
-groups.")
+groups."
+ :group 'gnus-group-levels
+ :type '(choice integer
+ (const :tag "none" nil)))
-(defvar gnus-save-newsrc-file t
+(defcustom gnus-save-newsrc-file t
"*Non-nil means that Gnus will save the `.newsrc' file.
Gnus always saves its own startup file, which is called
\".newsrc.eld\". The file called \".newsrc\" is in a format that can
be readily understood by other newsreaders. If you don't plan on
using other newsreaders, set this variable to nil to save some time on
-exit.")
+exit."
+ :group 'gnus-newsrc
+ :type 'boolean)
-(defvar gnus-save-killed-list t
+(defcustom gnus-save-killed-list t
"*If non-nil, save the list of killed groups to the startup file.
If you set this variable to nil, you'll save both time (when starting
and quitting) and space (both memory and disk), but it will also mean
nil if you set this variable to nil.
This variable can also be a regexp. In that case, all groups that do
-not match this regexp will be removed before saving the list.")
+not match this regexp will be removed before saving the list."
+ :group 'gnus-newsrc
+ :type 'boolean)
-(defvar gnus-ignored-newsgroups
+(defcustom gnus-ignored-newsgroups
(purecopy (mapconcat 'identity
'("^to\\." ; not "real" groups
"^[0-9. \t]+ " ; all digits in name
"*A regexp to match uninteresting newsgroups in the active file.
Any lines in the active file matching this regular expression are
removed from the newsgroup list before anything else is done to it,
-thus making them effectively non-existent.")
+thus making them effectively non-existent."
+ :group 'gnus-group-new
+ :type 'regexp)
-(defvar gnus-subscribe-newsgroup-method 'gnus-subscribe-zombies
+(defcustom gnus-subscribe-newsgroup-method 'gnus-subscribe-zombies
"*Function called with a group name when new group is detected.
A few pre-made functions are supplied: `gnus-subscribe-randomly'
inserts new groups at the beginning of the list of groups;
alphabetic order; `gnus-subscribe-hierarchically' inserts new groups
in hierarchical newsgroup order; `gnus-subscribe-interactively' asks
for your decision; `gnus-subscribe-killed' kills all new groups;
-`gnus-subscribe-zombies' will make all new groups into zombies.")
+`gnus-subscribe-zombies' will make all new groups into zombies."
+ :group 'gnus-group-new
+ :type '(radio (function-item gnus-subscribe-randomly)
+ (function-item gnus-subscribe-alphabetically)
+ (function-item gnus-subscribe-hierarchically)
+ (function-item gnus-subscribe-interactively)
+ (function-item gnus-subscribe-killed)
+ (function-item gnus-subscribe-zombies)
+ function))
;; Suggested by a bug report by Hallvard B Furuseth.
;; <h.b.furuseth@usit.uio.no>.
-(defvar gnus-subscribe-options-newsgroup-method
- (function gnus-subscribe-alphabetically)
+(defcustom gnus-subscribe-options-newsgroup-method
+ 'gnus-subscribe-alphabetically
"*This function is called to subscribe newsgroups mentioned on \"options -n\" lines.
If, for instance, you want to subscribe to all newsgroups in the
\"no\" and \"alt\" hierarchies, you'd put the following in your
options -n no.all alt.all
Gnus will the subscribe all new newsgroups in these hierarchies with
-the subscription method in this variable.")
-
-(defvar gnus-subscribe-hierarchical-interactive nil
+the subscription method in this variable."
+ :group 'gnus-group-new
+ :type '(radio (function-item gnus-subscribe-randomly)
+ (function-item gnus-subscribe-alphabetically)
+ (function-item gnus-subscribe-hierarchically)
+ (function-item gnus-subscribe-interactively)
+ (function-item gnus-subscribe-killed)
+ (function-item gnus-subscribe-zombies)
+ function))
+
+(defcustom gnus-subscribe-hierarchical-interactive nil
"*If non-nil, Gnus will offer to subscribe hierarchically.
When a new hierarchy appears, Gnus will ask the user:
If the user pressed `d', Gnus will descend the hierarchy, `y' will
subscribe to all newsgroups in the hierarchy and `s' will skip this
-hierarchy in its entirety.")
+hierarchy in its entirety."
+ :group 'gnus-group-new
+ :type 'boolean)
-(defvar gnus-auto-subscribed-groups
- "^nnml\\|^nnfolder\\|^nnmbox\\|^nnmh\\|^nnbabyl"
+(defcustom gnus-auto-subscribed-groups
+ "nnml\\|^nnfolder\\|^nnmbox\\|^nnmh\\|^nnbabyl"
"*All new groups that match this regexp will be subscribed automatically.
Note that this variable only deals with new groups. It has no effect
whatsoever on old groups.
New groups that match this regexp will not be handled by
`gnus-subscribe-newsgroup-method'. Instead, they will
-be subscribed using `gnus-subscribe-options-newsgroup-method'.")
+be subscribed using `gnus-subscribe-options-newsgroup-method'."
+ :group 'gnus-group-new
+ :type 'regexp)
-(defvar gnus-options-subscribe nil
+(defcustom gnus-options-subscribe nil
"*All new groups matching this regexp will be subscribed unconditionally.
Note that this variable deals only with new newsgroups. This variable
does not affect old newsgroups.
New groups that match this regexp will not be handled by
`gnus-subscribe-newsgroup-method'. Instead, they will
-be subscribed using `gnus-subscribe-options-newsgroup-method'.")
+be subscribed using `gnus-subscribe-options-newsgroup-method'."
+ :group 'gnus-group-new
+ :type '(choice regexp
+ (const :tag "none" nil)))
-(defvar gnus-options-not-subscribe nil
+(defcustom gnus-options-not-subscribe nil
"*All new groups matching this regexp will be ignored.
Note that this variable deals only with new newsgroups. This variable
-does not affect old (already subscribed) newsgroups.")
+does not affect old (already subscribed) newsgroups."
+ :group 'gnus-group-new
+ :type '(choice regexp
+ (const :tag "none" nil)))
-(defvar gnus-modtime-botch nil
- "*Non-nil means .newsrc should be deleted prior to save.
+(defcustom gnus-modtime-botch nil
+ "*Non-nil means .newsrc should be deleted prior to save.
Its use is due to the bogus appearance that .newsrc was modified on
-disc.")
-
-(defvar gnus-check-bogus-groups-hook nil
- "A hook run after removing bogus groups.")
-
-(defvar gnus-startup-hook nil
- "*A hook called at startup.
-This hook is called after Gnus is connected to the NNTP server.")
-
-(defvar gnus-get-new-news-hook nil
- "*A hook run just before Gnus checks for new news.")
-
-(defvar gnus-after-getting-new-news-hook nil
- "*A hook run after Gnus checks for new news.")
-
-(defvar gnus-save-newsrc-hook nil
- "*A hook called before saving any of the newsrc files.")
-
-(defvar gnus-save-quick-newsrc-hook nil
- "*A hook called just before saving the quick newsrc file.
-Can be used to turn version control on or off.")
-
-(defvar gnus-save-standard-newsrc-hook nil
- "*A hook called just before saving the standard newsrc file.
-Can be used to turn version control on or off.")
+disc."
+ :group 'gnus-newsrc
+ :type 'boolean)
+
+(defcustom gnus-check-bogus-groups-hook nil
+ "A hook run after removing bogus groups."
+ :group 'gnus-start-server
+ :type 'hook)
+
+(defcustom gnus-startup-hook nil
+ "A hook called at startup.
+This hook is called after Gnus is connected to the NNTP server."
+ :group 'gnus-start
+ :type 'hook)
+
+(defcustom gnus-before-startup-hook nil
+ "A hook called at before startup.
+This hook is called as the first thing when Gnus is started."
+ :group 'gnus-start
+ :type 'hook)
+
+(defcustom gnus-started-hook nil
+ "A hook called as the last thing after startup."
+ :group 'gnus-start
+ :type 'hook)
+
+(defcustom gnus-setup-news-hook nil
+ "A hook after reading the .newsrc file, but before generating the buffer."
+ :group 'gnus-start
+ :type 'hook)
+
+(defcustom gnus-get-new-news-hook nil
+ "A hook run just before Gnus checks for new news."
+ :group 'gnus-group-new
+ :type 'hook)
+
+(defcustom gnus-after-getting-new-news-hook
+ (when (gnus-boundp 'display-time-timer)
+ '(display-time-event-handler))
+ "*A hook run after Gnus checks for new news."
+ :group 'gnus-group-new
+ :type 'hook)
+
+(defcustom gnus-save-newsrc-hook nil
+ "A hook called before saving any of the newsrc files."
+ :group 'gnus-newsrc
+ :type 'hook)
+
+(defcustom gnus-save-quick-newsrc-hook nil
+ "A hook called just before saving the quick newsrc file.
+Can be used to turn version control on or off."
+ :group 'gnus-newsrc
+ :type 'hook)
+
+(defcustom gnus-save-standard-newsrc-hook nil
+ "A hook called just before saving the standard newsrc file.
+Can be used to turn version control on or off."
+ :group 'gnus-newsrc
+ :type 'hook)
;;; Internal variables
+(defvar gnus-always-read-dribble-file nil
+ "Uncoditionally read the dribble file.")
+
(defvar gnus-newsrc-file-version nil)
(defvar gnus-override-subscribe-method nil)
(defvar gnus-dribble-buffer nil)
;; Suggested by Brian Edmonds <edmonds@cs.ubc.ca>.
(defvar gnus-init-inhibit nil)
(defun gnus-read-init-file (&optional inhibit-next)
- (if gnus-init-inhibit
- (setq gnus-init-inhibit nil)
- (setq gnus-init-inhibit inhibit-next)
- (let ((files (list gnus-site-init-file gnus-init-file))
- file)
- (while files
- (and (setq file (pop files))
- (or (and (file-exists-p file)
- ;; Don't try to load a directory.
- (not (file-directory-p file)))
- (file-exists-p (concat file ".el"))
- (file-exists-p (concat file ".elc")))
- (condition-case var
- (load file nil t)
- (error
- (error "Error in %s: %s" file var))))))))
+ ;; Don't load .gnus if the -q option was used.
+ (when init-file-user
+ (if gnus-init-inhibit
+ (setq gnus-init-inhibit nil)
+ (setq gnus-init-inhibit inhibit-next)
+ (let ((files (list gnus-site-init-file gnus-init-file))
+ file)
+ (while files
+ (and (setq file (pop files))
+ (or (and (file-exists-p file)
+ ;; Don't try to load a directory.
+ (not (file-directory-p file)))
+ (file-exists-p (concat file ".el"))
+ (file-exists-p (concat file ".elc")))
+ (condition-case var
+ (load file nil t)
+ (error
+ (error "Error in %s: %s" file var)))))))))
;; For subscribing new newsgroup
(concat "^" (substring (car groups) 0 (match-end 0))))
(string-match prefix (cadr groups)))
(progn
- (setq prefixes (cons prefix prefixes))
+ (push prefix prefixes)
(message "Descend hierarchy %s? ([y]nsq): "
(substring prefix 1 (1- (length prefix))))
- (while (not (memq (setq ans (read-char)) '(?y ?\n ?n ?s ?q)))
+ (while (not (memq (setq ans (read-char-exclusive))
+ '(?y ?\n ?\r ?n ?s ?q)))
(ding)
(message "Descend hierarchy %s? ([y]nsq): "
(substring prefix 1 (1- (length prefix)))))
(while (and groups
(string-match prefix
(setq group (car groups))))
- (setq gnus-killed-list
- (cons group gnus-killed-list))
+ (push group gnus-killed-list)
(gnus-sethash group group gnus-killed-hashtb)
(setq groups (cdr groups)))
(setq starts (cdr starts)))
((= ans ?q)
(while groups
(setq group (car groups))
- (setq gnus-killed-list (cons group gnus-killed-list))
+ (push group gnus-killed-list)
(gnus-sethash group group gnus-killed-hashtb)
(setq groups (cdr groups))))
(t nil)))
(message "Subscribe %s? ([n]yq)" (car groups))
- (while (not (memq (setq ans (read-char)) '(?y ?\n ?q ?n)))
+ (while (not (memq (setq ans (read-char-exclusive))
+ '(?y ?\n ?\r ?q ?n)))
(ding)
(message "Subscribe %s? ([n]yq)" (car groups)))
(setq group (car groups))
((= ans ?q)
(while groups
(setq group (car groups))
- (setq gnus-killed-list (cons group gnus-killed-list))
+ (push group gnus-killed-list)
(gnus-sethash group group gnus-killed-hashtb)
(setq groups (cdr groups))))
(t
- (setq gnus-killed-list (cons group gnus-killed-list))
+ (push group gnus-killed-list)
(gnus-sethash group group gnus-killed-hashtb)))
(setq groups (cdr groups)))))))
"Subscribe new NEWSGROUP and insert it in hierarchical newsgroup order."
;; Basic ideas by mike-w@cs.aukuni.ac.nz (Mike Williams)
(save-excursion
- (set-buffer (find-file-noselect gnus-current-startup-file))
+ (set-buffer (nnheader-find-file-noselect gnus-current-startup-file))
(let ((groupkey newgroup)
before)
(while (and (not before) groupkey)
(string< before newgroup)))))
;; Remove tail of newsgroup name (eg. a.b.c -> a.b)
(setq groupkey
- (if (string-match "^\\(.*\\)\\.[^.]+$" groupkey)
- (substring groupkey (match-beginning 1) (match-end 1)))))
+ (when (string-match "^\\(.*\\)\\.[^.]+$" groupkey)
+ (substring groupkey (match-beginning 1) (match-end 1)))))
(gnus-subscribe-newsgroup newgroup before))
(kill-buffer (current-buffer))))
gnus-zombie-list nil
gnus-killed-hashtb nil
gnus-active-hashtb nil
- gnus-moderated-list nil
+ gnus-moderated-hashtb nil
gnus-description-hashtb nil
gnus-current-headers nil
gnus-thread-indent-array nil
gnus-newsgroup-data nil
gnus-newsgroup-unreads nil
nnoo-state-alist nil
- gnus-current-select-method nil)
+ gnus-current-select-method nil
+ gnus-ephemeral-servers nil)
(gnus-shutdown 'gnus)
;; Kill the startup file.
(and gnus-current-startup-file
prompt the user for the name of an NNTP server to use."
(interactive "P")
- (if (and (get-buffer gnus-group-buffer)
- (save-excursion
- (set-buffer gnus-group-buffer)
- (eq major-mode 'gnus-group-mode)))
+ (if (gnus-alive-p)
(progn
(switch-to-buffer gnus-group-buffer)
- (gnus-group-get-new-news))
+ (gnus-group-get-new-news
+ (and (numberp arg)
+ (> arg 0)
+ (max (car gnus-group-list-mode) arg))))
(gnus-splash)
(gnus-clear-system)
+ (gnus-run-hooks 'gnus-before-startup-hook)
(nnheader-init-server-buffer)
- (gnus-read-init-file)
(setq gnus-slave slave)
+ (gnus-read-init-file)
- (when (string-match "xemacs" (emacs-version))
- (gnus-splash))
+ (when gnus-simple-splash
+ (setq gnus-simple-splash nil)
+ (cond
+ (gnus-xemacs
+ (gnus-xmas-splash))
+ ((and (eq window-system 'x)
+ (= (frame-height) (1+ (window-height))))
+ (gnus-x-splash))))
(let ((level (and (numberp arg) (> arg 0) arg))
did-connect)
(unwind-protect
(progn
- (or dont-connect
- (setq did-connect
- (gnus-start-news-server (and arg (not level))))))
+ (unless dont-connect
+ (setq did-connect
+ (gnus-start-news-server (and arg (not level))))))
(if (and (not dont-connect)
(not did-connect))
(gnus-group-quit)
- (run-hooks 'gnus-startup-hook)
+ (gnus-run-hooks 'gnus-startup-hook)
;; NNTP server is successfully open.
;; Find the current startup file name.
;; Do the actual startup.
(gnus-setup-news nil level dont-connect)
+ (gnus-run-hooks 'gnus-setup-news-hook)
+ (gnus-start-draft-setup)
;; Generate the group buffer.
(gnus-group-list-groups level)
(gnus-group-first-unread-group)
(gnus-configure-windows 'group)
- (gnus-group-set-mode-line))))))
+ (gnus-group-set-mode-line)
+ (gnus-run-hooks 'gnus-started-hook))))))
+
+(defun gnus-start-draft-setup ()
+ "Make sure the draft group exists."
+ (gnus-request-create-group "drafts" '(nndraft ""))
+ (unless (gnus-gethash "nndraft:drafts" gnus-newsrc-hashtb)
+ (let ((gnus-level-default-subscribed 1))
+ (gnus-subscribe-group "nndraft:drafts" nil '(nndraft "")))
+ (gnus-group-set-parameter
+ "nndraft:drafts" 'gnus-dummy '((gnus-draft-mode)))))
;;;###autoload
(defun gnus-unload ()
"Unload all Gnus features."
(interactive)
- (or (boundp 'load-history)
- (error "Sorry, `gnus-unload' is not implemented in this Emacs version."))
+ (unless (boundp 'load-history)
+ (error "Sorry, `gnus-unload' is not implemented in this Emacs version"))
(let ((history load-history)
feature)
(while history
(defun gnus-dribble-enter (string)
"Enter STRING into the dribble buffer."
- (if (and (not gnus-dribble-ignore)
- gnus-dribble-buffer
- (buffer-name gnus-dribble-buffer))
- (let ((obuf (current-buffer)))
- (set-buffer gnus-dribble-buffer)
- (insert string "\n")
- (set-window-point (get-buffer-window (current-buffer)) (point-max))
- (bury-buffer gnus-dribble-buffer)
- (set-buffer obuf))))
+ (when (and (not gnus-dribble-ignore)
+ gnus-dribble-buffer
+ (buffer-name gnus-dribble-buffer))
+ (let ((obuf (current-buffer)))
+ (set-buffer gnus-dribble-buffer)
+ (goto-char (point-max))
+ (insert string "\n")
+ (set-window-point (get-buffer-window (current-buffer)) (point-max))
+ (bury-buffer gnus-dribble-buffer)
+ (save-excursion
+ (set-buffer gnus-group-buffer)
+ (gnus-group-set-mode-line))
+ (set-buffer obuf))))
+
+(defun gnus-dribble-touch ()
+ "Touch the dribble buffer."
+ (gnus-dribble-enter ""))
(defun gnus-dribble-read-file ()
"Read the dribble file from disk."
;; Load whichever file is newest -- the auto save file
;; or the "real" file.
(if (file-newer-than-file-p auto dribble-file)
- (insert-file-contents auto)
- (insert-file-contents dribble-file))
+ (nnheader-insert-file-contents auto)
+ (nnheader-insert-file-contents dribble-file))
(unless (zerop (buffer-size))
(set-buffer-modified-p t))
;; Set the file modes to reflect the .newsrc file modes.
(save-buffer)
(when (and (file-exists-p gnus-current-startup-file)
+ (file-exists-p dribble-file)
(setq modes (file-modes gnus-current-startup-file)))
(set-file-modes dribble-file modes))
;; Possibly eval the file later.
- (when (gnus-y-or-n-p
- "Auto-save file exists. Do you want to read it? ")
+ (when (or gnus-always-read-dribble-file
+ (gnus-y-or-n-p
+ "Gnus auto-save file exists. Do you want to read it? "))
(setq gnus-dribble-eval-file t)))))))
(defun gnus-dribble-eval-file ()
(save-excursion
(set-buffer gnus-dribble-buffer)
(let ((auto (make-auto-save-file-name)))
- (if (file-exists-p auto)
- (delete-file auto))
+ (when (file-exists-p auto)
+ (delete-file auto))
(erase-buffer)
(set-buffer-modified-p nil)))))
If LEVEL is non-nil, the news will be set up at level LEVEL."
(let ((init (not (and gnus-newsrc-alist gnus-active-hashtb (not rawfile)))))
- (when init
+ (when init
;; Clear some variables to re-initialize news information.
(setq gnus-newsrc-alist nil
gnus-active-hashtb nil)
;; Read the newsrc file and create `gnus-newsrc-hashtb'.
(gnus-read-newsrc-file rawfile))
- (when (and (not (assoc "archive" gnus-server-alist))
- (gnus-archive-server-wanted-p))
+ ;; Make sure the archive server is available to all and sundry.
+ (when gnus-message-archive-method
+ (setq gnus-server-alist (delq (assoc "archive" gnus-server-alist)
+ gnus-server-alist))
(push (cons "archive" gnus-message-archive-method)
gnus-server-alist))
;; done in `gnus-get-unread-articles'.
(and gnus-read-active-file
(not level)
- (gnus-read-active-file))
+ (gnus-read-active-file nil dont-connect))
(unless gnus-active-hashtb
- (setq gnus-active-hashtb (make-vector 4095 0)))
+ (setq gnus-active-hashtb (gnus-make-hashtable 4096)))
;; Initialize the cache.
(when gnus-use-cache
(gnus-cache-open))
;; Possibly eval the dribble file.
- (and init (or gnus-use-dribble-file gnus-slave) (gnus-dribble-eval-file))
+ (and init
+ (or gnus-use-dribble-file gnus-slave)
+ (gnus-dribble-eval-file))
;; Slave Gnusii should then clear the dribble buffer.
(when (and init gnus-slave)
(gnus-update-format-specifications)
;; See whether we need to read the description file.
- (when (and (string-match "%[-,0-9]*D" gnus-group-line-format)
+ (when (and (boundp 'gnus-group-line-format)
+ (let ((case-fold-search nil))
+ (string-match "%[-,0-9]*D" gnus-group-line-format))
(not gnus-description-hashtb)
(not dont-connect)
gnus-read-active-file)
;; Find new newsgroups and treat them.
(when (and init gnus-check-new-newsgroups (not level)
- (gnus-check-server gnus-select-method))
+ (gnus-check-server gnus-select-method)
+ (not gnus-slave)
+ gnus-plugged)
(gnus-find-new-newsgroups))
;; We might read in new NoCeM messages here.
- (when (and gnus-use-nocem
+ (when (and gnus-use-nocem
(not level)
(not dont-connect))
(gnus-nocem-scan-groups))
+ ;; Read any slave files.
+ (gnus-master-read-slave-newsrc)
+
;; Find the number of unread articles in each non-dead group.
(let ((gnus-read-active-file (and (not level) gnus-read-active-file)))
(gnus-get-unread-articles level))
"Search for new newsgroups and add them.
Each new newsgroup will be treated with `gnus-subscribe-newsgroup-method.'
The `-n' option line from .newsrc is respected.
-If ARG (the prefix), use the `ask-server' method to query
-the server for new groups."
+If ARG (the prefix), use the `ask-server' method to query the server
+for new groups."
(interactive "P")
(let ((check (if (or (and arg (not (listp gnus-check-new-newsgroups)))
(null gnus-read-active-file)
(setq groups (1+ groups))
(gnus-sethash group group gnus-killed-hashtb)
(if gnus-subscribe-hierarchical-interactive
- (setq new-newsgroups (cons group new-newsgroups))
+ (push group new-newsgroups)
(funcall gnus-subscribe-newsgroup-method group)))))))
gnus-active-hashtb)
(when new-newsgroups
(gnus-subscribe-hierarchical-interactive new-newsgroups))
- ;; Suggested by Per Abrahamsen <amanda@iesd.auc.dk>.
(if (> groups 0)
- (gnus-message 6 "%d new newsgroup%s arrived."
+ (gnus-message 5 "%d new newsgroup%s arrived."
groups (if (> groups 1) "s have" " has"))
- (gnus-message 6 "No new newsgroups.")))))))
+ (gnus-message 5 "No new newsgroups.")))))))
(defun gnus-matches-options-n (group)
;; Returns `subscribe' if the group is to be unconditionally
(new-date (current-time-string))
group new-newsgroups got-new method hashtb
gnus-override-subscribe-method)
+ (unless gnus-killed-hashtb
+ (gnus-make-hashtable-from-killed))
;; Go through both primary and secondary select methods and
;; request new newsgroups.
(while (setq method (gnus-server-get-method nil (pop methods)))
hashtb))
(when new-newsgroups
(gnus-subscribe-hierarchical-interactive new-newsgroups)))
- ;; Suggested by Per Abrahamsen <amanda@iesd.auc.dk>.
- (when (> groups 0)
- (gnus-message 6 "%d new newsgroup%s arrived."
- groups (if (> groups 1) "s have" " has")))
- (and got-new (setq gnus-newsrc-last-checked-date new-date))
+ (if (> groups 0)
+ (gnus-message 5 "%d new newsgroup%s arrived"
+ groups (if (> groups 1) "s have" " has"))
+ (gnus-message 5 "No new newsgroups"))
+ (when got-new
+ (setq gnus-newsrc-last-checked-date new-date))
got-new))
(defun gnus-check-first-time-used ()
nil
(gnus-message 6 "First time user; subscribing you to default groups")
(unless (gnus-read-active-file-p)
- (gnus-read-active-file))
+ (let ((gnus-read-active-file t))
+ (gnus-read-active-file)))
(setq gnus-newsrc-last-checked-date (current-time-string))
(let ((groups gnus-default-subscribed-newsgroups)
group)
((eq do-sub 'ignore)
nil)
(t
- (setq gnus-killed-list (cons group gnus-killed-list)))))))
+ (push group gnus-killed-list))))))
gnus-active-hashtb)
(while groups
- (if (gnus-active (car groups))
- (gnus-group-change-level
- (car groups) gnus-level-default-subscribed gnus-level-killed))
+ (when (gnus-active (car groups))
+ (gnus-group-change-level
+ (car groups) gnus-level-default-subscribed gnus-level-killed))
(setq groups (cdr groups)))
(gnus-group-make-help-group)
- (and gnus-novice-user
- (gnus-message 7 "`A k' to list killed groups"))))))
+ (when gnus-novice-user
+ (gnus-message 7 "`A k' to list killed groups"))))))
(defun gnus-subscribe-group (group previous &optional method)
(gnus-group-change-level
(if fromkilled (setq group (nth 1 entry))
(setq group (car (nth 2 entry))))
(setq group entry))
- (if (and (stringp entry)
- oldlevel
- (< oldlevel gnus-level-zombie))
- (setq entry (gnus-gethash entry gnus-newsrc-hashtb)))
+ (when (and (stringp entry)
+ oldlevel
+ (< oldlevel gnus-level-zombie))
+ (setq entry (gnus-gethash entry gnus-newsrc-hashtb)))
(if (and (not oldlevel)
(consp entry))
(setq oldlevel (gnus-info-level (nth 2 entry)))
- (setq oldlevel (or oldlevel 9)))
- (if (stringp previous)
- (setq previous (gnus-gethash previous gnus-newsrc-hashtb)))
+ (setq oldlevel (or oldlevel gnus-level-killed)))
+ (when (stringp previous)
+ (setq previous (gnus-gethash previous gnus-newsrc-hashtb)))
(if (and (>= oldlevel gnus-level-zombie)
(gnus-gethash group gnus-newsrc-hashtb))
;; subscribed.
() ; Do nothing.
- (or (gnus-ephemeral-group-p group)
- (gnus-dribble-enter
- (format "(gnus-group-change-level %S %S %S %S %S)"
- group level oldlevel (car (nth 2 previous)) fromkilled)))
+ (unless (gnus-ephemeral-group-p group)
+ (gnus-dribble-enter
+ (format "(gnus-group-change-level %S %S %S %S %S)"
+ group level oldlevel (car (nth 2 previous)) fromkilled)))
;; Then we remove the newgroup from any old structures, if needed.
;; If the group was killed, we remove it from the killed or zombie
(setq gnus-zombie-list (delete group gnus-zombie-list))
(setq gnus-killed-list (delete group gnus-killed-list))))
(t
- (if (and (>= level gnus-level-zombie)
- entry)
- (progn
- (gnus-sethash (car (nth 2 entry)) nil gnus-newsrc-hashtb)
- (if (nth 3 entry)
- (setcdr (gnus-gethash (car (nth 3 entry))
- gnus-newsrc-hashtb)
- (cdr entry)))
- (setcdr (cdr entry) (cdddr entry))))))
+ (when (and (>= level gnus-level-zombie)
+ entry)
+ (gnus-sethash (car (nth 2 entry)) nil gnus-newsrc-hashtb)
+ (when (nth 3 entry)
+ (setcdr (gnus-gethash (car (nth 3 entry))
+ gnus-newsrc-hashtb)
+ (cdr entry)))
+ (setcdr (cdr entry) (cdddr entry)))))
;; Finally we enter (if needed) the list where it is supposed to
;; go, and change the subscription level. If it is to be killed,
;; we enter it into the killed or zombie list.
- (cond
+ (cond
((>= level gnus-level-zombie)
;; Remove from the hash table.
(gnus-sethash group nil gnus-newsrc-hashtb)
;; groups.
(unless (gnus-group-foreign-p group)
(if (= level gnus-level-zombie)
- (setq gnus-zombie-list (cons group gnus-zombie-list))
- (setq gnus-killed-list (cons group gnus-killed-list)))))
+ (push group gnus-zombie-list)
+ (push group gnus-killed-list))))
(t
;; If the list is to be entered into the newsrc assoc, and
;; it was killed, we have to create an entry in the newsrc
(gnus-sethash group (cons num previous)
gnus-newsrc-hashtb))
(when (cdr entry)
- (setcdr (gnus-gethash (caadr entry) gnus-newsrc-hashtb) entry)))))
+ (setcdr (gnus-gethash (caadr entry) gnus-newsrc-hashtb) entry))
+ (gnus-dribble-enter
+ (format
+ "(gnus-group-set-info '%S)" info)))))
(when gnus-group-change-level-function
- (funcall gnus-group-change-level-function group level oldlevel)))))
+ (funcall gnus-group-change-level-function
+ group level oldlevel previous)))))
(defun gnus-kill-newsgroup (newsgroup)
"Obsolete function. Kills a newsgroup."
bogus group entry info)
(gnus-message 5 "Checking bogus newsgroups...")
(unless (gnus-read-active-file-p)
- (gnus-read-active-file))
+ (gnus-read-active-file t))
(when (gnus-read-active-file-p)
;; Find all bogus newsgroup that are subscribed.
(while newsrc
(setq info (pop newsrc)
group (gnus-info-group info))
(unless (or (gnus-active group) ; Active
- (gnus-info-method info) ; Foreign
- (and confirm
- (not (gnus-y-or-n-p
- (format "Remove bogus newsgroup: %s " group)))))
+ (gnus-info-method info)) ; Foreign
;; Found a bogus newsgroup.
(push group bogus)))
- ;; Remove all bogus subscribed groups by first killing them, and
- ;; then removing them from the list of killed groups.
- (while bogus
- (when (setq entry (gnus-gethash (setq group (pop bogus))
- gnus-newsrc-hashtb))
- (gnus-group-change-level entry gnus-level-killed)
- (setq gnus-killed-list (delete group gnus-killed-list))))
+ (if confirm
+ (map-y-or-n-p
+ "Remove bogus group %s? "
+ (lambda (group)
+ ;; Remove all bogus subscribed groups by first killing them, and
+ ;; then removing them from the list of killed groups.
+ (when (setq entry (gnus-gethash group gnus-newsrc-hashtb))
+ (gnus-group-change-level entry gnus-level-killed)
+ (setq gnus-killed-list (delete group gnus-killed-list))))
+ bogus '("group" "groups" "remove"))
+ (while (setq group (pop bogus))
+ ;; Remove all bogus subscribed groups by first killing them, and
+ ;; then removing them from the list of killed groups.
+ (when (setq entry (gnus-gethash group gnus-newsrc-hashtb))
+ (gnus-group-change-level entry gnus-level-killed)
+ (setq gnus-killed-list (delete group gnus-killed-list)))))
;; Then we remove all bogus groups from the list of killed and
;; zombie groups. They are removed without confirmation.
(let ((dead-lists '(gnus-killed-list gnus-zombie-list))
(set (car dead-lists)
(delete group (symbol-value (car dead-lists))))))
(setq dead-lists (cdr dead-lists))))
- (run-hooks 'gnus-check-bogus-groups-hook)
+ (gnus-run-hooks 'gnus-check-bogus-groups-hook)
(gnus-message 5 "Checking bogus newsgroups...done"))))
(defun gnus-check-duplicate-killed-groups ()
"Alter the ACTIVE info for GROUP to reflect the articles in the cache."
(when gnus-cache-active-hashtb
(let ((cache-active (gnus-gethash group gnus-cache-active-hashtb)))
- (and cache-active
- (< (car cache-active) (car active))
- (setcar active (car cache-active)))
- (and cache-active
- (> (cdr cache-active) (cdr active))
- (setcdr active (cdr cache-active)))))))
+ (when cache-active
+ (when (< (car cache-active) (car active))
+ (setcar active (car cache-active)))
+ (when (> (cdr cache-active) (cdr active))
+ (setcdr active (cdr cache-active))))))))
+
+(defun gnus-activate-group (group &optional scan dont-check method)
+ ;; Check whether a group has been activated or not.
+ ;; If SCAN, request a scan of that group as well.
+ (let ((method (or method (inline (gnus-find-method-for-group group))))
+ active)
+ (and (inline (gnus-check-server method))
+ ;; We escape all bugs and quit here to make it possible to
+ ;; continue if a group is so out-there that it reports bugs
+ ;; and stuff.
+ (progn
+ (and scan
+ (gnus-check-backend-function 'request-scan (car method))
+ (gnus-request-scan group method))
+ t)
+ (condition-case ()
+ (inline (gnus-request-group group dont-check method))
+ (error nil)
+ (quit nil))
+ (setq active (gnus-parse-active))
+ ;; If there are no articles in the group, the GROUP
+ ;; command may have responded with the `(0 . 0)'. We
+ ;; ignore this if we already have an active entry
+ ;; for the group.
+ (if (and (zerop (car active))
+ (zerop (cdr active))
+ (gnus-active group))
+ (gnus-active group)
+ (gnus-set-active group active)
+ ;; Return the new active info.
+ active))))
(defun gnus-get-unread-articles-in-group (info active &optional update)
(when active
;; Allow the backend to update the info in the group.
- (when (and update
+ (when (and update
(gnus-request-update-info
- info (gnus-find-method-for-group (gnus-info-group info))))
+ info (inline (gnus-find-method-for-group
+ (gnus-info-group info)))))
(gnus-activate-group (gnus-info-group info) nil t))
(let* ((range (gnus-info-read info))
(num 0))
;; If a cache is present, we may have to alter the active info.
(when (and gnus-use-cache info)
- (inline (gnus-cache-possibly-alter-active
+ (inline (gnus-cache-possibly-alter-active
(gnus-info-group info) active)))
;; Modify the list of read articles according to what articles
;; are available; then tally the unread articles and add the
(cdadr range))))
(setcdr range (cddr range)))
;; Adjust the first element to be the same as the lower limit.
- (if (and (not (atom (car range)))
- (< (cdar range) (car active)))
- (setcdr (car range) (1- (car active))))
+ (when (and (not (atom (car range)))
+ (< (cdar range) (car active)))
+ (setcdr (car range) (1- (car active))))
;; Then we want to peel off any elements that are higher
;; than the upper active limit.
(let ((srange range))
(while (and (cdr srange)
(<= (or (and (atom (cadr srange))
(cadr srange))
- (caadr srange)) (cdr active)))
+ (caadr srange))
+ (cdr active)))
(setq srange (cdr srange)))
- (if (cdr srange)
- ;; Nuke all remaining illegal elements.
- (setcdr srange nil))
+ (when (cdr srange)
+ ;; Nuke all remaining illegal elements.
+ (setcdr srange nil))
;; Adjust the final element.
- (if (and (not (atom (car srange)))
- (> (cdar srange) (cdr active)))
- (setcdr (car srange) (cdr active))))
+ (when (and (not (atom (car srange)))
+ (> (cdar srange) (cdr active)))
+ (setcdr (car srange) (cdr active))))
;; Compute the number of unread articles.
(while range
(setq num (+ num (- (1+ (or (and (atom (car range)) (car range))
;; newsgroup to t. This means that Gnus thinks that there are
;; unread articles, but it has no idea how many.
(if (and (setq method (gnus-info-method info))
- (not (gnus-server-equal
- gnus-select-method
- (setq method (gnus-server-get-method nil method))))
+ (not (inline
+ (gnus-server-equal
+ gnus-select-method
+ (setq method (gnus-server-get-method nil method)))))
(not (gnus-secondary-method-p method)))
;; These groups are foreign. Check the level.
(when (<= (gnus-info-level info) foreign-level)
;; Get the number of unread articles in the group.
(if active
- (inline (gnus-get-unread-articles-in-group info active))
+ (inline (gnus-get-unread-articles-in-group info active t))
;; The group couldn't be reached, so we nix out the number of
;; unread articles and stuff.
(gnus-set-active group nil)
(while alist
(gnus-sethash
(caar alist)
+ ;; Preserve number of unread articles in groups.
(cons (and ohashtb (car (gnus-gethash (caar alist) ohashtb)))
prev)
gnus-newsrc-hashtb)
(setq gnus-killed-hashtb
(gnus-make-hashtable
(+ (length gnus-killed-list) (length gnus-zombie-list))))
- (while (setq list (pop lists))
- (setq list (symbol-value list))
+ (while lists
+ (setq list (symbol-value (pop lists)))
(while list
(gnus-sethash (car list) (pop list) gnus-killed-hashtb)))))
-(defun gnus-activate-group (group &optional scan dont-check method)
- ;; Check whether a group has been activated or not.
- ;; If SCAN, request a scan of that group as well.
- (let ((method (or method (gnus-find-method-for-group group)))
- active)
- (and (gnus-check-server method)
- ;; We escape all bugs and quit here to make it possible to
- ;; continue if a group is so out-there that it reports bugs
- ;; and stuff.
- (progn
- (and scan
- (gnus-check-backend-function 'request-scan (car method))
- (gnus-request-scan group method))
- t)
- (condition-case ()
- (gnus-request-group group dont-check method)
- ; (error nil)
- (quit nil))
- (gnus-set-active group (setq active (gnus-parse-active)))
- ;; Return the new active info.
- active)))
-
(defun gnus-parse-active ()
"Parse active info in the nntp server buffer."
(save-excursion
(while articles
(when (gnus-member-of-range
(setq article (pop articles)) ranges)
- (setq news (cons article news))))
+ (push article news)))
(when news
(gnus-info-set-read
info (gnus-remove-from-range (gnus-info-read info) (nreverse news)))
;; Enter all dead groups into the hashtb.
(defun gnus-update-active-hashtb-from-killed ()
- (let ((hashtb (setq gnus-active-hashtb (make-vector 4095 0)))
+ (let ((hashtb (setq gnus-active-hashtb (gnus-make-hashtable 4096)))
(lists (list gnus-killed-list gnus-zombie-list))
killed)
(while lists
(unless (gnus-read-active-file-p)
(let ((gnus-read-active-file t))
(gnus-read-active-file)))
- (or gnus-killed-hashtb (gnus-make-hashtable-from-killed))
+ (unless gnus-killed-hashtb
+ (gnus-make-hashtable-from-killed))
;; Go through all newsgroups that are known to Gnus - enlarge kill list.
(mapatoms
(lambda (sym)
(if (or (eq do-sub 'subscribe) (eq do-sub 'ignore))
()
(setq groups (1+ groups))
- (setq gnus-killed-list
- (cons group gnus-killed-list))
+ (push group gnus-killed-list)
(gnus-sethash group group gnus-killed-hashtb))))))
gnus-active-hashtb)
- (gnus-dribble-enter ""))
+ (gnus-dribble-touch))
;; Get the active file(s) from the backend(s).
-(defun gnus-read-active-file ()
+(defun gnus-read-active-file (&optional force not-native)
(gnus-group-set-mode-line)
- (let ((methods
+ (let ((methods
(append
- (if (gnus-check-server gnus-select-method)
+ (if (and (not not-native)
+ (gnus-check-server gnus-select-method))
;; The native server is available.
(cons gnus-select-method gnus-secondary-select-methods)
;; The native server is down, so we just do the
(gnus-message 5 mesg)
(when (gnus-check-server method)
;; Request that the backend scan its incoming messages.
- (and (gnus-check-backend-function 'request-scan (car method))
- (gnus-request-scan nil method))
+ (when (gnus-check-backend-function 'request-scan (car method))
+ (gnus-request-scan nil method))
(cond
((and (eq gnus-read-active-file 'some)
- (gnus-check-backend-function 'retrieve-groups (car method)))
+ (gnus-check-backend-function 'retrieve-groups (car method))
+ (not force))
(let ((newsrc (cdr gnus-newsrc-alist))
(gmethod (gnus-server-get-method nil method))
groups info)
(while (setq info (pop newsrc))
- (when (gnus-server-equal
- (gnus-find-method-for-group
- (gnus-info-group info) info)
- gmethod)
- (push (gnus-group-real-name (gnus-info-group info))
+ (when (inline
+ (gnus-server-equal
+ (inline
+ (gnus-find-method-for-group
+ (gnus-info-group info) info))
+ gmethod))
+ (push (gnus-group-real-name (gnus-info-group info))
groups)))
(when groups
(gnus-check-server method)
1.2 "Cannot read partial active file from %s server."
(car method)))
((eq list-type 'active)
- (gnus-active-to-gnus-format method gnus-active-hashtb))
+ (gnus-active-to-gnus-format
+ method gnus-active-hashtb nil t))
(t
- (gnus-groups-to-gnus-format method gnus-active-hashtb))))))
+ (gnus-groups-to-gnus-format
+ method gnus-active-hashtb t))))))
+ ((null method)
+ t)
(t
(if (not (gnus-request-list method))
(unless (equal method gnus-message-archive-method)
- (gnus-error 1 "Cannot read active file from %s server."
+ (gnus-error 1 "Cannot read active file from %s server"
(car method)))
(gnus-message 5 mesg)
- (gnus-active-to-gnus-format method gnus-active-hashtb)
+ (gnus-active-to-gnus-format method gnus-active-hashtb nil t)
;; We mark this active file as read.
(push method gnus-have-read-active-file)
(gnus-message 5 "%sdone" mesg))))))
(setq methods (cdr methods))))))
+
+(defun gnus-ignored-newsgroups-has-to-p ()
+ "T only when gnus-ignored-newsgroups includes \"^to\\\\.\" as an element."
+ ;; note this regexp is the same as:
+ ;; (concat (regexp-quote "^to\\.") "\\($\\|" (regexp-quote "\\|") "\\)")
+ (string-match "\\^to\\\\\\.\\($\\|\\\\|\\)"
+ gnus-ignored-newsgroups))
+
;; Read an active file and place the results in `gnus-active-hashtb'.
-(defun gnus-active-to-gnus-format (&optional method hashtb ignore-errors)
+(defun gnus-active-to-gnus-format (&optional method hashtb ignore-errors
+ real-active)
(unless method
(setq method gnus-select-method))
(let ((cur (current-buffer))
(gnus-make-hashtable 4096)))))))
;; Delete unnecessary lines.
(goto-char (point-min))
- (while (search-forward "\nto." nil t)
- (delete-region (1+ (match-beginning 0))
- (progn (forward-line 1) (point))))
- (or (string= gnus-ignored-newsgroups "")
- (progn
- (goto-char (point-min))
- (delete-matching-lines gnus-ignored-newsgroups)))
+ (cond ((gnus-ignored-newsgroups-has-to-p)
+ (delete-matching-lines gnus-ignored-newsgroups))
+ ((string= gnus-ignored-newsgroups "")
+ (delete-matching-lines "^to\\."))
+ (t
+ (delete-matching-lines (concat "^to\\.\\|"
+ gnus-ignored-newsgroups))))
+
;; Make the group names readable as a lisp expression even if they
;; contain special characters.
- ;; Fix by Luc Van Eycken <Luc.VanEycken@esat.kuleuven.ac.be>.
(goto-char (point-max))
(while (re-search-backward "[][';?()#]" nil t)
(insert ?\\))
+
+ ;; Let the Gnus agent save the active file.
+ (when (and gnus-agent real-active)
+ (gnus-agent-save-active method))
+
;; If these are groups from a foreign select method, we insert the
;; group prefix in front of the group names.
- (and method (not (gnus-server-equal
- (gnus-server-get-method nil method)
- (gnus-server-get-method nil gnus-select-method)))
- (let ((prefix (gnus-group-prefixed-name "" method)))
- (goto-char (point-min))
- (while (and (not (eobp))
- (progn (insert prefix)
- (zerop (forward-line 1)))))))
+ (when (not (gnus-server-equal
+ (gnus-server-get-method nil method)
+ (gnus-server-get-method nil gnus-select-method)))
+ (let ((prefix (gnus-group-prefixed-name "" method)))
+ (goto-char (point-min))
+ (while (and (not (eobp))
+ (progn (insert prefix)
+ (zerop (forward-line 1)))))))
;; Store the active file in a hash table.
(goto-char (point-min))
- (if (string-match "%[oO]" gnus-group-line-format)
- ;; Suggested by Brian Edmonds <edmonds@cs.ubc.ca>.
- ;; If we want information on moderated groups, we use this
- ;; loop...
- (let* ((mod-hashtb (make-vector 7 0))
- (m (intern "m" mod-hashtb))
- group max min)
- (while (not (eobp))
- (condition-case nil
- (progn
- (narrow-to-region (point) (gnus-point-at-eol))
- (setq group (let ((obarray hashtb)) (read cur)))
- (if (and (numberp (setq max (read cur)))
- (numberp (setq min (read cur)))
- (progn
- (skip-chars-forward " \t")
- (not
- (or (= (following-char) ?=)
- (= (following-char) ?x)
- (= (following-char) ?j)))))
- (set group (cons min max))
- (set group nil))
- ;; Enter moderated groups into a list.
- (if (eq (let ((obarray mod-hashtb)) (read cur)) m)
- (setq gnus-moderated-list
- (cons (symbol-name group) gnus-moderated-list))))
- (error
- (and group
- (symbolp group)
- (set group nil))))
- (widen)
- (forward-line 1)))
- ;; And if we do not care about moderation, we use this loop,
- ;; which is faster.
- (let (group max min)
- (while (not (eobp))
- (condition-case ()
- (progn
- (narrow-to-region (point) (gnus-point-at-eol))
- ;; group gets set to a symbol interned in the hash table
- ;; (what a hack!!) - jwz
- (setq group (let ((obarray hashtb)) (read cur)))
- (if (and (numberp (setq max (read cur)))
- (numberp (setq min (read cur)))
- (progn
- (skip-chars-forward " \t")
- (not
- (or (= (following-char) ?=)
- (= (following-char) ?x)
- (= (following-char) ?j)))))
+ (let (group max min)
+ (while (not (eobp))
+ (condition-case ()
+ (progn
+ (narrow-to-region (point) (gnus-point-at-eol))
+ ;; group gets set to a symbol interned in the hash table
+ ;; (what a hack!!) - jwz
+ (setq group (let ((obarray hashtb)) (read cur)))
+ (if (and (numberp (setq max (read cur)))
+ (numberp (setq min (read cur)))
+ (progn
+ (skip-chars-forward " \t")
+ (not
+ (or (= (following-char) ?=)
+ (= (following-char) ?x)
+ (= (following-char) ?j)))))
+ (progn
(set group (cons min max))
- (set group nil)))
- (error
- (progn
- (and group
- (symbolp group)
- (set group nil))
- (or ignore-errors
- (gnus-message 3 "Warning - illegal active: %s"
- (buffer-substring
- (gnus-point-at-bol) (gnus-point-at-eol)))))))
- (widen)
- (forward-line 1))))))
-
-(defun gnus-groups-to-gnus-format (method &optional hashtb)
+ ;; if group is moderated, stick in moderation table
+ (when (= (following-char) ?m)
+ (unless gnus-moderated-hashtb
+ (setq gnus-moderated-hashtb (gnus-make-hashtable)))
+ (gnus-sethash (symbol-name group) t
+ gnus-moderated-hashtb)))
+ (set group nil)))
+ (error
+ (and group
+ (symbolp group)
+ (set group nil))
+ (unless ignore-errors
+ (gnus-message 3 "Warning - illegal active: %s"
+ (buffer-substring
+ (gnus-point-at-bol) (gnus-point-at-eol))))))
+ (widen)
+ (forward-line 1)))))
+
+(defun gnus-groups-to-gnus-format (method &optional hashtb real-active)
;; Parse a "groups" active file.
(let ((cur (current-buffer))
(hashtb (or hashtb
(gnus-server-get-method nil gnus-select-method)))
(gnus-group-prefixed-name "" method))))
+ ;; Let the Gnus agent save the active file.
+ (when (and gnus-agent real-active)
+ (gnus-agent-save-groups method))
+
(goto-char (point-min))
;; We split this into to separate loops, one with the prefix
;; and one without to speed the reading up somewhat.
(let (min max group)
(while (not (eobp))
(condition-case ()
- (if (= (following-char) ?2)
- (progn
- (read cur) (read cur)
- (setq min (read cur)
- max (read cur))
- (set (setq group (let ((obarray hashtb)) (read cur)))
- (cons min max))))
+ (when (= (following-char) ?2)
+ (read cur) (read cur)
+ (setq min (read cur)
+ max (read cur))
+ (set (setq group (let ((obarray hashtb)) (read cur)))
+ (cons min max)))
(error (and group (symbolp group) (set group nil))))
(forward-line 1))))))
;; file (ticked articles, killed groups, foreign methods, etc.)
(gnus-read-newsrc-el-file quick-file)
- (if (and (file-exists-p gnus-current-startup-file)
- (or force
- (and (file-newer-than-file-p newsrc-file quick-file)
- (file-newer-than-file-p newsrc-file
- (concat quick-file "d")))
- (not gnus-newsrc-alist)))
- ;; We read the .newsrc file. Note that if there if a
- ;; .newsrc.eld file exists, it has already been read, and
- ;; the `gnus-newsrc-hashtb' has been created. While reading
- ;; the .newsrc file, Gnus will only use the information it
- ;; can find there for changing the data already read -
- ;; i. e., reading the .newsrc file will not trash the data
- ;; already read (except for read articles).
- (save-excursion
- (gnus-message 5 "Reading %s..." newsrc-file)
- (set-buffer (find-file-noselect newsrc-file))
- (buffer-disable-undo (current-buffer))
- (gnus-newsrc-to-gnus-format)
- (kill-buffer (current-buffer))
- (gnus-message 5 "Reading %s...done" newsrc-file)))
-
- ;; Read any slave files.
- (unless gnus-slave
- (gnus-master-read-slave-newsrc))
-
+ (when (and (file-exists-p gnus-current-startup-file)
+ (or force
+ (and (file-newer-than-file-p newsrc-file quick-file)
+ (file-newer-than-file-p newsrc-file
+ (concat quick-file "d")))
+ (not gnus-newsrc-alist)))
+ ;; We read the .newsrc file. Note that if there if a
+ ;; .newsrc.eld file exists, it has already been read, and
+ ;; the `gnus-newsrc-hashtb' has been created. While reading
+ ;; the .newsrc file, Gnus will only use the information it
+ ;; can find there for changing the data already read -
+ ;; i. e., reading the .newsrc file will not trash the data
+ ;; already read (except for read articles).
+ (save-excursion
+ (gnus-message 5 "Reading %s..." newsrc-file)
+ (set-buffer (nnheader-find-file-noselect newsrc-file))
+ (buffer-disable-undo (current-buffer))
+ (gnus-newsrc-to-gnus-format)
+ (kill-buffer (current-buffer))
+ (gnus-message 5 "Reading %s...done" newsrc-file)))
+
;; Convert old to new.
(gnus-convert-old-newsrc))))
(condition-case nil
(load ding-file t t t)
(error
- (gnus-error 1 "Error in %s" ding-file)))
+ (ding)
+ (unless (gnus-yes-or-no-p
+ (format "Error in %s; continue? " ding-file))
+ (error "Error in %s" ding-file))))
(when gnus-newsrc-assoc
(setq gnus-newsrc-alist gnus-newsrc-assoc)))
(gnus-make-hashtable-from-newsrc-alist)
(let ((gnus-killed-assoc nil)
gnus-marked-assoc gnus-newsrc-alist gnus-newsrc-assoc)
(prog1
- (condition-case nil
- (load file t t t)
- (error nil))
+ (ignore-errors
+ (load file t t t))
(setq newsrc gnus-newsrc-assoc
killed gnus-killed-assoc
marked gnus-marked-assoc)))
(gnus-info-set-level
info (if (nth 1 group) gnus-level-default-subscribed
gnus-level-default-unsubscribed))
- (setq gnus-newsrc-alist (cons info gnus-newsrc-alist)))
+ (push info gnus-newsrc-alist))
(push (setq info
(list (car group)
(if (nth 1 group) gnus-level-default-subscribed
(unless (nthcdr 3 info)
(nconc info (list nil)))
(gnus-info-set-marks
- info (list (cons 'tick (gnus-compress-sequence
+ info (list (cons 'tick (gnus-compress-sequence
(sort (cdr m) '<) t))))))
(setq newsrc killed)
(while newsrc
;; The .el file version of this variable does not begin with
;; "options", while the .eld version does, so we just add it if it
;; isn't there.
- (and
- gnus-newsrc-options
- (progn
- (and (not (string-match "^ *options" gnus-newsrc-options))
- (setq gnus-newsrc-options (concat "options " gnus-newsrc-options)))
- (and (not (string-match "\n$" gnus-newsrc-options))
- (setq gnus-newsrc-options (concat gnus-newsrc-options "\n")))
- ;; Finally, if we read some options lines, we parse them.
- (or (string= gnus-newsrc-options "")
- (gnus-newsrc-parse-options gnus-newsrc-options))))
+ (when
+ gnus-newsrc-options
+ (when (not (string-match "^ *options" gnus-newsrc-options))
+ (setq gnus-newsrc-options (concat "options " gnus-newsrc-options)))
+ (when (not (string-match "\n$" gnus-newsrc-options))
+ (setq gnus-newsrc-options (concat gnus-newsrc-options "\n")))
+ ;; Finally, if we read some options lines, we parse them.
+ (unless (string= gnus-newsrc-options "")
+ (gnus-newsrc-parse-options gnus-newsrc-options)))
(setq gnus-newsrc-alist (nreverse gnus-newsrc-alist))
(gnus-make-hashtable-from-newsrc-alist)))
(setq gnus-newsrc-options "")
(setq gnus-newsrc-options-n nil)
- (or gnus-active-hashtb
- (setq gnus-active-hashtb (make-vector 4095 0)))
+ (unless gnus-active-hashtb
+ (setq gnus-active-hashtb (gnus-make-hashtable 4096)))
(let ((buf (current-buffer))
(already-read (> (length gnus-newsrc-alist) 1))
group subscribed options-symbol newsrc Options-symbol
(point)))))
(forward-line -1))
(symbol
- ;; Group names can be just numbers.
- (when (numberp symbol)
+ ;; Group names can be just numbers.
+ (when (numberp symbol)
(setq symbol (intern (int-to-string symbol) gnus-active-hashtb)))
- (or (boundp symbol) (set symbol nil))
+ (unless (boundp symbol)
+ (set symbol nil))
;; It was a group name.
(setq subscribed (= (following-char) ?:)
group (symbol-name symbol)
;; This is a buggy line, by we pretend that
;; it's kinda OK. Perhaps the user should be
;; dinged?
- (setq reads (cons num1 reads))
- (setq reads
- (cons
- (cons num1
- (progn
- (narrow-to-region (match-beginning 0)
- (match-end 0))
- (read buf)))
- reads))
+ (push num1 reads)
+ (push
+ (cons num1
+ (progn
+ (narrow-to-region (match-beginning 0)
+ (match-end 0))
+ (read buf)))
+ reads)
(widen)))
;; It was just a simple number, so we add it to the
;; list of ranges.
- (setq reads (cons num1 reads)))
+ (push num1 reads))
;; If the next char in ?\n, then we have reached the end
;; of the line and return nil.
(/= (following-char) ?\n))
(t
;; Not numbers and not eol, so this might be a buggy
;; line...
- (or (eobp)
- ;; If it was eob instead of ?\n, we allow it.
- (progn
- ;; The line was buggy.
- (setq group nil)
- (gnus-error 3.1 "Mangled line: %s"
- (buffer-substring (gnus-point-at-bol)
- (gnus-point-at-eol)))))
+ (unless (eobp)
+ ;; If it was eob instead of ?\n, we allow it.
+ ;; The line was buggy.
+ (setq group nil)
+ (gnus-error 3.1 "Mangled line: %s"
+ (buffer-substring (gnus-point-at-bol)
+ (gnus-point-at-eol))))
nil))
;; Skip past ", ". Spaces are illegal in these ranges, but
;; we allow them, because it's a common mistake to put a
(1+ gnus-level-subscribed)
gnus-level-default-unsubscribed))
(nreverse reads))))
- (setq newsrc (cons info newsrc))))))
+ (push info newsrc)))))
(forward-line 1))
(setq newsrc (nreverse newsrc))
(if (setq entry (assoc (caar prev) newsrc))
(setcdr (setq mentry (memq entry newsrc))
(cons (car rc) (cdr mentry)))
- (setq newsrc (cons (car rc) newsrc))))
+ (push (car rc) newsrc)))
(setq prev rc
rc (cdr rc)))))
(gnus-make-hashtable-from-newsrc-alist)
;; Finally, if we read some options lines, we parse them.
- (or (string= gnus-newsrc-options "")
- (gnus-newsrc-parse-options gnus-newsrc-options))))
+ (unless (string= gnus-newsrc-options "")
+ (gnus-newsrc-parse-options gnus-newsrc-options))))
;; Parse options lines to find "options -n !all rec.all" and stuff.
;; The return value will be a list on the form
;; If the word begins with a bang (!), this is a "not"
;; spec. We put this spec (minus the bang) and the
;; symbol `ignore' into the list.
- (setq out (cons (cons (concat
- "^" (buffer-substring
- (1+ (match-beginning 0))
- (match-end 0)))
- 'ignore) out))
+ (push (cons (concat
+ "^" (buffer-substring
+ (1+ (match-beginning 0))
+ (match-end 0))
+ "\\($\\|\\.\\)")
+ 'ignore)
+ out)
;; There was no bang, so this is a "yes" spec.
- (setq out (cons (cons (concat "^" (match-string 0))
- 'subscribe) out)))))
+ (push (cons (concat "^" (match-string 0) "\\($\\|\\.\\)")
+ 'subscribe)
+ out))))
(setq gnus-newsrc-options-n out))))
(set-buffer gnus-dribble-buffer)
(buffer-size)))))
(gnus-message 4 "(No changes need to be saved)")
- (run-hooks 'gnus-save-newsrc-hook)
+ (gnus-run-hooks 'gnus-save-newsrc-hook)
(if gnus-slave
(gnus-slave-save-newsrc)
;; Save .newsrc.
(when gnus-save-newsrc-file
- (gnus-message 5 "Saving %s..." gnus-current-startup-file)
+ (gnus-message 8 "Saving %s..." gnus-current-startup-file)
(gnus-gnus-to-newsrc-format)
- (gnus-message 5 "Saving %s...done" gnus-current-startup-file))
+ (gnus-message 8 "Saving %s...done" gnus-current-startup-file))
;; Save .newsrc.eld.
(set-buffer (get-buffer-create " *Gnus-newsrc*"))
(make-local-variable 'version-control)
(erase-buffer)
(gnus-message 5 "Saving %s.eld..." gnus-current-startup-file)
(gnus-gnus-to-quick-newsrc-format)
- (run-hooks 'gnus-save-quick-newsrc-hook)
+ (gnus-run-hooks 'gnus-save-quick-newsrc-hook)
(save-buffer)
(kill-buffer (current-buffer))
(gnus-message
(defun gnus-gnus-to-quick-newsrc-format ()
"Insert Gnus variables such as gnus-newsrc-alist in lisp format."
- (let ((print-quoted t))
+ (let ((print-quoted t)
+ (print-escape-newlines t))
+ (insert ";; -*- emacs-lisp -*-\n")
(insert ";; Gnus startup file.\n")
- (insert
- ";; Never delete this file - touch .newsrc instead to force Gnus\n")
- (insert ";; to read .newsrc.\n")
+ (insert "\
+;; Never delete this file -- if you want to force Gnus to read the
+;; .newsrc file (if you have one), touch .newsrc instead.\n")
(insert "(setq gnus-newsrc-file-version "
(prin1-to-string gnus-version) ")\n")
(let* ((gnus-killed-list
(when (and (boundp (setq variable (pop variables)))
(symbol-value variable))
(insert "(setq " (symbol-name variable) " '")
- (prin1 (symbol-value variable) (current-buffer))
+ (gnus-prin1 (symbol-value variable))
(insert ")\n"))))))
(defun gnus-strip-killed-list ()
(let ((list gnus-killed-list)
olist)
(while list
- (when (string-match gnus-save-killed-list)
+ (when (string-match gnus-save-killed-list (car list))
(push (car list) olist))
(pop list))
(nreverse olist)))
(buffer-disable-undo (current-buffer))
(erase-buffer)
;; Write options.
- (if gnus-newsrc-options (insert gnus-newsrc-options))
+ (when gnus-newsrc-options
+ (insert gnus-newsrc-options))
;; Write subscribed and unsubscribed.
(while (setq info (pop newsrc))
;; Don't write foreign groups to .newsrc.
(when (or (null (setq method (gnus-info-method info)))
(equal method "native")
- (gnus-server-equal method gnus-select-method))
+ (inline (gnus-server-equal method gnus-select-method)))
(insert (gnus-info-group info)
(if (> (gnus-info-level info) gnus-level-subscribed)
"!" ":"))
(princ (car range))
(insert "-")
(princ (cdr range)))
- (if ranges (insert ",")))))
+ (when ranges
+ (insert ",")))))
(insert "\n")))
(make-local-variable 'version-control)
(setq version-control 'never)
(if gnus-modtime-botch
(delete-file gnus-startup-file)
(clear-visited-file-modtime))
- (run-hooks 'gnus-save-standard-newsrc-hook)
+ (gnus-run-hooks 'gnus-save-standard-newsrc-hook)
(save-buffer)
(kill-buffer (current-buffer)))))
(save-excursion
(set-buffer gnus-dribble-buffer)
(let ((slave-name
- (make-temp-name (concat gnus-current-startup-file "-slave-"))))
- (write-region (point-min) (point-max) slave-name nil 'nomesg))))
+ (make-temp-name (concat gnus-current-startup-file "-slave-")))
+ (modes (ignore-errors
+ (file-modes (concat gnus-current-startup-file ".eld")))))
+ (gnus-write-buffer slave-name)
+ (when modes
+ (set-file-modes slave-name modes)))))
(defun gnus-master-read-slave-newsrc ()
(let ((slave-files
(erase-buffer)
(setq file (nth 1 (car slave-files)))
(insert-file-contents file)
- (if (condition-case ()
- (progn
- (eval-buffer (current-buffer))
- t)
- (error
- (gnus-error 3.2 "Possible error in %s" file)
- nil))
- (or gnus-slave ; Slaves shouldn't delete these files.
- (condition-case ()
- (delete-file file)
- (error nil))))
+ (when (condition-case ()
+ (progn
+ (eval-buffer (current-buffer))
+ t)
+ (error
+ (gnus-error 3.2 "Possible error in %s" file)
+ nil))
+ (unless gnus-slave ; Slaves shouldn't delete these files.
+ (ignore-errors
+ (delete-file file))))
(setq slave-files (cdr slave-files))))
+ (gnus-dribble-touch)
(gnus-message 7 "Reading slave newsrcs...done"))))
\f
;;;
(defun gnus-read-all-descriptions-files ()
- (let ((methods (cons gnus-select-method
+ (let ((methods (cons gnus-select-method
(nconc
(when (gnus-archive-server-wanted-p)
(list "archive"))
(setq method (gnus-server-to-method method)))
;; We create the hashtable whether we manage to read the desc file
;; to avoid trying to re-read after a failed read.
- (or gnus-description-hashtb
- (setq gnus-description-hashtb
- (gnus-make-hashtable (length gnus-active-hashtb))))
+ (unless gnus-description-hashtb
+ (setq gnus-description-hashtb
+ (gnus-make-hashtable (length gnus-active-hashtb))))
;; Mark this method's desc file as read.
(gnus-sethash (gnus-group-prefixed-name "" method) "Has read"
gnus-description-hashtb)
(narrow-to-region (point-min) (point)))
;; If these are groups from a foreign select method, we insert the
;; group prefix in front of the group names.
- (and method (not (gnus-server-equal
- (gnus-server-get-method nil method)
- (gnus-server-get-method nil gnus-select-method)))
+ (and method (not (inline
+ (gnus-server-equal
+ (gnus-server-get-method nil method)
+ (gnus-server-get-method
+ nil gnus-select-method))))
(let ((prefix (gnus-group-prefixed-name "" method)))
(goto-char (point-min))
(while (and (not (eobp))
(error 0)))
(skip-chars-forward " \t")
;; ... which leads to this line being effectively ignored.
- (and (symbolp group)
- (set group (buffer-substring
- (point) (progn (end-of-line) (point)))))
+ (when (symbolp group)
+ (let ((str (buffer-substring
+ (point) (progn (end-of-line) (point))))
+ (coding
+ (and (boundp 'enable-multibyte-characters)
+ enable-multibyte-characters
+ (fboundp 'gnus-mule-get-coding-system)
+ (gnus-mule-get-coding-system (symbol-name group)))))
+ (if coding
+ (setq str (gnus-decode-coding-string str (car coding))))
+ (set group str)))
(forward-line 1))))
(gnus-message 5 "Reading descriptions file...done")
t))))
(defun gnus-set-default-directory ()
"Set the default directory in the current buffer to `gnus-default-directory'.
If this variable is nil, don't do anything."
- (setq default-directory
+ (setq default-directory
(if (and gnus-default-directory
(file-exists-p gnus-default-directory))
(file-name-as-directory (expand-file-name gnus-default-directory))
projects / gnus / blobdiff