* simple.el (shell-command-to-string): Use `process-file'.
[bpt/emacs.git] / lisp / gnus / gnus-start.el
CommitLineData
eec82323 1;;; gnus-start.el --- startup functions for Gnus
e84b4b86 2
73b0cd50 3;; Copyright (C) 1996-2011 Free Software Foundation, Inc.
eec82323 4
6748645f 5;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
eec82323
LMI
6;; Keywords: news
7
8;; This file is part of GNU Emacs.
9
5e809f55 10;; GNU Emacs is free software: you can redistribute it and/or modify
eec82323 11;; it under the terms of the GNU General Public License as published by
5e809f55
GM
12;; the Free Software Foundation, either version 3 of the License, or
13;; (at your option) any later version.
eec82323
LMI
14
15;; GNU Emacs is distributed in the hope that it will be useful,
16;; but WITHOUT ANY WARRANTY; without even the implied warranty of
de768922 17;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
eec82323
LMI
18;; GNU General Public License for more details.
19
20;; You should have received a copy of the GNU General Public License
5e809f55 21;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
eec82323
LMI
22
23;;; Commentary:
24
25;;; Code:
26
27(require 'gnus)
28(require 'gnus-win)
29(require 'gnus-int)
30(require 'gnus-spec)
31(require 'gnus-range)
32(require 'gnus-util)
23f87bed
MB
33(autoload 'message-make-date "message")
34(autoload 'gnus-agent-read-servers-validate "gnus-agent")
54506618 35(autoload 'gnus-agent-save-local "gnus-agent")
23f87bed 36(autoload 'gnus-agent-possibly-alter-active "gnus-agent")
54506618 37
bf247b6e 38(eval-when-compile
9efa445f 39 (require 'cl))
54506618 40
9efa445f
DN
41(defvar gnus-agent-covered-methods)
42(defvar gnus-agent-file-loading-local)
43(defvar gnus-agent-file-loading-cache)
eec82323
LMI
44
45(defcustom gnus-startup-file (nnheader-concat gnus-home-directory ".newsrc")
46 "Your `.newsrc' file.
47`.newsrc-SERVER' will be used instead if that exists."
48 :group 'gnus-start
49 :type 'file)
50
23f87bed 51(defcustom gnus-backup-startup-file 'never
bf46b4d4 52 "Control use of version numbers for backups of `gnus-startup-file'.
23f87bed
MB
53This variable takes the same values as the `version-control'
54variable."
bf247b6e 55 :version "22.1"
23f87bed
MB
56 :group 'gnus-start
57 :type '(choice (const :tag "Never" never)
58 (const :tag "If existing" nil)
59 (other :tag "Always" t)))
60
61(defcustom gnus-save-startup-file-via-temp-buffer t
62 "Whether to write the startup file contents to a buffer then save
63the buffer or write directly to the file. The buffer is faster
64because all of the contents are written at once. The direct write
65uses considerably less memory."
bf247b6e 66 :version "22.1"
23f87bed
MB
67 :group 'gnus-start
68 :type '(choice (const :tag "Write via buffer" t)
69 (const :tag "Write directly to file" nil)))
70
eec82323 71(defcustom gnus-init-file (nnheader-concat gnus-home-directory ".gnus")
83be5c8c
RS
72 "Your Gnus Emacs-Lisp startup file name.
73If a file with the `.el' or `.elc' suffixes exists, it will be read instead."
eec82323
LMI
74 :group 'gnus-start
75 :type 'file)
76
77(defcustom gnus-site-init-file
cb75201b 78 (condition-case nil
83be5c8c
RS
79 (concat (file-name-directory
80 (directory-file-name installation-directory))
81 "site-lisp/gnus-init")
cb75201b 82 (error nil))
16409b0b 83 "The site-wide Gnus Emacs-Lisp startup file name, or nil if none.
83be5c8c 84If a file with the `.el' or `.elc' suffixes exists, it will be read instead."
eec82323 85 :group 'gnus-start
83be5c8c 86 :type '(choice file (const nil)))
eec82323 87
eec82323
LMI
88(defcustom gnus-use-dribble-file t
89 "*Non-nil means that Gnus will use a dribble file to store user updates.
90If Emacs should crash without saving the .newsrc files, complete
91information can be restored from the dribble file."
92 :group 'gnus-dribble-file
93 :type 'boolean)
94
95(defcustom gnus-dribble-directory nil
96 "*The directory where dribble files will be saved.
97If this variable is nil, the directory where the .newsrc files are
98saved will be used."
99 :group 'gnus-dribble-file
100 :type '(choice directory (const nil)))
101
a8151ef7 102(defcustom gnus-check-new-newsgroups 'ask-server
6748645f 103 "*Non-nil means that Gnus will run `gnus-find-new-newsgroups' at startup.
eec82323
LMI
104This normally finds new newsgroups by comparing the active groups the
105servers have already reported with those Gnus already knows, either alive
106or killed.
107
6748645f 108When any of the following are true, `gnus-find-new-newsgroups' will instead
eec82323
LMI
109ask the servers (primary, secondary, and archive servers) to list new
110groups since the last time it checked:
111 1. This variable is `ask-server'.
112 2. This variable is a list of select methods (see below).
113 3. `gnus-read-active-file' is nil or `some'.
6748645f 114 4. A prefix argument is given to `gnus-find-new-newsgroups' interactively.
eec82323
LMI
115
116Thus, if this variable is `ask-server' or a list of select methods or
117`gnus-read-active-file' is nil or `some', then the killed list is no
118longer necessary, so you could safely set `gnus-save-killed-list' to nil.
119
120This variable can be a list of select methods which Gnus will query with
121the `ask-server' method in addition to the primary, secondary, and archive
122servers.
123
124Eg.
125 (setq gnus-check-new-newsgroups
126 '((nntp \"some.server\") (nntp \"other.server\")))
127
128If this variable is nil, then you have to tell Gnus explicitly to
129check for new newsgroups with \\<gnus-group-mode-map>\\[gnus-find-new-newsgroups]."
130 :group 'gnus-start
131 :type '(choice (const :tag "no" nil)
132 (const :tag "by brute force" t)
133 (const :tag "ask servers" ask-server)
134 (repeat :menu-tag "ask additional servers"
135 :tag "ask additional servers"
136 :value ((nntp ""))
137 (sexp :format "%v"))))
138
139(defcustom gnus-check-bogus-newsgroups nil
140 "*Non-nil means that Gnus will check and remove bogus newsgroup at startup.
141If this variable is nil, then you have to tell Gnus explicitly to
142check for bogus newsgroups with \\<gnus-group-mode-map>\\[gnus-group-check-bogus-groups]."
143 :group 'gnus-start-server
144 :type 'boolean)
145
a8151ef7 146(defcustom gnus-read-active-file 'some
eec82323
LMI
147 "*Non-nil means that Gnus will read the entire active file at startup.
148If this variable is nil, Gnus will only know about the groups in your
149`.newsrc' file.
150
151If this variable is `some', Gnus will try to only read the relevant
152parts of the active file from the server. Not all servers support
153this, and it might be quite slow with other servers, but this should
154generally be faster than both the t and nil value.
155
156If you set this variable to nil or `some', you probably still want to
157be told about new newsgroups that arrive. To do that, set
158`gnus-check-new-newsgroups' to `ask-server'. This may not work
159properly with all servers."
160 :group 'gnus-start-server
161 :type '(choice (const nil)
162 (const some)
163 (const t)))
164
16409b0b
GM
165(defconst gnus-level-subscribed 5
166 "Groups with levels less than or equal to this variable are subscribed.")
eec82323 167
16409b0b
GM
168(defconst gnus-level-unsubscribed 7
169 "Groups with levels less than or equal to this variable are unsubscribed.
60b0b668
MB
170
171Groups with levels less than `gnus-level-subscribed', which
172should be less than this variable, are subscribed. Groups with
173levels from `gnus-level-subscribed' (exclusive) upto this
174variable (inclusive) are unsubscribed. See also
e1b9db1a 175`gnus-level-zombie', `gnus-level-killed' and the Info node `(gnus)Group
60b0b668 176Levels' for details.")
eec82323 177
16409b0b
GM
178(defconst gnus-level-zombie 8
179 "Groups with this level are zombie groups.")
eec82323 180
16409b0b
GM
181(defconst gnus-level-killed 9
182 "Groups with this level are killed.")
eec82323
LMI
183
184(defcustom gnus-level-default-subscribed 3
185 "*New subscribed groups will be subscribed at this level."
186 :group 'gnus-group-levels
187 :type 'integer)
188
189(defcustom gnus-level-default-unsubscribed 6
190 "*New unsubscribed groups will be unsubscribed at this level."
191 :group 'gnus-group-levels
192 :type 'integer)
193
194(defcustom gnus-activate-level (1+ gnus-level-subscribed)
195 "*Groups higher than this level won't be activated on startup.
196Setting this variable to something low might save lots of time when
197you have many groups that you aren't interested in."
198 :group 'gnus-group-levels
199 :type 'integer)
200
201(defcustom gnus-activate-foreign-newsgroups 4
202 "*If nil, Gnus will not check foreign newsgroups at startup.
203If it is non-nil, it should be a number between one and nine. Foreign
204newsgroups that have a level lower or equal to this number will be
205activated on startup. For instance, if you want to active all
206subscribed newsgroups, but not the rest, you'd set this variable to
207`gnus-level-subscribed'.
208
209If you subscribe to lots of newsgroups from different servers, startup
210might take a while. By setting this variable to nil, you'll save time,
211but you won't be told how many unread articles there are in the
212groups."
213 :group 'gnus-group-levels
6748645f
LMI
214 :type '(choice integer
215 (const :tag "none" nil)))
eec82323 216
16409b0b
GM
217(defcustom gnus-read-newsrc-file t
218 "*Non-nil means that Gnus will read the `.newsrc' file.
219Gnus always reads its own startup file, which is called
220\".newsrc.eld\". The file called \".newsrc\" is in a format that can
221be readily understood by other newsreaders. If you don't plan on
222using other newsreaders, set this variable to nil to save some time on
223entry."
0e5f03c1 224 :version "21.1"
16409b0b
GM
225 :group 'gnus-newsrc
226 :type 'boolean)
227
eec82323
LMI
228(defcustom gnus-save-newsrc-file t
229 "*Non-nil means that Gnus will save the `.newsrc' file.
230Gnus always saves its own startup file, which is called
231\".newsrc.eld\". The file called \".newsrc\" is in a format that can
232be readily understood by other newsreaders. If you don't plan on
233using other newsreaders, set this variable to nil to save some time on
234exit."
235 :group 'gnus-newsrc
236 :type 'boolean)
237
238(defcustom gnus-save-killed-list t
239 "*If non-nil, save the list of killed groups to the startup file.
240If you set this variable to nil, you'll save both time (when starting
241and quitting) and space (both memory and disk), but it will also mean
242that Gnus has no record of which groups are new and which are old, so
243the automatic new newsgroups subscription methods become meaningless.
244
245You should always set `gnus-check-new-newsgroups' to `ask-server' or
246nil if you set this variable to nil.
247
248This variable can also be a regexp. In that case, all groups that do
249not match this regexp will be removed before saving the list."
250 :group 'gnus-newsrc
23f87bed
MB
251 :type '(radio (sexp :format "Non-nil\n"
252 :match (lambda (widget value)
253 (and value (not (stringp value))))
254 :value t)
255 (const nil)
ad136a7c 256 regexp))
eec82323
LMI
257
258(defcustom gnus-ignored-newsgroups
16409b0b
GM
259 (mapconcat 'identity
260 '("^to\\." ; not "real" groups
23f87bed 261 "^[0-9. \t]+\\( \\|$\\)" ; all digits in name
bdaa75c7 262 "^[\"][\"#'()]" ; bogus characters
16409b0b
GM
263 )
264 "\\|")
6748645f 265 "*A regexp to match uninteresting newsgroups in the active file.
eec82323
LMI
266Any lines in the active file matching this regular expression are
267removed from the newsgroup list before anything else is done to it,
268thus making them effectively non-existent."
269 :group 'gnus-group-new
270 :type 'regexp)
271
272(defcustom gnus-subscribe-newsgroup-method 'gnus-subscribe-zombies
23f87bed 273 "*Function(s) called with a group name when new group is detected.
eec82323
LMI
274A few pre-made functions are supplied: `gnus-subscribe-randomly'
275inserts new groups at the beginning of the list of groups;
276`gnus-subscribe-alphabetically' inserts new groups in strict
277alphabetic order; `gnus-subscribe-hierarchically' inserts new groups
278in hierarchical newsgroup order; `gnus-subscribe-interactively' asks
279for your decision; `gnus-subscribe-killed' kills all new groups;
16409b0b
GM
280`gnus-subscribe-zombies' will make all new groups into zombies;
281`gnus-subscribe-topics' will enter groups into the topics that
282claim them."
eec82323
LMI
283 :group 'gnus-group-new
284 :type '(radio (function-item gnus-subscribe-randomly)
285 (function-item gnus-subscribe-alphabetically)
286 (function-item gnus-subscribe-hierarchically)
287 (function-item gnus-subscribe-interactively)
288 (function-item gnus-subscribe-killed)
289 (function-item gnus-subscribe-zombies)
16409b0b 290 (function-item gnus-subscribe-topics)
23f87bed
MB
291 function
292 (repeat function)))
293
294(defcustom gnus-subscribe-newsgroup-hooks nil
295 "*Hooks run after you subscribe to a new group.
296The hooks will be called with new group's name as argument."
bf247b6e 297 :version "22.1"
23f87bed
MB
298 :group 'gnus-group-new
299 :type 'hook)
eec82323 300
eec82323
LMI
301(defcustom gnus-subscribe-options-newsgroup-method
302 'gnus-subscribe-alphabetically
23f87bed 303 "*Function(s) called to subscribe newsgroups mentioned on \"options -n\" lines.
eec82323
LMI
304If, for instance, you want to subscribe to all newsgroups in the
305\"no\" and \"alt\" hierarchies, you'd put the following in your
306.newsrc file:
307
308options -n no.all alt.all
309
763bb2d4
MB
310Gnus will then subscribe all new newsgroups in these hierarchies
311with the subscription method in this variable."
eec82323
LMI
312 :group 'gnus-group-new
313 :type '(radio (function-item gnus-subscribe-randomly)
314 (function-item gnus-subscribe-alphabetically)
315 (function-item gnus-subscribe-hierarchically)
316 (function-item gnus-subscribe-interactively)
317 (function-item gnus-subscribe-killed)
318 (function-item gnus-subscribe-zombies)
23f87bed
MB
319 (function-item gnus-subscribe-topics)
320 function
321 (repeat function)))
eec82323
LMI
322
323(defcustom gnus-subscribe-hierarchical-interactive nil
324 "*If non-nil, Gnus will offer to subscribe hierarchically.
325When a new hierarchy appears, Gnus will ask the user:
326
327'alt.binaries': Do you want to subscribe to this hierarchy? ([d]ys):
328
329If the user pressed `d', Gnus will descend the hierarchy, `y' will
330subscribe to all newsgroups in the hierarchy and `s' will skip this
331hierarchy in its entirety."
332 :group 'gnus-group-new
333 :type 'boolean)
334
7410c270
G
335(defcustom gnus-auto-subscribed-categories '(mail post-mail)
336 "*New groups from methods of these categories will be subscribed automatically.
337Note that this variable only deals with new groups. It has no
338effect whatsoever on old groups. The default is to automatically
339subscribe all groups from mail-like backends."
340 :version "24.1"
341 :group 'gnus-group-new
342 :type '(repeat symbol))
343
eec82323 344(defcustom gnus-auto-subscribed-groups
7410c270 345 "^nnml\\|^nnfolder\\|^nnmbox\\|^nnmh\\|^nnbabyl\\|^nnmaildir\\|^nnimap"
eec82323
LMI
346 "*All new groups that match this regexp will be subscribed automatically.
347Note that this variable only deals with new groups. It has no effect
348whatsoever on old groups.
349
350New groups that match this regexp will not be handled by
351`gnus-subscribe-newsgroup-method'. Instead, they will
352be subscribed using `gnus-subscribe-options-newsgroup-method'."
353 :group 'gnus-group-new
354 :type 'regexp)
355
356(defcustom gnus-options-subscribe nil
357 "*All new groups matching this regexp will be subscribed unconditionally.
de768922 358Note that this variable deals only with new newsgroups. This variable
eec82323
LMI
359does not affect old newsgroups.
360
361New groups that match this regexp will not be handled by
362`gnus-subscribe-newsgroup-method'. Instead, they will
363be subscribed using `gnus-subscribe-options-newsgroup-method'."
364 :group 'gnus-group-new
365 :type '(choice regexp
366 (const :tag "none" nil)))
367
368(defcustom gnus-options-not-subscribe nil
369 "*All new groups matching this regexp will be ignored.
de768922 370Note that this variable deals only with new newsgroups. This variable
eec82323
LMI
371does not affect old (already subscribed) newsgroups."
372 :group 'gnus-group-new
373 :type '(choice regexp
374 (const :tag "none" nil)))
375
376(defcustom gnus-modtime-botch nil
377 "*Non-nil means .newsrc should be deleted prior to save.
378Its use is due to the bogus appearance that .newsrc was modified on
379disc."
380 :group 'gnus-newsrc
381 :type 'boolean)
382
383(defcustom gnus-check-bogus-groups-hook nil
384 "A hook run after removing bogus groups."
385 :group 'gnus-start-server
386 :type 'hook)
387
388(defcustom gnus-startup-hook nil
389 "A hook called at startup.
390This hook is called after Gnus is connected to the NNTP server."
391 :group 'gnus-start
392 :type 'hook)
393
6748645f 394(defcustom gnus-before-startup-hook nil
e3e955fe 395 "A hook called before startup.
6748645f
LMI
396This hook is called as the first thing when Gnus is started."
397 :group 'gnus-start
398 :type 'hook)
399
eec82323
LMI
400(defcustom gnus-started-hook nil
401 "A hook called as the last thing after startup."
402 :group 'gnus-start
403 :type 'hook)
404
b1ae92ba 405(defcustom gnus-setup-news-hook nil
6748645f
LMI
406 "A hook after reading the .newsrc file, but before generating the buffer."
407 :group 'gnus-start
408 :type 'hook)
409
23f87bed
MB
410(defcustom gnus-get-top-new-news-hook nil
411 "A hook run just before Gnus checks for new news globally."
bf247b6e 412 :version "22.1"
23f87bed
MB
413 :group 'gnus-group-new
414 :type 'hook)
415
eec82323
LMI
416(defcustom gnus-get-new-news-hook nil
417 "A hook run just before Gnus checks for new news."
418 :group 'gnus-group-new
419 :type 'hook)
420
421(defcustom gnus-after-getting-new-news-hook
b1ae92ba 422 '(gnus-display-time-event-handler)
16409b0b 423 "*A hook run after Gnus checks for new news when Gnus is already running."
3431395c 424 :version "24.1"
eec82323
LMI
425 :group 'gnus-group-new
426 :type 'hook)
427
23f87bed
MB
428(defcustom gnus-read-newsrc-el-hook nil
429 "A hook called after reading the newsrc.eld? file."
430 :group 'gnus-newsrc
431 :type 'hook)
432
eec82323
LMI
433(defcustom gnus-save-newsrc-hook nil
434 "A hook called before saving any of the newsrc files."
435 :group 'gnus-newsrc
436 :type 'hook)
437
438(defcustom gnus-save-quick-newsrc-hook nil
439 "A hook called just before saving the quick newsrc file.
440Can be used to turn version control on or off."
441 :group 'gnus-newsrc
442 :type 'hook)
443
444(defcustom gnus-save-standard-newsrc-hook nil
445 "A hook called just before saving the standard newsrc file.
446Can be used to turn version control on or off."
447 :group 'gnus-newsrc
448 :type 'hook)
449
23f87bed
MB
450(defcustom gnus-group-mode-hook nil
451 "Hook for Gnus group mode."
452 :group 'gnus-group-various
453 :options '(gnus-topic-mode)
454 :type 'hook)
455
6748645f 456(defcustom gnus-always-read-dribble-file nil
16409b0b 457 "Unconditionally read the dribble file."
6748645f
LMI
458 :group 'gnus-newsrc
459 :type 'boolean)
460
2d2820a4
GM
461;;; Internal variables
462
eb75e087
DL
463;; Fixme: deal with old emacs-mule when mm-universal-coding-system is
464;; utf-8-emacs.
39d74434
SZ
465(defvar gnus-ding-file-coding-system mm-universal-coding-system
466 "Coding system for ding file.")
eec82323
LMI
467
468(defvar gnus-newsrc-file-version nil)
469(defvar gnus-override-subscribe-method nil)
470(defvar gnus-dribble-buffer nil)
471(defvar gnus-newsrc-options nil
472 "Options line in the .newsrc file.")
473
474(defvar gnus-newsrc-options-n nil
475 "List of regexps representing groups to be subscribed/ignored unconditionally.")
476
477(defvar gnus-newsrc-last-checked-date nil
478 "Date Gnus last asked server for new newsgroups.")
479
480(defvar gnus-current-startup-file nil
481 "Startup file for the current host.")
482
483;; Byte-compiler warning.
484(defvar gnus-group-line-format)
485
486;; Suggested by Brian Edmonds <edmonds@cs.ubc.ca>.
487(defvar gnus-init-inhibit nil)
488(defun gnus-read-init-file (&optional inhibit-next)
489 ;; Don't load .gnus if the -q option was used.
490 (when init-file-user
491 (if gnus-init-inhibit
492 (setq gnus-init-inhibit nil)
493 (setq gnus-init-inhibit inhibit-next)
39d74434
SZ
494 (dolist (file (list gnus-site-init-file gnus-init-file))
495 (when (and file
496 (locate-library file))
497 (if (or debug-on-error debug-on-quit)
498 (load file nil t)
499 (condition-case var
500 (load file nil t)
501 (error
23f87bed 502 (error "Error in %s: %s" file (cadr var))))))))))
eec82323
LMI
503
504;; For subscribing new newsgroup
505
506(defun gnus-subscribe-hierarchical-interactive (groups)
507 (let ((groups (sort groups 'string<))
01c52d31 508 prefixes prefix start ans group starts real-group)
eec82323
LMI
509 (while groups
510 (setq prefixes (list "^"))
511 (while (and groups prefixes)
01c52d31
MB
512 (while (not (string-match (car prefixes)
513 (gnus-group-real-name (car groups))))
eec82323
LMI
514 (setq prefixes (cdr prefixes)))
515 (setq prefix (car prefixes))
516 (setq start (1- (length prefix)))
01c52d31
MB
517 (if (and (string-match "[^\\.]\\." (gnus-group-real-name (car groups))
518 start)
eec82323
LMI
519 (cdr groups)
520 (setq prefix
01c52d31
MB
521 (concat "^" (substring
522 (gnus-group-real-name (car groups))
523 0 (match-end 0))))
524 (string-match prefix (gnus-group-real-name (cadr groups))))
eec82323
LMI
525 (progn
526 (push prefix prefixes)
527 (message "Descend hierarchy %s? ([y]nsq): "
528 (substring prefix 1 (1- (length prefix))))
6748645f
LMI
529 (while (not (memq (setq ans (read-char-exclusive))
530 '(?y ?\n ?\r ?n ?s ?q)))
eec82323
LMI
531 (ding)
532 (message "Descend hierarchy %s? ([y]nsq): "
533 (substring prefix 1 (1- (length prefix)))))
534 (cond ((= ans ?n)
535 (while (and groups
01c52d31
MB
536 (setq group (car groups)
537 real-group (gnus-group-real-name group))
538 (string-match prefix real-group))
eec82323
LMI
539 (push group gnus-killed-list)
540 (gnus-sethash group group gnus-killed-hashtb)
541 (setq groups (cdr groups)))
542 (setq starts (cdr starts)))
543 ((= ans ?s)
544 (while (and groups
01c52d31
MB
545 (setq group (car groups)
546 real-group (gnus-group-real-name group))
547 (string-match prefix real-group))
eec82323
LMI
548 (gnus-sethash group group gnus-killed-hashtb)
549 (gnus-subscribe-alphabetically (car groups))
550 (setq groups (cdr groups)))
551 (setq starts (cdr starts)))
552 ((= ans ?q)
553 (while groups
554 (setq group (car groups))
555 (push group gnus-killed-list)
556 (gnus-sethash group group gnus-killed-hashtb)
557 (setq groups (cdr groups))))
558 (t nil)))
559 (message "Subscribe %s? ([n]yq)" (car groups))
6748645f
LMI
560 (while (not (memq (setq ans (read-char-exclusive))
561 '(?y ?\n ?\r ?q ?n)))
eec82323
LMI
562 (ding)
563 (message "Subscribe %s? ([n]yq)" (car groups)))
564 (setq group (car groups))
565 (cond ((= ans ?y)
566 (gnus-subscribe-alphabetically (car groups))
567 (gnus-sethash group group gnus-killed-hashtb))
568 ((= ans ?q)
569 (while groups
570 (setq group (car groups))
571 (push group gnus-killed-list)
572 (gnus-sethash group group gnus-killed-hashtb)
573 (setq groups (cdr groups))))
574 (t
575 (push group gnus-killed-list)
576 (gnus-sethash group group gnus-killed-hashtb)))
577 (setq groups (cdr groups)))))))
578
579(defun gnus-subscribe-randomly (newsgroup)
580 "Subscribe new NEWSGROUP by making it the first newsgroup."
581 (gnus-subscribe-newsgroup newsgroup))
582
583(defun gnus-subscribe-alphabetically (newgroup)
23f87bed 584 "Subscribe new NEWGROUP and insert it in alphabetical order."
eec82323
LMI
585 (let ((groups (cdr gnus-newsrc-alist))
586 before)
587 (while (and (not before) groups)
588 (if (string< newgroup (caar groups))
589 (setq before (caar groups))
590 (setq groups (cdr groups))))
591 (gnus-subscribe-newsgroup newgroup before)))
592
593(defun gnus-subscribe-hierarchically (newgroup)
23f87bed 594 "Subscribe new NEWGROUP and insert it in hierarchical newsgroup order."
eec82323 595 ;; Basic ideas by mike-w@cs.aukuni.ac.nz (Mike Williams)
20a673b2 596 (with-current-buffer (nnheader-find-file-noselect gnus-current-startup-file)
23f87bed
MB
597 (prog1
598 (let ((groupkey newgroup) before)
599 (while (and (not before) groupkey)
600 (goto-char (point-min))
601 (let ((groupkey-re
602 (concat "^\\(" (regexp-quote groupkey) ".*\\)[!:]")))
603 (while (and (re-search-forward groupkey-re nil t)
604 (progn
605 (setq before (match-string 1))
606 (string< before newgroup)))))
607 ;; Remove tail of newsgroup name (eg. a.b.c -> a.b)
608 (setq groupkey
609 (when (string-match "^\\(.*\\)\\.[^.]+$" groupkey)
610 (substring groupkey (match-beginning 1) (match-end 1)))))
611 (gnus-subscribe-newsgroup newgroup before))
612 (kill-buffer (current-buffer)))))
eec82323
LMI
613
614(defun gnus-subscribe-interactively (group)
615 "Subscribe the new GROUP interactively.
616It is inserted in hierarchical newsgroup order if subscribed. If not,
617it is killed."
66841476 618 (if (gnus-y-or-n-p (format "Subscribe new newsgroup %s? " group))
eec82323
LMI
619 (gnus-subscribe-hierarchically group)
620 (push group gnus-killed-list)))
621
622(defun gnus-subscribe-zombies (group)
623 "Make the new GROUP into a zombie group."
624 (push group gnus-zombie-list))
625
626(defun gnus-subscribe-killed (group)
627 "Make the new GROUP a killed group."
628 (push group gnus-killed-list))
629
630(defun gnus-subscribe-newsgroup (newsgroup &optional next)
631 "Subscribe new NEWSGROUP.
de768922 632If NEXT is non-nil, it is inserted before NEXT. Otherwise it is made
eec82323
LMI
633the first newsgroup."
634 (save-excursion
635 (goto-char (point-min))
636 ;; We subscribe the group by changing its level to `subscribed'.
637 (gnus-group-change-level
638 newsgroup gnus-level-default-subscribed
01c52d31 639 gnus-level-killed (gnus-group-entry (or next "dummy.group")))
549c9aed 640 (gnus-request-update-group-status newsgroup 'subscribe)
23f87bed
MB
641 (gnus-message 5 "Subscribe newsgroup: %s" newsgroup)
642 (run-hook-with-args 'gnus-subscribe-newsgroup-hooks newsgroup)
643 t))
eec82323
LMI
644
645(defun gnus-read-active-file-p ()
646 "Say whether the active file has been read from `gnus-select-method'."
647 (memq gnus-select-method gnus-have-read-active-file))
648
649;;; General various misc type functions.
650
651;; Silence byte-compiler.
9efa445f
DN
652(defvar gnus-current-headers)
653(defvar gnus-thread-indent-array)
654(defvar gnus-newsgroup-name)
655(defvar gnus-newsgroup-headers)
656(defvar gnus-group-list-mode)
657(defvar gnus-group-mark-positions)
658(defvar gnus-newsgroup-data)
659(defvar gnus-newsgroup-unreads)
660(defvar nnoo-state-alist)
661(defvar gnus-current-select-method)
662(defvar mail-sources)
663(defvar nnmail-scan-directory-mail-source-once)
664(defvar nnmail-split-history)
665(defvar nnmail-spool-file)
23f87bed
MB
666
667(defun gnus-close-all-servers ()
668 "Close all servers."
669 (interactive)
670 (dolist (server gnus-opened-servers)
671 (gnus-close-server (car server))))
6748645f 672
eec82323
LMI
673(defun gnus-clear-system ()
674 "Clear all variables and buffers."
675 ;; Clear Gnus variables.
23f87bed 676 (let ((variables (remove 'gnus-format-specs gnus-variable-list)))
eec82323
LMI
677 (while variables
678 (set (car variables) nil)
679 (setq variables (cdr variables))))
680 ;; Clear other internal variables.
681 (setq gnus-list-of-killed-groups nil
682 gnus-have-read-active-file nil
23f87bed 683 gnus-agent-covered-methods nil
54506618
MB
684 gnus-agent-file-loading-local nil
685 gnus-agent-file-loading-cache nil
23f87bed 686 gnus-server-method-cache nil
eec82323
LMI
687 gnus-newsrc-alist nil
688 gnus-newsrc-hashtb nil
689 gnus-killed-list nil
690 gnus-zombie-list nil
691 gnus-killed-hashtb nil
692 gnus-active-hashtb nil
693 gnus-moderated-hashtb nil
694 gnus-description-hashtb nil
695 gnus-current-headers nil
696 gnus-thread-indent-array nil
697 gnus-newsgroup-headers nil
698 gnus-newsgroup-name nil
699 gnus-server-alist nil
700 gnus-group-list-mode nil
701 gnus-opened-servers nil
702 gnus-group-mark-positions nil
703 gnus-newsgroup-data nil
704 gnus-newsgroup-unreads nil
705 nnoo-state-alist nil
6748645f 706 gnus-current-select-method nil
16409b0b 707 nnmail-split-history nil
0617bb00 708 gnus-extended-servers nil
6748645f 709 gnus-ephemeral-servers nil)
eec82323
LMI
710 (gnus-shutdown 'gnus)
711 ;; Kill the startup file.
712 (and gnus-current-startup-file
713 (get-file-buffer gnus-current-startup-file)
714 (kill-buffer (get-file-buffer gnus-current-startup-file)))
715 ;; Clear the dribble buffer.
716 (gnus-dribble-clear)
717 ;; Kill global KILL file buffer.
718 (when (get-file-buffer (gnus-newsgroup-kill-file nil))
719 (kill-buffer (get-file-buffer (gnus-newsgroup-kill-file nil))))
720 (gnus-kill-buffer nntp-server-buffer)
721 ;; Kill Gnus buffers.
23f87bed
MB
722 (dolist (buffer (gnus-buffers))
723 (gnus-kill-buffer buffer))
eec82323
LMI
724 ;; Remove Gnus frames.
725 (gnus-kill-gnus-frames))
726
727(defun gnus-no-server-1 (&optional arg slave)
728 "Read network news.
3031d8b0
MB
729If ARG is a positive number, Gnus will use that as the startup
730level. If ARG is nil, Gnus will be started at level 2
731\(`gnus-level-default-subscribed' minus one). If ARG is non-nil
732and not a positive number, Gnus will prompt the user for the name
733of an NNTP server to use. As opposed to \\[gnus], this command
734will not connect to the local server."
eec82323
LMI
735 (interactive "P")
736 (let ((val (or arg (1- gnus-level-default-subscribed))))
737 (gnus val t slave)
738 (make-local-variable 'gnus-group-use-permanent-levels)
739 (setq gnus-group-use-permanent-levels val)))
740
741(defun gnus-1 (&optional arg dont-connect slave)
742 "Read network news.
743If ARG is non-nil and a positive number, Gnus will use that as the
de768922 744startup level. If ARG is non-nil and not a positive number, Gnus will
eec82323
LMI
745prompt the user for the name of an NNTP server to use."
746 (interactive "P")
747
6748645f 748 (if (gnus-alive-p)
eec82323
LMI
749 (progn
750 (switch-to-buffer gnus-group-buffer)
751 (gnus-group-get-new-news
752 (and (numberp arg)
753 (> arg 0)
754 (max (car gnus-group-list-mode) arg))))
755
eec82323 756 (gnus-clear-system)
6748645f
LMI
757 (gnus-splash)
758 (gnus-run-hooks 'gnus-before-startup-hook)
eec82323 759 (nnheader-init-server-buffer)
eec82323 760 (setq gnus-slave slave)
a8151ef7 761 (gnus-read-init-file)
01c52d31
MB
762
763 ;; Add "native" to gnus-predefined-server-alist just to have a
764 ;; name for the native select method.
765 (when gnus-select-method
766 (push (cons "native" gnus-select-method)
767 gnus-predefined-server-alist))
c9fc72fa 768
23f87bed
MB
769 (if gnus-agent
770 (gnus-agentize))
eec82323 771
eec82323
LMI
772 (let ((level (and (numberp arg) (> arg 0) arg))
773 did-connect)
774 (unwind-protect
775 (progn
776 (unless dont-connect
777 (setq did-connect
778 (gnus-start-news-server (and arg (not level))))))
779 (if (and (not dont-connect)
780 (not did-connect))
7410c270 781 ;; Couldn't connect to the server, so bail out.
eec82323 782 (gnus-group-quit)
6748645f 783 (gnus-run-hooks 'gnus-startup-hook)
eec82323
LMI
784 ;; Find the current startup file name.
785 (setq gnus-current-startup-file
786 (gnus-make-newsrc-file gnus-startup-file))
787
788 ;; Read the dribble file.
789 (when (or gnus-slave gnus-use-dribble-file)
790 (gnus-dribble-read-file))
791
eec82323
LMI
792 ;; Do the actual startup.
793 (gnus-setup-news nil level dont-connect)
6748645f 794 (gnus-run-hooks 'gnus-setup-news-hook)
7410c270
G
795 (when gnus-agent
796 (gnus-request-create-group "queue" '(nndraft "")))
6748645f 797 (gnus-start-draft-setup)
eec82323
LMI
798 ;; Generate the group buffer.
799 (gnus-group-list-groups level)
800 (gnus-group-first-unread-group)
801 (gnus-configure-windows 'group)
802 (gnus-group-set-mode-line)
6748645f
LMI
803 (gnus-run-hooks 'gnus-started-hook))))))
804
805(defun gnus-start-draft-setup ()
806 "Make sure the draft group exists."
4e815860 807 (interactive)
6748645f 808 (gnus-request-create-group "drafts" '(nndraft ""))
01c52d31 809 (unless (gnus-group-entry "nndraft:drafts")
6748645f 810 (let ((gnus-level-default-subscribed 1))
7410c270
G
811 (gnus-subscribe-group "nndraft:drafts" nil '(nndraft "")))
812 (setcar (gnus-group-entry "nndraft:drafts") 0))
3031d8b0
MB
813 (unless (equal (gnus-group-get-parameter "nndraft:drafts" 'gnus-dummy t)
814 '((gnus-draft-mode)))
6748645f
LMI
815 (gnus-group-set-parameter
816 "nndraft:drafts" 'gnus-dummy '((gnus-draft-mode)))))
eec82323 817
eec82323
LMI
818\f
819;;;
820;;; Dribble file
821;;;
822
823(defvar gnus-dribble-ignore nil)
824(defvar gnus-dribble-eval-file nil)
825
826(defun gnus-dribble-file-name ()
827 "Return the dribble file for the current .newsrc."
828 (concat
829 (if gnus-dribble-directory
830 (concat (file-name-as-directory gnus-dribble-directory)
831 (file-name-nondirectory gnus-current-startup-file))
832 gnus-current-startup-file)
833 "-dribble"))
834
835(defun gnus-dribble-enter (string)
836 "Enter STRING into the dribble buffer."
837 (when (and (not gnus-dribble-ignore)
838 gnus-dribble-buffer
839 (buffer-name gnus-dribble-buffer))
840 (let ((obuf (current-buffer)))
841 (set-buffer gnus-dribble-buffer)
842 (goto-char (point-max))
843 (insert string "\n")
23f87bed
MB
844 ;; This has been commented by Josh Huber <huber@alum.wpi.edu>
845 ;; It causes problems with both XEmacs and Emacs 21, and doesn't
846 ;; seem to be of much value. (FIXME: remove this after we make sure
847 ;; it's not needed).
848 ;; (set-window-point (get-buffer-window (current-buffer)) (point-max))
eec82323 849 (bury-buffer gnus-dribble-buffer)
20a673b2 850 (with-current-buffer gnus-group-buffer
6748645f 851 (gnus-group-set-mode-line))
eec82323
LMI
852 (set-buffer obuf))))
853
854(defun gnus-dribble-touch ()
855 "Touch the dribble buffer."
856 (gnus-dribble-enter ""))
857
858(defun gnus-dribble-read-file ()
859 "Read the dribble file from disk."
860 (let ((dribble-file (gnus-dribble-file-name)))
8bff7c00
KY
861 (unless (file-exists-p (file-name-directory dribble-file))
862 (make-directory (file-name-directory dribble-file) t))
20a673b2
KY
863 (with-current-buffer (setq gnus-dribble-buffer
864 (gnus-get-buffer-create
865 (file-name-nondirectory dribble-file)))
58090a8d 866 (set (make-local-variable 'file-precious-flag) t)
4a3988d5 867 (setq buffer-save-without-query t)
eec82323
LMI
868 (erase-buffer)
869 (setq buffer-file-name dribble-file)
870 (auto-save-mode t)
16409b0b 871 (buffer-disable-undo)
eec82323
LMI
872 (bury-buffer (current-buffer))
873 (set-buffer-modified-p nil)
874 (let ((auto (make-auto-save-file-name))
875 (gnus-dribble-ignore t)
23f87bed 876 (purpose nil)
eec82323
LMI
877 modes)
878 (when (or (file-exists-p auto) (file-exists-p dribble-file))
879 ;; Load whichever file is newest -- the auto save file
880 ;; or the "real" file.
881 (if (file-newer-than-file-p auto dribble-file)
882 (nnheader-insert-file-contents auto)
883 (nnheader-insert-file-contents dribble-file))
884 (unless (zerop (buffer-size))
885 (set-buffer-modified-p t))
886 ;; Set the file modes to reflect the .newsrc file modes.
887 (save-buffer)
888 (when (and (file-exists-p gnus-current-startup-file)
a8151ef7 889 (file-exists-p dribble-file)
eec82323 890 (setq modes (file-modes gnus-current-startup-file)))
01c52d31 891 (gnus-set-file-modes dribble-file modes))
23f87bed
MB
892 (goto-char (point-min))
893 (when (search-forward "Gnus was exited on purpose" nil t)
894 (setq purpose t))
eec82323 895 ;; Possibly eval the file later.
6748645f
LMI
896 (when (or gnus-always-read-dribble-file
897 (gnus-y-or-n-p
23f87bed
MB
898 (if purpose
899 "Gnus exited on purpose without saving; read auto-save file anyway? "
900 "Gnus auto-save file exists. Do you want to read it? ")))
eec82323
LMI
901 (setq gnus-dribble-eval-file t)))))))
902
903(defun gnus-dribble-eval-file ()
904 (when gnus-dribble-eval-file
905 (setq gnus-dribble-eval-file nil)
906 (save-excursion
907 (let ((gnus-dribble-ignore t))
908 (set-buffer gnus-dribble-buffer)
909 (eval-buffer (current-buffer))))))
910
911(defun gnus-dribble-delete-file ()
912 (when (file-exists-p (gnus-dribble-file-name))
913 (delete-file (gnus-dribble-file-name)))
914 (when gnus-dribble-buffer
20a673b2 915 (with-current-buffer gnus-dribble-buffer
eec82323
LMI
916 (let ((auto (make-auto-save-file-name)))
917 (when (file-exists-p auto)
918 (delete-file auto))
919 (erase-buffer)
920 (set-buffer-modified-p nil)))))
921
922(defun gnus-dribble-save ()
923 (when (and gnus-dribble-buffer
924 (buffer-name gnus-dribble-buffer))
20a673b2 925 (with-current-buffer gnus-dribble-buffer
eec82323
LMI
926 (save-buffer))))
927
928(defun gnus-dribble-clear ()
929 (when (gnus-buffer-exists-p gnus-dribble-buffer)
20a673b2 930 (with-current-buffer gnus-dribble-buffer
eec82323
LMI
931 (erase-buffer)
932 (set-buffer-modified-p nil)
933 (setq buffer-saved-size (buffer-size)))))
934
935\f
936;;;
937;;; Active & Newsrc File Handling
938;;;
939
940(defun gnus-setup-news (&optional rawfile level dont-connect)
941 "Setup news information.
942If RAWFILE is non-nil, the .newsrc file will also be read.
943If LEVEL is non-nil, the news will be set up at level LEVEL."
16409b0b
GM
944 (require 'nnmail)
945 (let ((init (not (and gnus-newsrc-alist gnus-active-hashtb (not rawfile))))
946 ;; Binding this variable will inhibit multiple fetchings
947 ;; of the same mail source.
948 (nnmail-fetched-sources (list t)))
eec82323
LMI
949
950 (when init
951 ;; Clear some variables to re-initialize news information.
952 (setq gnus-newsrc-alist nil
953 gnus-active-hashtb nil)
954 ;; Read the newsrc file and create `gnus-newsrc-hashtb'.
955 (gnus-read-newsrc-file rawfile))
956
6748645f 957 ;; Make sure the archive server is available to all and sundry.
01c52d31
MB
958 (let ((method (or (and (stringp gnus-message-archive-method)
959 (gnus-server-to-method
960 gnus-message-archive-method))
961 gnus-message-archive-method)))
962 ;; Check whether the archive method is writable.
963 (unless (or (not method)
964 (stringp method)
965 (memq 'respool (assoc (format "%s" (car method))
966 gnus-valid-select-methods)))
967 (setq method "archive")) ;; The default.
968 (when (stringp method)
969 (setq method `(nnfolder
970 ,method
971 (nnfolder-directory
972 ,(nnheader-concat message-directory method))
973 (nnfolder-active-file
974 ,(nnheader-concat message-directory
975 (concat method "/active")))
976 (nnfolder-get-new-mail nil)
977 (nnfolder-inhibit-expiry t))))
978 (if (assoc "archive" gnus-server-alist)
979 (when gnus-update-message-archive-method
980 (if method
981 (setcdr (assoc "archive" gnus-server-alist) method)
982 (setq gnus-server-alist (delq (assoc "archive" gnus-server-alist)
983 gnus-server-alist))))
984 (when method
985 (push (cons "archive" method) gnus-server-alist))))
eec82323
LMI
986
987 ;; If we don't read the complete active file, we fill in the
988 ;; hashtb here.
989 (when (or (null gnus-read-active-file)
990 (eq gnus-read-active-file 'some))
991 (gnus-update-active-hashtb-from-killed))
eec82323
LMI
992 (unless gnus-active-hashtb
993 (setq gnus-active-hashtb (gnus-make-hashtable 4096)))
eec82323
LMI
994 ;; Initialize the cache.
995 (when gnus-use-cache
996 (gnus-cache-open))
997
998 ;; Possibly eval the dribble file.
999 (and init
1000 (or gnus-use-dribble-file gnus-slave)
1001 (gnus-dribble-eval-file))
1002
1003 ;; Slave Gnusii should then clear the dribble buffer.
1004 (when (and init gnus-slave)
1005 (gnus-dribble-clear))
1006
1007 (gnus-update-format-specifications)
1008
1009 ;; See whether we need to read the description file.
1010 (when (and (boundp 'gnus-group-line-format)
23f87bed 1011 (stringp gnus-group-line-format)
a8151ef7
LMI
1012 (let ((case-fold-search nil))
1013 (string-match "%[-,0-9]*D" gnus-group-line-format))
eec82323
LMI
1014 (not gnus-description-hashtb)
1015 (not dont-connect)
1016 gnus-read-active-file)
1017 (gnus-read-all-descriptions-files))
1018
1019 ;; Find new newsgroups and treat them.
1020 (when (and init gnus-check-new-newsgroups (not level)
1021 (gnus-check-server gnus-select-method)
6748645f
LMI
1022 (not gnus-slave)
1023 gnus-plugged)
eec82323
LMI
1024 (gnus-find-new-newsgroups))
1025
23f87bed
MB
1026 ;; Check and remove bogus newsgroups.
1027 (when (and init gnus-check-bogus-newsgroups
1028 gnus-read-active-file (not level)
1029 (gnus-server-opened gnus-select-method))
1030 (gnus-check-bogus-newsgroups))
1031
eec82323
LMI
1032 ;; Read any slave files.
1033 (gnus-master-read-slave-newsrc)
1034
1035 ;; Find the number of unread articles in each non-dead group.
1036 (let ((gnus-read-active-file (and (not level) gnus-read-active-file)))
23f87bed
MB
1037 (gnus-get-unread-articles level))))
1038
1039(defun gnus-call-subscribe-functions (method group)
1040 "Call METHOD to subscribe GROUP.
1041If no function returns `non-nil', call `gnus-subscribe-zombies'."
1042 (unless (cond
1043 ((functionp method)
1044 (funcall method group))
1045 ((listp method)
1046 (catch 'found
1047 (dolist (func method)
1048 (if (funcall func group)
1049 (throw 'found t)))
1050 nil))
1051 (t nil))
1052 (gnus-subscribe-zombies group)))
eec82323
LMI
1053
1054(defun gnus-find-new-newsgroups (&optional arg)
1055 "Search for new newsgroups and add them.
16409b0b 1056Each new newsgroup will be treated with `gnus-subscribe-newsgroup-method'.
eec82323 1057The `-n' option line from .newsrc is respected.
6748645f
LMI
1058
1059With 1 C-u, use the `ask-server' method to query the server for new
1060groups.
1061With 2 C-u's, use most complete method possible to query the server
1062for new groups, and subscribe the new groups as zombies."
1063 (interactive "p")
1064 (let* ((gnus-subscribe-newsgroup-method
1065 gnus-subscribe-newsgroup-method)
1066 (check (cond
16409b0b
GM
1067 ((or (and (= (or arg 1) 4)
1068 (not (listp gnus-check-new-newsgroups)))
1069 (null gnus-read-active-file)
1070 (eq gnus-read-active-file 'some))
1071 'ask-server)
1072 ((= (or arg 1) 16)
1073 (setq gnus-subscribe-newsgroup-method
1074 'gnus-subscribe-zombies)
1075 t)
1076 (t gnus-check-new-newsgroups))))
837ba704
JD
1077 (if (or (consp check)
1078 (eq check 'ask-server))
1079 ;; Ask the server for new groups.
1080 (gnus-ask-server-for-new-groups)
1081 ;; Go through the active hashtb and look for new groups.
1082 (let ((groups 0)
1083 group new-newsgroups)
1084 (gnus-message 5 "Looking for new newsgroups...")
1085 (unless gnus-have-read-active-file
1086 (gnus-read-active-file))
1087 (setq gnus-newsrc-last-checked-date (message-make-date))
1088 (unless gnus-killed-hashtb
1089 (gnus-make-hashtable-from-killed))
1090 ;; Go though every newsgroup in `gnus-active-hashtb' and compare
1091 ;; with `gnus-newsrc-hashtb' and `gnus-killed-hashtb'.
1092 (mapatoms
1093 (lambda (sym)
1094 (if (or (null (setq group (symbol-name sym)))
1095 (not (boundp sym))
1096 (null (symbol-value sym))
1097 (gnus-gethash group gnus-killed-hashtb)
1098 (gnus-gethash group gnus-newsrc-hashtb))
1099 ()
1100 (let ((do-sub (gnus-matches-options-n group)))
1101 (cond
1102 ((eq do-sub 'subscribe)
1103 (setq groups (1+ groups))
1104 (gnus-sethash group group gnus-killed-hashtb)
1105 (gnus-call-subscribe-functions
1106 gnus-subscribe-options-newsgroup-method group))
1107 ((eq do-sub 'ignore)
1108 nil)
1109 (t
1110 (setq groups (1+ groups))
1111 (gnus-sethash group group gnus-killed-hashtb)
1112 (if gnus-subscribe-hierarchical-interactive
1113 (push group new-newsgroups)
1114 (gnus-call-subscribe-functions
1115 gnus-subscribe-newsgroup-method group)))))))
1116 gnus-active-hashtb)
1117 (when new-newsgroups
1118 (gnus-subscribe-hierarchical-interactive new-newsgroups))
1119 (if (> groups 0)
1120 (gnus-message 5 "%d new newsgroup%s arrived."
1121 groups (if (> groups 1) "s have" " has"))
9310f19d
LMI
1122 (gnus-message 5 "No new newsgroups."))
1123 groups))))
eec82323
LMI
1124
1125(defun gnus-matches-options-n (group)
1126 ;; Returns `subscribe' if the group is to be unconditionally
1127 ;; subscribed, `ignore' if it is to be ignored, and nil if there is
1128 ;; no match for the group.
1129
1130 ;; First we check the two user variables.
1131 (cond
1132 ((and gnus-options-subscribe
1133 (string-match gnus-options-subscribe group))
1134 'subscribe)
7410c270
G
1135 ((let ((do-subscribe nil))
1136 (dolist (category gnus-auto-subscribed-categories)
1137 (when (gnus-member-of-valid category group)
1138 (setq do-subscribe t)))
1139 do-subscribe)
1140 'subscribe)
eec82323
LMI
1141 ((and gnus-auto-subscribed-groups
1142 (string-match gnus-auto-subscribed-groups group))
1143 'subscribe)
1144 ((and gnus-options-not-subscribe
1145 (string-match gnus-options-not-subscribe group))
1146 'ignore)
1147 ;; Then we go through the list that was retrieved from the .newsrc
1148 ;; file. This list has elements on the form
1149 ;; `(REGEXP . {ignore,subscribe})'. The first match found (the list
1150 ;; is in the reverse order of the options line) is returned.
1151 (t
1152 (let ((regs gnus-newsrc-options-n))
1153 (while (and regs
1154 (not (string-match (caar regs) group)))
1155 (setq regs (cdr regs)))
1156 (and regs (cdar regs))))))
1157
1158(defun gnus-ask-server-for-new-groups ()
7c972da0
GM
1159 (let* ((new-date (message-make-date))
1160 (date (or gnus-newsrc-last-checked-date new-date))
eec82323
LMI
1161 (methods (cons gnus-select-method
1162 (nconc
1163 (when (gnus-archive-server-wanted-p)
1164 (list "archive"))
1165 (append
1166 (and (consp gnus-check-new-newsgroups)
1167 gnus-check-new-newsgroups)
1168 gnus-secondary-select-methods))))
1169 (groups 0)
eec82323
LMI
1170 group new-newsgroups got-new method hashtb
1171 gnus-override-subscribe-method)
6748645f
LMI
1172 (unless gnus-killed-hashtb
1173 (gnus-make-hashtable-from-killed))
eec82323
LMI
1174 ;; Go through both primary and secondary select methods and
1175 ;; request new newsgroups.
1176 (while (setq method (gnus-server-get-method nil (pop methods)))
6748645f
LMI
1177 (setq new-newsgroups nil
1178 gnus-override-subscribe-method method)
eec82323
LMI
1179 (when (and (gnus-check-server method)
1180 (gnus-request-newgroups date method))
1181 (save-excursion
6748645f
LMI
1182 (setq got-new t
1183 hashtb (gnus-make-hashtable 100))
eec82323
LMI
1184 (set-buffer nntp-server-buffer)
1185 ;; Enter all the new groups into a hashtable.
1186 (gnus-active-to-gnus-format method hashtb 'ignore))
1187 ;; Now all new groups from `method' are in `hashtb'.
1188 (mapatoms
1189 (lambda (group-sym)
1190 (if (or (null (setq group (symbol-name group-sym)))
1191 (not (boundp group-sym))
1192 (null (symbol-value group-sym))
1193 (gnus-gethash group gnus-newsrc-hashtb)
1194 (member group gnus-zombie-list)
1195 (member group gnus-killed-list))
1196 ;; The group is already known.
1197 ()
1198 ;; Make this group active.
1199 (when (symbol-value group-sym)
1200 (gnus-set-active group (symbol-value group-sym)))
1201 ;; Check whether we want it or not.
1202 (let ((do-sub (gnus-matches-options-n group)))
1203 (cond
1204 ((eq do-sub 'subscribe)
1205 (incf groups)
1206 (gnus-sethash group group gnus-killed-hashtb)
23f87bed
MB
1207 (gnus-call-subscribe-functions
1208 gnus-subscribe-options-newsgroup-method group))
eec82323
LMI
1209 ((eq do-sub 'ignore)
1210 nil)
1211 (t
1212 (incf groups)
1213 (gnus-sethash group group gnus-killed-hashtb)
1214 (if gnus-subscribe-hierarchical-interactive
1215 (push group new-newsgroups)
23f87bed
MB
1216 (gnus-call-subscribe-functions
1217 gnus-subscribe-newsgroup-method group)))))))
eec82323
LMI
1218 hashtb))
1219 (when new-newsgroups
1220 (gnus-subscribe-hierarchical-interactive new-newsgroups)))
16409b0b
GM
1221 (if (> groups 0)
1222 (gnus-message 5 "%d new newsgroup%s arrived"
1223 groups (if (> groups 1) "s have" " has"))
1224 (gnus-message 5 "No new newsgroups"))
eec82323
LMI
1225 (when got-new
1226 (setq gnus-newsrc-last-checked-date new-date))
9310f19d 1227 new-newsgroups))
eec82323 1228
16409b0b 1229(defun gnus-subscribe-group (group &optional previous method)
23f87bed 1230 "Subscribe GROUP and put it after PREVIOUS."
eec82323
LMI
1231 (gnus-group-change-level
1232 (if method
1233 (list t group gnus-level-default-subscribed nil nil method)
1234 group)
16409b0b
GM
1235 gnus-level-default-subscribed gnus-level-killed previous t)
1236 t)
eec82323
LMI
1237
1238;; `gnus-group-change-level' is the fundamental function for changing
1239;; subscription levels of newsgroups. This might mean just changing
1240;; from level 1 to 2, which is pretty trivial, from 2 to 6 or back
1241;; again, which subscribes/unsubscribes a group, which is equally
1242;; trivial. Changing from 1-7 to 8-9 means that you kill a group, and
1243;; from 8-9 to 1-7 means that you remove the group from the list of
1244;; killed (or zombie) groups and add them to the (kinda) subscribed
1245;; groups. And last but not least, moving from 8 to 9 and 9 to 8,
1246;; which is trivial.
1247;; ENTRY can either be a string (newsgroup name) or a list (if
1248;; FROMKILLED is t, it's a list on the format (NUM INFO-LIST),
1249;; otherwise it's a list in the format of the `gnus-newsrc-hashtb'
1250;; entries.
1251;; LEVEL is the new level of the group, OLDLEVEL is the old level and
1252;; PREVIOUS is the group (in hashtb entry format) to insert this group
1253;; after.
1254(defun gnus-group-change-level (entry level &optional oldlevel
1255 previous fromkilled)
1256 (let (group info active num)
1257 ;; Glean what info we can from the arguments
1258 (if (consp entry)
1259 (if fromkilled (setq group (nth 1 entry))
1260 (setq group (car (nth 2 entry))))
1261 (setq group entry))
1262 (when (and (stringp entry)
1263 oldlevel
1264 (< oldlevel gnus-level-zombie))
01c52d31 1265 (setq entry (gnus-group-entry entry)))
eec82323
LMI
1266 (if (and (not oldlevel)
1267 (consp entry))
1268 (setq oldlevel (gnus-info-level (nth 2 entry)))
6748645f 1269 (setq oldlevel (or oldlevel gnus-level-killed)))
eec82323 1270 (when (stringp previous)
01c52d31 1271 (setq previous (gnus-group-entry previous)))
eec82323
LMI
1272
1273 (if (and (>= oldlevel gnus-level-zombie)
01c52d31 1274 (gnus-group-entry group))
eec82323
LMI
1275 ;; We are trying to subscribe a group that is already
1276 ;; subscribed.
1277 () ; Do nothing.
1278
1279 (unless (gnus-ephemeral-group-p group)
1280 (gnus-dribble-enter
1281 (format "(gnus-group-change-level %S %S %S %S %S)"
1282 group level oldlevel (car (nth 2 previous)) fromkilled)))
1283
1284 ;; Then we remove the newgroup from any old structures, if needed.
1285 ;; If the group was killed, we remove it from the killed or zombie
1286 ;; list. If not, and it is in fact going to be killed, we remove
1287 ;; it from the newsrc hash table and assoc.
1288 (cond
1289 ((>= oldlevel gnus-level-zombie)
23f87bed
MB
1290 ;; oldlevel could be wrong.
1291 (setq gnus-zombie-list (delete group gnus-zombie-list))
1292 (setq gnus-killed-list (delete group gnus-killed-list)))
eec82323
LMI
1293 (t
1294 (when (and (>= level gnus-level-zombie)
1295 entry)
1296 (gnus-sethash (car (nth 2 entry)) nil gnus-newsrc-hashtb)
1297 (when (nth 3 entry)
01c52d31 1298 (setcdr (gnus-group-entry (car (nth 3 entry)))
eec82323
LMI
1299 (cdr entry)))
1300 (setcdr (cdr entry) (cdddr entry)))))
1301
1302 ;; Finally we enter (if needed) the list where it is supposed to
1303 ;; go, and change the subscription level. If it is to be killed,
1304 ;; we enter it into the killed or zombie list.
1305 (cond
1306 ((>= level gnus-level-zombie)
1307 ;; Remove from the hash table.
1308 (gnus-sethash group nil gnus-newsrc-hashtb)
1309 ;; We do not enter foreign groups into the list of dead
1310 ;; groups.
1311 (unless (gnus-group-foreign-p group)
1312 (if (= level gnus-level-zombie)
1313 (push group gnus-zombie-list)
23f87bed
MB
1314 (if (= oldlevel gnus-level-killed)
1315 ;; Remove from active hashtb.
1316 (unintern group gnus-active-hashtb)
1317 ;; Don't add it into killed-list if it was killed.
1318 (push group gnus-killed-list)))))
eec82323
LMI
1319 (t
1320 ;; If the list is to be entered into the newsrc assoc, and
1321 ;; it was killed, we have to create an entry in the newsrc
1322 ;; hashtb format and fix the pointers in the newsrc assoc.
1323 (if (< oldlevel gnus-level-zombie)
1324 ;; It was alive, and it is going to stay alive, so we
1325 ;; just change the level and don't change any pointers or
1326 ;; hash table entries.
1327 (setcar (cdaddr entry) level)
1328 (if (listp entry)
1329 (setq info (cdr entry)
1330 num (car entry))
1331 (setq active (gnus-active group))
1332 (setq num
1333 (if active (- (1+ (cdr active)) (car active)) t))
16409b0b
GM
1334 ;; Shorten the select method if possible, if we need to
1335 ;; store it at all (native groups).
1336 (let ((method (gnus-method-simplify
1337 (or gnus-override-subscribe-method
1338 (gnus-group-method group)))))
1339 (if method
1340 (setq info (list group level nil nil method))
1341 (setq info (list group level nil)))))
eec82323
LMI
1342 (unless previous
1343 (setq previous
1344 (let ((p gnus-newsrc-alist))
1345 (while (cddr p)
1346 (setq p (cdr p)))
1347 p)))
1348 (setq entry (cons info (cddr previous)))
1349 (if (cdr previous)
1350 (progn
1351 (setcdr (cdr previous) entry)
1352 (gnus-sethash group (cons num (cdr previous))
1353 gnus-newsrc-hashtb))
1354 (setcdr previous entry)
1355 (gnus-sethash group (cons num previous)
1356 gnus-newsrc-hashtb))
1357 (when (cdr entry)
01c52d31 1358 (setcdr (gnus-group-entry (caadr entry)) entry))
eec82323
LMI
1359 (gnus-dribble-enter
1360 (format
1361 "(gnus-group-set-info '%S)" info)))))
1362 (when gnus-group-change-level-function
a8151ef7
LMI
1363 (funcall gnus-group-change-level-function
1364 group level oldlevel previous)))))
eec82323
LMI
1365
1366(defun gnus-kill-newsgroup (newsgroup)
1367 "Obsolete function. Kills a newsgroup."
1368 (gnus-group-change-level
01c52d31 1369 (gnus-group-entry newsgroup) gnus-level-killed))
eec82323
LMI
1370
1371(defun gnus-check-bogus-newsgroups (&optional confirm)
1372 "Remove bogus newsgroups.
1373If CONFIRM is non-nil, the user has to confirm the deletion of every
1374newsgroup."
1375 (let ((newsrc (cdr gnus-newsrc-alist))
1376 bogus group entry info)
1377 (gnus-message 5 "Checking bogus newsgroups...")
1378 (unless (gnus-read-active-file-p)
1379 (gnus-read-active-file t))
1380 (when (gnus-read-active-file-p)
1381 ;; Find all bogus newsgroup that are subscribed.
1382 (while newsrc
1383 (setq info (pop newsrc)
1384 group (gnus-info-group info))
1385 (unless (or (gnus-active group) ; Active
23f87bed
MB
1386 (and (gnus-info-method info)
1387 (not (gnus-secondary-method-p
1388 (gnus-info-method info))))) ; Foreign
eec82323
LMI
1389 ;; Found a bogus newsgroup.
1390 (push group bogus)))
1391 (if confirm
1392 (map-y-or-n-p
a3f57c41 1393 (format "Remove bogus group %%s (of %d groups)? " (length bogus))
eec82323
LMI
1394 (lambda (group)
1395 ;; Remove all bogus subscribed groups by first killing them, and
1396 ;; then removing them from the list of killed groups.
01c52d31 1397 (when (setq entry (gnus-group-entry group))
eec82323
LMI
1398 (gnus-group-change-level entry gnus-level-killed)
1399 (setq gnus-killed-list (delete group gnus-killed-list))))
1400 bogus '("group" "groups" "remove"))
1401 (while (setq group (pop bogus))
1402 ;; Remove all bogus subscribed groups by first killing them, and
1403 ;; then removing them from the list of killed groups.
01c52d31 1404 (when (setq entry (gnus-group-entry group))
eec82323
LMI
1405 (gnus-group-change-level entry gnus-level-killed)
1406 (setq gnus-killed-list (delete group gnus-killed-list)))))
1407 ;; Then we remove all bogus groups from the list of killed and
1408 ;; zombie groups. They are removed without confirmation.
1409 (let ((dead-lists '(gnus-killed-list gnus-zombie-list))
1410 killed)
1411 (while dead-lists
1412 (setq killed (symbol-value (car dead-lists)))
1413 (while killed
1414 (unless (gnus-active (setq group (pop killed)))
1415 ;; The group is bogus.
1416 ;; !!!Slow as hell.
1417 (set (car dead-lists)
1418 (delete group (symbol-value (car dead-lists))))))
1419 (setq dead-lists (cdr dead-lists))))
6748645f 1420 (gnus-run-hooks 'gnus-check-bogus-groups-hook)
eec82323
LMI
1421 (gnus-message 5 "Checking bogus newsgroups...done"))))
1422
1423(defun gnus-check-duplicate-killed-groups ()
1424 "Remove duplicates from the list of killed groups."
1425 (interactive)
1426 (let ((killed gnus-killed-list))
1427 (while killed
1428 (gnus-message 9 "%d" (length killed))
1429 (setcdr killed (delete (car killed) (cdr killed)))
1430 (setq killed (cdr killed)))))
1431
1432;; We want to inline a function from gnus-cache, so we cheat here:
9efa445f 1433(defvar gnus-cache-active-hashtb)
eec82323 1434(eval-when-compile
eec82323
LMI
1435 (defun gnus-cache-possibly-alter-active (group active)
1436 "Alter the ACTIVE info for GROUP to reflect the articles in the cache."
1437 (when gnus-cache-active-hashtb
1438 (let ((cache-active (gnus-gethash group gnus-cache-active-hashtb)))
a8151ef7
LMI
1439 (when cache-active
1440 (when (< (car cache-active) (car active))
1441 (setcar active (car cache-active)))
1442 (when (> (cdr cache-active) (cdr active))
1443 (setcdr active (cdr cache-active))))))))
eec82323 1444
c15c8017
LMI
1445(defun gnus-activate-group (group &optional scan dont-check method
1446 dont-sub-check)
531e5812
MB
1447 "Check whether a group has been activated or not.
1448If SCAN, request a scan of that group as well."
eec82323
LMI
1449 (let ((method (or method (inline (gnus-find-method-for-group group))))
1450 active)
1451 (and (inline (gnus-check-server method))
1452 ;; We escape all bugs and quit here to make it possible to
1453 ;; continue if a group is so out-there that it reports bugs
1454 ;; and stuff.
1455 (progn
1456 (and scan
1457 (gnus-check-backend-function 'request-scan (car method))
1458 (gnus-request-scan group method))
1459 t)
23f87bed 1460 (if (or debug-on-error debug-on-quit)
c15c8017 1461 (inline (gnus-request-group group (or dont-sub-check dont-check)
286c4fc2
LMI
1462 method
1463 (gnus-get-info group)))
23f87bed 1464 (condition-case nil
c15c8017 1465 (inline (gnus-request-group group (or dont-sub-check dont-check)
286c4fc2
LMI
1466 method
1467 (gnus-get-info group)))
23f87bed
MB
1468 ;;(error nil)
1469 (quit
1470 (message "Quit activating %s" group)
1471 nil)))
1472 (unless dont-check
1473 (setq active (gnus-parse-active))
1474 ;; If there are no articles in the group, the GROUP
1475 ;; command may have responded with the `(0 . 0)'. We
1476 ;; ignore this if we already have an active entry
1477 ;; for the group.
01c52d31
MB
1478 (if (and (zerop (or (car active) 0))
1479 (zerop (or (cdr active) 0))
23f87bed
MB
1480 (gnus-active group))
1481 (gnus-active group)
1482
54506618
MB
1483 ;; If a cache is present, we may have to alter the active info.
1484 (when gnus-use-cache
1485 (inline (gnus-cache-possibly-alter-active
1486 group active)))
1487
1488 ;; If the agent is enabled, we may have to alter the active info.
1489 (when gnus-agent
1490 (gnus-agent-possibly-alter-active group active))
1491
23f87bed
MB
1492 (gnus-set-active group active)
1493 ;; Return the new active info.
1494 active)))))
eec82323
LMI
1495
1496(defun gnus-get-unread-articles-in-group (info active &optional update)
54506618 1497 (when (and info active)
eec82323
LMI
1498 ;; Allow the backend to update the info in the group.
1499 (when (and update
1500 (gnus-request-update-info
1501 info (inline (gnus-find-method-for-group
1502 (gnus-info-group info)))))
1503 (gnus-activate-group (gnus-info-group info) nil t))
6748645f 1504
9e928ac9 1505 ;; Allow backends to update marks,
5415d076 1506 (when gnus-propagate-marks
b1ae92ba
G
1507 (let ((method (inline (gnus-find-method-for-group
1508 (gnus-info-group info)))))
1509 (when (gnus-check-backend-function 'request-marks (car method))
1510 (gnus-request-marks info method))))
1511
eec82323
LMI
1512 (let* ((range (gnus-info-read info))
1513 (num 0))
54506618
MB
1514
1515 ;; These checks are present in gnus-activate-group but skipped
97610156 1516 ;; due to setting dont-check in the preceding call.
54506618 1517
eec82323
LMI
1518 ;; If a cache is present, we may have to alter the active info.
1519 (when (and gnus-use-cache info)
1520 (inline (gnus-cache-possibly-alter-active
1521 (gnus-info-group info) active)))
23f87bed
MB
1522
1523 ;; If the agent is enabled, we may have to alter the active info.
1524 (when (and gnus-agent info)
54506618 1525 (gnus-agent-possibly-alter-active (gnus-info-group info) active info))
23f87bed 1526
eec82323
LMI
1527 ;; Modify the list of read articles according to what articles
1528 ;; are available; then tally the unread articles and add the
1529 ;; number to the group hash table entry.
1530 (cond
1531 ((zerop (cdr active))
1532 (setq num 0))
1533 ((not range)
1534 (setq num (- (1+ (cdr active)) (car active))))
1535 ((not (listp (cdr range)))
1536 ;; Fix a single (num . num) range according to the
1537 ;; active hash table.
1538 ;; Fix by Carsten Bormann <cabo@Informatik.Uni-Bremen.DE>.
1539 (and (< (cdr range) (car active)) (setcdr range (1- (car active))))
1540 (and (> (cdr range) (cdr active)) (setcdr range (cdr active)))
1541 ;; Compute number of unread articles.
1542 (setq num (max 0 (- (cdr active) (- (1+ (cdr range)) (car range))))))
1543 (t
1544 ;; The read list is a list of ranges. Fix them according to
1545 ;; the active hash table.
1546 ;; First peel off any elements that are below the lower
1547 ;; active limit.
1548 (while (and (cdr range)
1549 (>= (car active)
1550 (or (and (atom (cadr range)) (cadr range))
1551 (caadr range))))
1552 (if (numberp (car range))
1553 (setcar range
1554 (cons (car range)
1555 (or (and (numberp (cadr range))
1556 (cadr range))
1557 (cdadr range))))
1558 (setcdr (car range)
1559 (or (and (numberp (nth 1 range)) (nth 1 range))
1560 (cdadr range))))
1561 (setcdr range (cddr range)))
1562 ;; Adjust the first element to be the same as the lower limit.
1563 (when (and (not (atom (car range)))
1564 (< (cdar range) (car active)))
1565 (setcdr (car range) (1- (car active))))
1566 ;; Then we want to peel off any elements that are higher
1567 ;; than the upper active limit.
1568 (let ((srange range))
16409b0b 1569 ;; Go past all valid elements.
eec82323
LMI
1570 (while (and (cdr srange)
1571 (<= (or (and (atom (cadr srange))
1572 (cadr srange))
1573 (caadr srange))
1574 (cdr active)))
1575 (setq srange (cdr srange)))
1576 (when (cdr srange)
16409b0b 1577 ;; Nuke all remaining invalid elements.
eec82323
LMI
1578 (setcdr srange nil))
1579
1580 ;; Adjust the final element.
1581 (when (and (not (atom (car srange)))
1582 (> (cdar srange) (cdr active)))
1583 (setcdr (car srange) (cdr active))))
1584 ;; Compute the number of unread articles.
1585 (while range
1586 (setq num (+ num (- (1+ (or (and (atom (car range)) (car range))
1587 (cdar range)))
1588 (or (and (atom (car range)) (car range))
1589 (caar range)))))
1590 (setq range (cdr range)))
1591 (setq num (max 0 (- (cdr active) num)))))
1592 ;; Set the number of unread articles.
23f87bed 1593 (when (and info
01c52d31
MB
1594 (gnus-group-entry (gnus-info-group info)))
1595 (setcar (gnus-group-entry (gnus-info-group info)) num))
eec82323
LMI
1596 num)))
1597
1598;; Go though `gnus-newsrc-alist' and compare with `gnus-active-hashtb'
1599;; and compute how many unread articles there are in each group.
1600(defun gnus-get-unread-articles (&optional level)
23f87bed 1601 (setq gnus-server-method-cache nil)
3d319c8f 1602 (require 'gnus-agent)
eec82323 1603 (let* ((newsrc (cdr gnus-newsrc-alist))
b890d447 1604 (alevel (or level gnus-activate-level (1+ gnus-level-subscribed)))
eec82323 1605 (foreign-level
cdad7ab2
LMI
1606 (or
1607 level
1608 (min
1609 (cond ((and gnus-activate-foreign-newsgroups
1610 (not (numberp gnus-activate-foreign-newsgroups)))
1611 (1+ gnus-level-subscribed))
1612 ((numberp gnus-activate-foreign-newsgroups)
1613 gnus-activate-foreign-newsgroups)
1614 (t 0))
1615 alevel)))
23f87bed
MB
1616 (methods-cache nil)
1617 (type-cache nil)
4469385c 1618 (gnus-agent-article-local-times 0)
cc4244d3 1619 (archive-method (gnus-server-to-method "archive"))
8c3e17f8 1620 infos info group active method cmethod
55c9cbb0 1621 method-type method-group-list entry)
23f87bed 1622 (gnus-message 6 "Checking new news...")
eec82323
LMI
1623
1624 (while newsrc
1625 (setq active (gnus-active (setq group (gnus-info-group
01c52d31 1626 (setq info (pop newsrc))))))
8c3e17f8
LMI
1627 ;; First go through all the groups, see what select methods they
1628 ;; belong to, and then collect them into lists per unique select
1629 ;; method.
1630 (if (not (setq method (gnus-info-method info)))
1631 (setq method gnus-select-method)
0617bb00
LMI
1632 ;; There may be several similar methods. Possibly extend the
1633 ;; method.
23f87bed
MB
1634 (if (setq cmethod (assoc method methods-cache))
1635 (setq method (cdr cmethod))
0617bb00
LMI
1636 (setq cmethod (if (stringp method)
1637 (gnus-server-to-method method)
1638 (inline (gnus-find-method-for-group
1639 (gnus-info-group info) info))))
23f87bed
MB
1640 (push (cons method cmethod) methods-cache)
1641 (setq method cmethod)))
8c3e17f8
LMI
1642 (setq method-group-list (assoc method type-cache))
1643 (unless method-group-list
23f87bed 1644 (setq method-type
01c52d31 1645 (cond
cc4244d3
LMI
1646 ((or (gnus-secondary-method-p method)
1647 (and (gnus-archive-server-wanted-p)
1648 (gnus-methods-equal-p archive-method method)))
01c52d31
MB
1649 'secondary)
1650 ((inline (gnus-server-equal gnus-select-method method))
1651 'primary)
1652 (t
1653 'foreign)))
20a673b2 1654 (push (setq method-group-list (list method method-type nil nil))
8c3e17f8 1655 type-cache))
a83e5f19 1656 ;; Only add groups that need updating.
55c9cbb0
KY
1657 (if (<= (gnus-info-level info)
1658 (if (eq (cadr method-group-list) 'foreign)
1659 foreign-level
1660 alevel))
1661 (setcar (nthcdr 2 method-group-list)
1662 (cons info (nth 2 method-group-list)))
1663 ;; The group is inactive, so we nix out the number of unread articles.
1664 ;; It leads `(gnus-group-unread group)' to return t. See also
1665 ;; `gnus-group-prepare-flat'.
1666 (unless active
1667 (when (setq entry (gnus-group-entry group))
1668 (setcar entry t)))))
8c3e17f8
LMI
1669
1670 ;; Sort the methods based so that the primary and secondary
1671 ;; methods come first. This is done for legacy reasons to try to
1672 ;; ensure that side-effect behaviour doesn't change from previous
1673 ;; Gnus versions.
1674 (setq type-cache
1675 (sort (nreverse type-cache)
1676 (lambda (c1 c2)
1677 (< (gnus-method-rank (cadr c1) (car c1))
1678 (gnus-method-rank (cadr c2) (car c2))))))
06b840e0
LI
1679 ;; Go through the list of servers and possibly extend methods that
1680 ;; aren't equal (and that need extension; i.e., they are async).
1681 (let ((methods nil))
1682 (dolist (elem type-cache)
1683 (destructuring-bind (method method-type infos dummy) elem
1684 (let ((gnus-opened-servers methods))
1685 (when (and (gnus-similar-server-opened method)
1686 (gnus-check-backend-function
1687 'retrieve-group-data-early (car method)))
1688 (setq method (gnus-server-extend-method
1689 (gnus-info-group (car infos))
1690 method))
1691 (setcar elem method))
1692 (push (list method 'ok) methods)))))
003522ce
G
1693
1694 ;; If we have primary/secondary select methods, but no groups from
1695 ;; them, we still want to issue a retrieval request from them.
1696 (dolist (method (cons gnus-select-method
1697 gnus-secondary-select-methods))
1698 (when (and (not (assoc method type-cache))
1699 (gnus-check-backend-function 'request-list (car method)))
1700 (with-current-buffer nntp-server-buffer
1701 (gnus-read-active-file-1 method nil))))
1702
20a673b2
KY
1703 ;; Start early async retrieval of data.
1704 (dolist (elem type-cache)
1705 (destructuring-bind (method method-type infos dummy) elem
1706 (when (and method infos
bdaa75c7 1707 (not (gnus-method-denied-p method)))
1fe0787f
LMI
1708 ;; If the open-server method doesn't exist, then the method
1709 ;; itself doesn't exist, so we ignore it.
1710 (if (not (ignore-errors (gnus-get-function method 'open-server)))
1711 (setq type-cache (delq elem type-cache))
1712 (unless (gnus-server-opened method)
1713 (gnus-open-server method))
1714 (when (and
1715 (gnus-server-opened method)
1716 (gnus-check-backend-function
1717 'retrieve-group-data-early (car method)))
1718 (when (gnus-check-backend-function 'request-scan (car method))
1719 (gnus-request-scan nil method))
c1d5851d
LI
1720 ;; Store the token we get back from -early so that we
1721 ;; can pass it to -finish later.
1fe0787f
LMI
1722 (setcar (nthcdr 3 elem)
1723 (gnus-retrieve-group-data-early method infos)))))))
20a673b2
KY
1724
1725 ;; Do the rest of the retrieval.
1726 (dolist (elem type-cache)
1727 (destructuring-bind (method method-type infos early-data) elem
1728 (when (and method infos)
b1ae92ba
G
1729 (let ((updatep (gnus-check-backend-function
1730 'request-update-info (car method))))
1731 ;; See if any of the groups from this method require updating.
1732 (gnus-read-active-for-groups method infos early-data)
1733 (dolist (info infos)
1734 (inline (gnus-get-unread-articles-in-group
1735 info (gnus-active (gnus-info-group info))
1736 updatep)))))))
23f87bed 1737 (gnus-message 6 "Checking new news...done")))
eec82323 1738
8c3e17f8
LMI
1739(defun gnus-method-rank (type method)
1740 (cond
d65835d9
LMI
1741 ;; Get info for virtual groups last.
1742 ((eq (car method) 'nnvirtual)
1743 200)
8c3e17f8
LMI
1744 ((eq type 'primary)
1745 1)
1746 ;; Compute the rank of the secondary methods based on where they
1747 ;; are in the secondary select list.
1748 ((eq type 'secondary)
1749 (let ((i 2))
1750 (block nil
1751 (dolist (smethod gnus-secondary-select-methods)
3cf628e8 1752 (when (equal method smethod)
8c3e17f8
LMI
1753 (return i))
1754 (incf i))
1755 i)))
1756 ;; Just say that all foreign groups have the same rank.
1757 (t
1758 100)))
1759
20a673b2 1760(defun gnus-read-active-for-groups (method infos early-data)
8c3e17f8
LMI
1761 (with-current-buffer nntp-server-buffer
1762 (cond
c1d5851d
LI
1763 ;; Finish up getting the data from the methods that have -early
1764 ;; methods.
20a673b2
KY
1765 ((and
1766 (gnus-check-backend-function 'finish-retrieve-group-infos (car method))
1767 (or (not (gnus-agent-method-p method))
1768 (gnus-online method)))
e8861cd2
LMI
1769 (gnus-finish-retrieve-group-infos method infos early-data)
1770 (gnus-agent-save-active method))
c1d5851d 1771 ;; Most backends have -retrieve-groups.
0d1c2cc8 1772 ((gnus-check-backend-function 'retrieve-groups (car method))
26f96aa0 1773 (when (gnus-check-backend-function 'request-scan (car method))
b069e5a6 1774 (gnus-request-scan nil method))
39486331
KY
1775 (let (groups)
1776 (gnus-read-active-file-2
1777 (dolist (info infos (nreverse groups))
1778 (push (gnus-group-real-name (gnus-info-group info)) groups))
1779 method)))
c1d5851d 1780 ;; Virtually all backends have -request-list.
74769e8b 1781 ((gnus-check-backend-function 'request-list (car method))
c1d5851d
LI
1782 (gnus-read-active-file-1 method nil))
1783 ;; Except nnvirtual and friends, where we request each group, one
1784 ;; by one.
8c3e17f8
LMI
1785 (t
1786 (dolist (info infos)
74769e8b 1787 (gnus-activate-group (gnus-info-group info) nil nil method t))))))
8c3e17f8 1788
eec82323
LMI
1789;; Create a hash table out of the newsrc alist. The `car's of the
1790;; alist elements are used as keys.
1791(defun gnus-make-hashtable-from-newsrc-alist ()
1792 (let ((alist gnus-newsrc-alist)
1793 (ohashtb gnus-newsrc-hashtb)
01c52d31 1794 prev info method rest methods)
eec82323
LMI
1795 (setq gnus-newsrc-hashtb (gnus-make-hashtable (length alist)))
1796 (setq alist
1797 (setq prev (setq gnus-newsrc-alist
1798 (if (equal (caar gnus-newsrc-alist)
1799 "dummy.group")
1800 gnus-newsrc-alist
1801 (cons (list "dummy.group" 0 nil) alist)))))
1802 (while alist
01c52d31
MB
1803 (setq info (car alist))
1804 ;; Make the same select-methods identical Lisp objects.
1805 (when (setq method (gnus-info-method info))
1806 (if (setq rest (member method methods))
1807 (gnus-info-set-method info (car rest))
1808 (push method methods)))
fb994703
LMI
1809 ;; Check for duplicates.
1810 (if (gnus-gethash (car info) gnus-newsrc-hashtb)
1811 ;; Remove this entry from the alist.
1812 (setcdr prev (cddr prev))
1813 (gnus-sethash
1814 (car info)
1815 ;; Preserve number of unread articles in groups.
1816 (cons (and ohashtb (car (gnus-gethash (car info) ohashtb)))
1817 prev)
1818 gnus-newsrc-hashtb)
1819 (setq prev alist))
1820 (setq alist (cdr alist)))
01c52d31
MB
1821 ;; Make the same select-methods in `gnus-server-alist' identical
1822 ;; as well.
1823 (while methods
1824 (setq method (pop methods))
1825 (when (setq rest (rassoc method gnus-server-alist))
1826 (setcdr rest method)))))
eec82323
LMI
1827
1828(defun gnus-make-hashtable-from-killed ()
1829 "Create a hash table from the killed and zombie lists."
1830 (let ((lists '(gnus-killed-list gnus-zombie-list))
1831 list)
1832 (setq gnus-killed-hashtb
1833 (gnus-make-hashtable
1834 (+ (length gnus-killed-list) (length gnus-zombie-list))))
1835 (while lists
1836 (setq list (symbol-value (pop lists)))
1837 (while list
1838 (gnus-sethash (car list) (pop list) gnus-killed-hashtb)))))
1839
1840(defun gnus-parse-active ()
1841 "Parse active info in the nntp server buffer."
20a673b2 1842 (with-current-buffer nntp-server-buffer
eec82323
LMI
1843 (goto-char (point-min))
1844 ;; Parse the result we got from `gnus-request-group'.
1845 (when (looking-at "[0-9]+ [0-9]+ \\([0-9]+\\) [0-9]+")
1846 (goto-char (match-beginning 1))
1847 (cons (read (current-buffer))
1848 (read (current-buffer))))))
1849
1850(defun gnus-make-articles-unread (group articles)
1851 "Mark ARTICLES in GROUP as unread."
01c52d31
MB
1852 (let* ((info (nth 2 (or (gnus-group-entry group)
1853 (gnus-group-entry
1854 (gnus-group-real-name group)))))
eec82323
LMI
1855 (ranges (gnus-info-read info))
1856 news article)
1857 (while articles
1858 (when (gnus-member-of-range
1859 (setq article (pop articles)) ranges)
1860 (push article news)))
1861 (when news
23f87bed 1862 ;; Enter this list into the group info.
eec82323
LMI
1863 (gnus-info-set-read
1864 info (gnus-remove-from-range (gnus-info-read info) (nreverse news)))
23f87bed
MB
1865
1866 ;; Set the number of unread articles in gnus-newsrc-hashtb.
1867 (gnus-get-unread-articles-in-group info (gnus-active group))
1868
1869 ;; Insert the change into the group buffer and the dribble file.
1870 (gnus-group-update-group group t))))
1871
1872(defun gnus-make-ascending-articles-unread (group articles)
1873 "Mark ascending ARTICLES in GROUP as unread."
01c52d31
MB
1874 (let* ((entry (or (gnus-group-entry group)
1875 (gnus-group-entry (gnus-group-real-name group))))
23f87bed
MB
1876 (info (nth 2 entry))
1877 (ranges (gnus-info-read info))
1878 (r ranges)
1879 modified)
1880
1881 (while articles
1882 (let ((article (pop articles))) ; get the next article to remove from ranges
1883 (while (let ((range (car ranges))) ; note the current range
1884 (if (atom range) ; single value range
1885 (cond ((not range)
1886 ;; the articles extend past the end of the ranges
1887 ;; OK - I'm done
1888 (setq articles nil))
1889 ((< range article)
97610156 1890 ;; this range precedes the article. Leave the range unmodified.
23f87bed
MB
1891 (pop ranges)
1892 ranges)
1893 ((= range article)
1894 ;; this range exactly matches the article; REMOVE THE RANGE.
1895 ;; NOTE: When the range being removed is the last range, the list is corrupted by inserting null at its end.
1896 (setcar ranges (cadr ranges))
1897 (setcdr ranges (cddr ranges))
1898 (setq modified (if (car ranges) t 'remove-null))
1899 nil))
1900 (let ((min (car range))
1901 (max (cdr range)))
1902 ;; I have a min/max range to consider
1903 (cond ((> min max) ; invalid range introduced by splitter
1904 (setcar ranges (cadr ranges))
1905 (setcdr ranges (cddr ranges))
1906 (setq modified (if (car ranges) t 'remove-null))
1907 ranges)
1908 ((= min max)
1909 ;; replace min/max range with a single-value range
1910 (setcar ranges min)
1911 ranges)
1912 ((< max article)
97610156 1913 ;; this range precedes the article. Leave the range unmodified.
23f87bed
MB
1914 (pop ranges)
1915 ranges)
1916 ((< article min)
97610156 1917 ;; this article precedes the range. Return null to move to the
23f87bed
MB
1918 ;; next article
1919 nil)
1920 (t
1921 ;; this article splits the range into two parts
1922 (setcdr ranges (cons (cons (1+ article) max) (cdr ranges)))
1923 (setcdr range (1- article))
1924 (setq modified t)
1925 ranges))))))))
bf247b6e 1926
23f87bed
MB
1927 (when modified
1928 (when (eq modified 'remove-null)
1929 (setq r (delq nil r)))
1930 ;; Enter this list into the group info.
1931 (gnus-info-set-read info r)
1932
1933 ;; Set the number of unread articles in gnus-newsrc-hashtb.
1934 (gnus-get-unread-articles-in-group info (gnus-active group))
1935
1936 ;; Insert the change into the group buffer and the dribble file.
eec82323
LMI
1937 (gnus-group-update-group group t))))
1938
1939;; Enter all dead groups into the hashtb.
1940(defun gnus-update-active-hashtb-from-killed ()
1941 (let ((hashtb (setq gnus-active-hashtb (gnus-make-hashtable 4096)))
1942 (lists (list gnus-killed-list gnus-zombie-list))
1943 killed)
1944 (while lists
1945 (setq killed (car lists))
1946 (while killed
01c52d31 1947 (gnus-sethash (mm-string-as-unibyte (car killed)) nil hashtb)
eec82323
LMI
1948 (setq killed (cdr killed)))
1949 (setq lists (cdr lists)))))
1950
1951(defun gnus-get-killed-groups ()
1952 "Go through the active hashtb and mark all unknown groups as killed."
1953 ;; First make sure active file has been read.
1954 (unless (gnus-read-active-file-p)
1955 (let ((gnus-read-active-file t))
1956 (gnus-read-active-file)))
1957 (unless gnus-killed-hashtb
1958 (gnus-make-hashtable-from-killed))
1959 ;; Go through all newsgroups that are known to Gnus - enlarge kill list.
1960 (mapatoms
1961 (lambda (sym)
1962 (let ((groups 0)
1963 (group (symbol-name sym)))
1964 (if (or (null group)
1965 (gnus-gethash group gnus-killed-hashtb)
1966 (gnus-gethash group gnus-newsrc-hashtb))
1967 ()
1968 (let ((do-sub (gnus-matches-options-n group)))
1969 (if (or (eq do-sub 'subscribe) (eq do-sub 'ignore))
1970 ()
1971 (setq groups (1+ groups))
1972 (push group gnus-killed-list)
1973 (gnus-sethash group group gnus-killed-hashtb))))))
1974 gnus-active-hashtb)
1975 (gnus-dribble-touch))
1976
1977;; Get the active file(s) from the backend(s).
a8151ef7 1978(defun gnus-read-active-file (&optional force not-native)
eec82323
LMI
1979 (gnus-group-set-mode-line)
1980 (let ((methods
16409b0b
GM
1981 (mapcar
1982 (lambda (m) (if (stringp m) (gnus-server-get-method nil m) m))
1983 (append
1984 (if (and (not not-native)
1985 (gnus-check-server gnus-select-method))
1986 ;; The native server is available.
1987 (cons gnus-select-method gnus-secondary-select-methods)
1988 ;; The native server is down, so we just do the
1989 ;; secondary ones.
1990 gnus-secondary-select-methods)
1991 ;; Also read from the archive server.
1992 (when (gnus-archive-server-wanted-p)
1993 (list "archive")))))
1994 method)
eec82323 1995 (setq gnus-have-read-active-file nil)
20a673b2 1996 (with-current-buffer nntp-server-buffer
16409b0b
GM
1997 (while (setq method (pop methods))
1998 ;; Only do each method once, in case the methods appear more
1999 ;; than once in this list.
1fe0787f
LMI
2000 (when (and (not (member method methods))
2001 ;; Check whether the backend exists.
2002 (ignore-errors (gnus-get-function method 'open-server)))
23f87bed 2003 (if (or debug-on-error debug-on-quit)
16409b0b 2004 (gnus-read-active-file-1 method force)
23f87bed
MB
2005 (condition-case ()
2006 (gnus-read-active-file-1 method force)
2007 ;; We catch C-g so that we can continue past servers
2008 ;; that do not respond.
2009 (quit
2010 (message "Quit reading the active file")
2011 nil))))))))
16409b0b 2012
c1d5851d 2013(defun gnus-read-active-file-1 (method force)
16409b0b
GM
2014 (let (where mesg)
2015 (setq where (nth 1 method)
2016 mesg (format "Reading active file%s via %s..."
2017 (if (and where (not (zerop (length where))))
2018 (concat " from " where) "")
2019 (car method)))
bdaa75c7 2020 (gnus-message 5 "%s" mesg)
16409b0b
GM
2021 (when (gnus-check-server method)
2022 ;; Request that the backend scan its incoming messages.
a9ec34f4
LMI
2023 (when (and (or (and gnus-agent
2024 (gnus-online method))
2025 (not gnus-agent))
8c3e17f8 2026 (gnus-check-backend-function 'request-scan (car method)))
b069e5a6 2027 (gnus-request-scan nil method))
16409b0b
GM
2028 (cond
2029 ((and (eq gnus-read-active-file 'some)
2030 (gnus-check-backend-function 'retrieve-groups (car method))
2031 (not force))
2032 (let ((newsrc (cdr gnus-newsrc-alist))
2033 (gmethod (gnus-server-get-method nil method))
2034 groups info)
2035 (while (setq info (pop newsrc))
2036 (when (inline
2037 (gnus-server-equal
54506618
MB
2038 (inline
2039 (gnus-find-method-for-group
2040 (gnus-info-group info) info))
2041 gmethod))
16409b0b
GM
2042 (push (gnus-group-real-name (gnus-info-group info))
2043 groups)))
2044 (gnus-read-active-file-2 groups method)))
2045 ((null method)
2046 t)
2047 (t
2048 (if (not (gnus-request-list method))
2049 (unless (equal method gnus-message-archive-method)
2050 (gnus-error 1 "Cannot read active file from %s server"
2051 (car method)))
bdaa75c7 2052 (gnus-message 5 "%s" mesg)
16409b0b
GM
2053 (gnus-active-to-gnus-format method gnus-active-hashtb nil t)
2054 ;; We mark this active file as read.
e0da801a 2055 (add-to-list 'gnus-have-read-active-file method)
16409b0b
GM
2056 (gnus-message 5 "%sdone" mesg)))))))
2057
2058(defun gnus-read-active-file-2 (groups method)
23f87bed 2059 "Read an active file for GROUPS in METHOD using `gnus-retrieve-groups'."
16409b0b 2060 (when groups
20a673b2 2061 (with-current-buffer nntp-server-buffer
16409b0b
GM
2062 (gnus-check-server method)
2063 (let ((list-type (gnus-retrieve-groups groups method)))
2064 (cond ((not list-type)
2065 (gnus-error
2066 1.2 "Cannot read partial active file from %s server."
2067 (car method)))
2068 ((eq list-type 'active)
2069 (gnus-active-to-gnus-format method gnus-active-hashtb nil t))
2070 (t
2071 (gnus-groups-to-gnus-format method gnus-active-hashtb t)))))))
eec82323
LMI
2072
2073;; Read an active file and place the results in `gnus-active-hashtb'.
6748645f
LMI
2074(defun gnus-active-to-gnus-format (&optional method hashtb ignore-errors
2075 real-active)
eec82323
LMI
2076 (unless method
2077 (setq method gnus-select-method))
2078 (let ((cur (current-buffer))
2079 (hashtb (or hashtb
2080 (if (and gnus-active-hashtb
2081 (not (equal method gnus-select-method)))
2082 gnus-active-hashtb
2083 (setq gnus-active-hashtb
2084 (if (equal method gnus-select-method)
2085 (gnus-make-hashtable
2086 (count-lines (point-min) (point-max)))
1428d46b
MB
2087 (gnus-make-hashtable 4096))))))
2088 group max min)
a8151ef7 2089 ;; Delete unnecessary lines.
eec82323 2090 (goto-char (point-min))
16409b0b
GM
2091 (cond
2092 ((string= gnus-ignored-newsgroups "")
2093 (delete-matching-lines "^to\\."))
2094 (t
2095 (delete-matching-lines (concat "^to\\.\\|" gnus-ignored-newsgroups))))
2096
2097 (goto-char (point-min))
2098 (unless (re-search-forward "[\\\"]" nil t)
2099 ;; Make the group names readable as a lisp expression even if they
2100 ;; contain special characters.
2101 (goto-char (point-max))
2102 (while (re-search-backward "[][';?()#]" nil t)
2103 (insert ?\\)))
eec82323 2104
6748645f 2105 ;; Let the Gnus agent save the active file.
23f87bed 2106 (when (and gnus-agent real-active (gnus-online method))
6748645f
LMI
2107 (gnus-agent-save-active method))
2108
eec82323
LMI
2109 ;; If these are groups from a foreign select method, we insert the
2110 ;; group prefix in front of the group names.
a8151ef7
LMI
2111 (when (not (gnus-server-equal
2112 (gnus-server-get-method nil method)
2113 (gnus-server-get-method nil gnus-select-method)))
2114 (let ((prefix (gnus-group-prefixed-name "" method)))
2115 (goto-char (point-min))
2116 (while (and (not (eobp))
16409b0b
GM
2117 (progn
2118 (when (= (following-char) ?\")
2119 (forward-char 1))
2120 (insert prefix)
2121 (zerop (forward-line 1)))))))
eec82323 2122 ;; Store the active file in a hash table.
1428d46b
MB
2123 ;; Use a unibyte buffer in order to make `read' read non-ASCII
2124 ;; group names (which have been encoded) as unibyte strings.
2125 (mm-with-unibyte-buffer
2126 (insert-buffer-substring cur)
2127 (setq cur (current-buffer))
2128 (goto-char (point-min))
eec82323 2129 (while (not (eobp))
23f87bed 2130 (condition-case ()
eec82323 2131 (progn
01c52d31 2132 (narrow-to-region (point) (point-at-eol))
eec82323
LMI
2133 ;; group gets set to a symbol interned in the hash table
2134 ;; (what a hack!!) - jwz
2135 (setq group (let ((obarray hashtb)) (read cur)))
16409b0b
GM
2136 ;; ### The extended group name scheme makes
2137 ;; the previous optimization strategy sort of pointless...
2138 (when (stringp group)
2139 (setq group (intern group hashtb)))
eec82323
LMI
2140 (if (and (numberp (setq max (read cur)))
2141 (numberp (setq min (read cur)))
2142 (progn
2143 (skip-chars-forward " \t")
2144 (not
16409b0b
GM
2145 (or (eq (char-after) ?=)
2146 (eq (char-after) ?x)
2147 (eq (char-after) ?j)))))
eec82323
LMI
2148 (progn
2149 (set group (cons min max))
2150 ;; if group is moderated, stick in moderation table
16409b0b 2151 (when (eq (char-after) ?m)
eec82323
LMI
2152 (unless gnus-moderated-hashtb
2153 (setq gnus-moderated-hashtb (gnus-make-hashtable)))
2154 (gnus-sethash (symbol-name group) t
2155 gnus-moderated-hashtb)))
2156 (set group nil)))
2157 (error
2158 (and group
2159 (symbolp group)
2160 (set group nil))
2161 (unless ignore-errors
16409b0b 2162 (gnus-message 3 "Warning - invalid active: %s"
eec82323 2163 (buffer-substring
01c52d31 2164 (point-at-bol) (point-at-eol))))))
eec82323
LMI
2165 (widen)
2166 (forward-line 1)))))
2167
6748645f 2168(defun gnus-groups-to-gnus-format (method &optional hashtb real-active)
eec82323
LMI
2169 ;; Parse a "groups" active file.
2170 (let ((cur (current-buffer))
2171 (hashtb (or hashtb
2172 (if (and method gnus-active-hashtb)
2173 gnus-active-hashtb
2174 (setq gnus-active-hashtb
2175 (gnus-make-hashtable
2176 (count-lines (point-min) (point-max)))))))
2177 (prefix (and method
2178 (not (gnus-server-equal
2179 (gnus-server-get-method nil method)
2180 (gnus-server-get-method nil gnus-select-method)))
2181 (gnus-group-prefixed-name "" method))))
2182
6748645f 2183 ;; Let the Gnus agent save the active file.
16409b0b
GM
2184 (if (and gnus-agent
2185 real-active
23f87bed 2186 (gnus-online method)
16409b0b
GM
2187 (gnus-agent-method-p method))
2188 (progn
54506618 2189 (gnus-agent-save-active method)
16409b0b
GM
2190 (gnus-active-to-gnus-format method hashtb nil real-active))
2191
2192 (goto-char (point-min))
2193 ;; We split this into to separate loops, one with the prefix
2194 ;; and one without to speed the reading up somewhat.
2195 (if prefix
2196 (let (min max opoint group)
2197 (while (not (eobp))
2198 (condition-case ()
2199 (progn
2200 (read cur) (read cur)
2201 (setq min (read cur)
2202 max (read cur)
2203 opoint (point))
2204 (skip-chars-forward " \t")
2205 (insert prefix)
2206 (goto-char opoint)
2207 (set (let ((obarray hashtb)) (read cur))
2208 (cons min max)))
2209 (error (and group (symbolp group) (set group nil))))
2210 (forward-line 1)))
2211 (let (min max group)
eec82323
LMI
2212 (while (not (eobp))
2213 (condition-case ()
16409b0b 2214 (when (eq (char-after) ?2)
eec82323
LMI
2215 (read cur) (read cur)
2216 (setq min (read cur)
16409b0b
GM
2217 max (read cur))
2218 (set (setq group (let ((obarray hashtb)) (read cur)))
eec82323
LMI
2219 (cons min max)))
2220 (error (and group (symbolp group) (set group nil))))
16409b0b 2221 (forward-line 1)))))))
eec82323
LMI
2222
2223(defun gnus-read-newsrc-file (&optional force)
2224 "Read startup file.
2225If FORCE is non-nil, the .newsrc file is read."
2226 ;; Reset variables that might be defined in the .newsrc.eld file.
23f87bed 2227 (let ((variables (remove 'gnus-format-specs gnus-variable-list)))
eec82323
LMI
2228 (while variables
2229 (set (car variables) nil)
2230 (setq variables (cdr variables))))
2231 (let* ((newsrc-file gnus-current-startup-file)
2232 (quick-file (concat newsrc-file ".el")))
2233 (save-excursion
2234 ;; We always load the .newsrc.eld file. If always contains
2235 ;; much information that can not be gotten from the .newsrc
2236 ;; file (ticked articles, killed groups, foreign methods, etc.)
2237 (gnus-read-newsrc-el-file quick-file)
2238
16409b0b
GM
2239 (when (and gnus-read-newsrc-file
2240 (file-exists-p gnus-current-startup-file)
eec82323
LMI
2241 (or force
2242 (and (file-newer-than-file-p newsrc-file quick-file)
2243 (file-newer-than-file-p newsrc-file
2244 (concat quick-file "d")))
2245 (not gnus-newsrc-alist)))
2246 ;; We read the .newsrc file. Note that if there if a
2247 ;; .newsrc.eld file exists, it has already been read, and
2248 ;; the `gnus-newsrc-hashtb' has been created. While reading
2249 ;; the .newsrc file, Gnus will only use the information it
2250 ;; can find there for changing the data already read -
2251 ;; i. e., reading the .newsrc file will not trash the data
2252 ;; already read (except for read articles).
2253 (save-excursion
2254 (gnus-message 5 "Reading %s..." newsrc-file)
2255 (set-buffer (nnheader-find-file-noselect newsrc-file))
16409b0b 2256 (buffer-disable-undo)
eec82323
LMI
2257 (gnus-newsrc-to-gnus-format)
2258 (kill-buffer (current-buffer))
2259 (gnus-message 5 "Reading %s...done" newsrc-file)))
2260
2261 ;; Convert old to new.
2262 (gnus-convert-old-newsrc))))
2263
2264(defun gnus-convert-old-newsrc ()
54506618 2265 "Convert old newsrc formats into the current format, if needed."
eec82323 2266 (let ((fcv (and gnus-newsrc-file-version
86713405
MB
2267 (gnus-continuum-version gnus-newsrc-file-version)))
2268 (gcv (gnus-continuum-version)))
54506618
MB
2269 (when fcv
2270 ;; A newsrc file was loaded.
2271 (let (prompt-displayed
2272 (converters
2273 (sort
2274 (mapcar (lambda (date-func)
2275 (cons (gnus-continuum-version (car date-func))
2276 date-func))
2277 ;; This is a list of converters that must be run
2278 ;; to bring the newsrc file up to the current
2279 ;; version. If you create an incompatibility
2280 ;; with older versions, you should create an
2281 ;; entry here. The entry should consist of the
2282 ;; current gnus version (hardcoded so that it
2283 ;; doesn't change with each release) and the
2284 ;; function that must be applied to convert the
2285 ;; previous version into the current version.
c825ac9d 2286 '(("September Gnus v0.1" nil
54506618
MB
2287 gnus-convert-old-ticks)
2288 ("Oort Gnus v0.08" "legacy-gnus-agent"
2289 gnus-agent-convert-to-compressed-agentview)
c825ac9d 2290 ("Gnus v5.10.7" "legacy-gnus-agent"
54506618 2291 gnus-agent-unlist-expire-days)
c825ac9d 2292 ("Gnus v5.10.7" "legacy-gnus-agent"
54506618
MB
2293 gnus-agent-unhook-expire-days)))
2294 #'car-less-than-car)))
2295 ;; Skip converters older than the file version
2296 (while (and converters (>= fcv (caar converters)))
2297 (pop converters))
2298
2299 ;; Perform converters to bring older version up to date.
2300 (when (and converters (< fcv (caar converters)))
d5ddd795 2301 (while (and converters (< fcv (caar converters))
86713405 2302 (<= (caar converters) gcv))
54506618
MB
2303 (let* ((converter-spec (pop converters))
2304 (convert-to (nth 1 converter-spec))
2305 (load-from (nth 2 converter-spec))
2306 (func (nth 3 converter-spec)))
2307 (when (and load-from
2308 (not (fboundp func)))
2309 (load load-from t))
54506618
MB
2310 (or prompt-displayed
2311 (not (gnus-convert-converter-needs-prompt func))
2312 (while (let (c
2313 (cursor-in-echo-area t)
2314 (echo-keystrokes 0))
2315 (message "Convert gnus from version '%s' to '%s'? (n/y/?)"
2316 gnus-newsrc-file-version gnus-version)
2317 (setq c (read-char-exclusive))
2318
2319 (cond ((or (eq c ?n) (eq c ?N))
2320 (error "Can not start gnus without converting"))
2321 ((or (eq c ?y) (eq c ?Y))
2322 (setq prompt-displayed t)
2323 nil)
2324 ((eq c ?\?)
2325 (message "This conversion is irreversible. \
2326 To be safe, you should backup your files before proceeding.")
2327 (sit-for 5)
2328 t)
2329 (t
2330 (gnus-message 3 "Ignoring unexpected input")
2331 (sit-for 3)
2332 t)))))
2333
2334 (funcall func convert-to)))
bf247b6e 2335 (gnus-dribble-enter
54506618
MB
2336 (format ";Converted gnus from version '%s' to '%s'."
2337 gnus-newsrc-file-version gnus-version)))))))
2338
2339(defun gnus-convert-mark-converter-prompt (converter no-prompt)
2340 "Indicate whether CONVERTER requires gnus-convert-old-newsrc to
2341 display the conversion prompt. NO-PROMPT may be nil (prompt),
2342 t (no prompt), or any form that can be called as a function.
2343 The form should return either t or nil."
2344 (put converter 'gnus-convert-no-prompt no-prompt))
2345
2346(defun gnus-convert-converter-needs-prompt (converter)
2347 (let ((no-prompt (get converter 'gnus-convert-no-prompt)))
2348 (not (if (memq no-prompt '(t nil))
2349 no-prompt
2350 (funcall no-prompt)))))
2351
2352(defun gnus-convert-old-ticks (converting-to)
eec82323
LMI
2353 (let ((newsrc (cdr gnus-newsrc-alist))
2354 marks info dormant ticked)
2355 (while (setq info (pop newsrc))
2356 (when (setq marks (gnus-info-marks info))
2357 (setq dormant (cdr (assq 'dormant marks))
2358 ticked (cdr (assq 'tick marks)))
2359 (when (or dormant ticked)
2360 (gnus-info-set-read
2361 info
2362 (gnus-add-to-range
2363 (gnus-info-read info)
2364 (nconc (gnus-uncompress-range dormant)
2365 (gnus-uncompress-range ticked)))))))))
2366
23f87bed
MB
2367(defun gnus-load (file)
2368 "Load FILE, but in such a way that read errors can be reported."
2369 (with-temp-buffer
2370 (insert-file-contents file)
2371 (while (not (eobp))
2372 (condition-case type
2373 (let ((form (read (current-buffer))))
2374 (eval form))
2375 (error
2376 (unless (eq (car type) 'end-of-file)
af5370ad 2377 (let ((errmsg (format "Error in %s line %d" file
80d06753 2378 (count-lines (point-min) (point)))))
23f87bed 2379 (ding)
af5370ad
RS
2380 (unless (gnus-yes-or-no-p (concat errmsg "; continue? "))
2381 (error "%s" errmsg)))))))))
23f87bed 2382
eec82323
LMI
2383(defun gnus-read-newsrc-el-file (file)
2384 (let ((ding-file (concat file "d")))
23f87bed
MB
2385 (when (file-exists-p ding-file)
2386 ;; We always, always read the .eld file.
2387 (gnus-message 5 "Reading %s..." ding-file)
2388 (let (gnus-newsrc-assoc)
a37d67dd 2389 (gnus-load ding-file)
23f87bed
MB
2390 ;; Older versions of `gnus-format-specs' are no longer valid
2391 ;; in Oort Gnus 0.01.
2392 (let ((version
2393 (and gnus-newsrc-file-version
2394 (gnus-continuum-version gnus-newsrc-file-version))))
2395 (when (or (not version)
2396 (< version 5.090009))
2397 (setq gnus-format-specs gnus-default-format-specs)))
2398 (when gnus-newsrc-assoc
2399 (setq gnus-newsrc-alist gnus-newsrc-assoc))))
01c52d31
MB
2400 (dolist (elem gnus-newsrc-alist)
2401 (setcar elem (mm-string-as-unibyte (car elem))))
eec82323
LMI
2402 (gnus-make-hashtable-from-newsrc-alist)
2403 (when (file-newer-than-file-p file ding-file)
2404 ;; Old format quick file
2405 (gnus-message 5 "Reading %s..." file)
2406 ;; The .el file is newer than the .eld file, so we read that one
2407 ;; as well.
23f87bed
MB
2408 (gnus-read-old-newsrc-el-file file)))
2409 (gnus-run-hooks 'gnus-read-newsrc-el-hook))
eec82323
LMI
2410
2411;; Parse the old-style quick startup file
2412(defun gnus-read-old-newsrc-el-file (file)
2413 (let (newsrc killed marked group m info)
2414 (prog1
2415 (let ((gnus-killed-assoc nil)
2416 gnus-marked-assoc gnus-newsrc-alist gnus-newsrc-assoc)
2417 (prog1
2418 (ignore-errors
2419 (load file t t t))
2420 (setq newsrc gnus-newsrc-assoc
2421 killed gnus-killed-assoc
2422 marked gnus-marked-assoc)))
2423 (setq gnus-newsrc-alist nil)
2424 (while (setq group (pop newsrc))
2425 (if (setq info (gnus-get-info (car group)))
2426 (progn
2427 (gnus-info-set-read info (cddr group))
2428 (gnus-info-set-level
2429 info (if (nth 1 group) gnus-level-default-subscribed
2430 gnus-level-default-unsubscribed))
2431 (push info gnus-newsrc-alist))
2432 (push (setq info
2433 (list (car group)
2434 (if (nth 1 group) gnus-level-default-subscribed
2435 gnus-level-default-unsubscribed)
2436 (cddr group)))
2437 gnus-newsrc-alist))
2438 ;; Copy marks into info.
2439 (when (setq m (assoc (car group) marked))
2440 (unless (nthcdr 3 info)
2441 (nconc info (list nil)))
2442 (gnus-info-set-marks
2443 info (list (cons 'tick (gnus-compress-sequence
2444 (sort (cdr m) '<) t))))))
2445 (setq newsrc killed)
2446 (while newsrc
2447 (setcar newsrc (caar newsrc))
2448 (setq newsrc (cdr newsrc)))
2449 (setq gnus-killed-list killed))
2450 ;; The .el file version of this variable does not begin with
2451 ;; "options", while the .eld version does, so we just add it if it
2452 ;; isn't there.
2453 (when
2454 gnus-newsrc-options
2455 (when (not (string-match "^ *options" gnus-newsrc-options))
2456 (setq gnus-newsrc-options (concat "options " gnus-newsrc-options)))
2457 (when (not (string-match "\n$" gnus-newsrc-options))
2458 (setq gnus-newsrc-options (concat gnus-newsrc-options "\n")))
2459 ;; Finally, if we read some options lines, we parse them.
2460 (unless (string= gnus-newsrc-options "")
2461 (gnus-newsrc-parse-options gnus-newsrc-options)))
2462
2463 (setq gnus-newsrc-alist (nreverse gnus-newsrc-alist))
2464 (gnus-make-hashtable-from-newsrc-alist)))
2465
2466(defun gnus-make-newsrc-file (file)
2467 "Make server dependent file name by catenating FILE and server host name."
2468 (let* ((file (expand-file-name file nil))
2469 (real-file (concat file "-" (nth 1 gnus-select-method))))
2470 (if (or (file-exists-p real-file)
2471 (file-exists-p (concat real-file ".el"))
2472 (file-exists-p (concat real-file ".eld")))
6748645f
LMI
2473 real-file
2474 file)))
eec82323
LMI
2475
2476(defun gnus-newsrc-to-gnus-format ()
2477 (setq gnus-newsrc-options "")
2478 (setq gnus-newsrc-options-n nil)
2479
2480 (unless gnus-active-hashtb
2481 (setq gnus-active-hashtb (gnus-make-hashtable 4096)))
2482 (let ((buf (current-buffer))
2483 (already-read (> (length gnus-newsrc-alist) 1))
2484 group subscribed options-symbol newsrc Options-symbol
2485 symbol reads num1)
2486 (goto-char (point-min))
2487 ;; We intern the symbol `options' in the active hashtb so that we
2488 ;; can `eq' against it later.
2489 (set (setq options-symbol (intern "options" gnus-active-hashtb)) nil)
2490 (set (setq Options-symbol (intern "Options" gnus-active-hashtb)) nil)
2491
2492 (while (not (eobp))
2493 ;; We first read the first word on the line by narrowing and
2494 ;; then reading into `gnus-active-hashtb'. Most groups will
2495 ;; already exist in that hashtb, so this will save some string
2496 ;; space.
2497 (narrow-to-region
2498 (point)
2499 (progn (skip-chars-forward "^ \t!:\n") (point)))
2500 (goto-char (point-min))
2501 (setq symbol
2502 (and (/= (point-min) (point-max))
2503 (let ((obarray gnus-active-hashtb)) (read buf))))
2504 (widen)
2505 ;; Now, the symbol we have read is either `options' or a group
2506 ;; name. If it is an options line, we just add it to a string.
2507 (cond
2508 ((or (eq symbol options-symbol)
2509 (eq symbol Options-symbol))
2510 (setq gnus-newsrc-options
2511 ;; This concating is quite inefficient, but since our
2512 ;; thorough studies show that approx 99.37% of all
2513 ;; .newsrc files only contain a single options line, we
2514 ;; don't give a damn, frankly, my dear.
2515 (concat gnus-newsrc-options
2516 (buffer-substring
01c52d31 2517 (point-at-bol)
eec82323
LMI
2518 ;; Options may continue on the next line.
2519 (or (and (re-search-forward "^[^ \t]" nil 'move)
01c52d31 2520 (point-at-bol))
eec82323
LMI
2521 (point)))))
2522 (forward-line -1))
2523 (symbol
2524 ;; Group names can be just numbers.
2525 (when (numberp symbol)
2526 (setq symbol (intern (int-to-string symbol) gnus-active-hashtb)))
2527 (unless (boundp symbol)
2528 (set symbol nil))
2529 ;; It was a group name.
16409b0b 2530 (setq subscribed (eq (char-after) ?:)
eec82323
LMI
2531 group (symbol-name symbol)
2532 reads nil)
2533 (if (eolp)
2534 ;; If the line ends here, this is clearly a buggy line, so
23f87bed 2535 ;; we put point a the beginning of line and let the cond
eec82323
LMI
2536 ;; below do the error handling.
2537 (beginning-of-line)
2538 ;; We skip to the beginning of the ranges.
2539 (skip-chars-forward "!: \t"))
2540 ;; We are now at the beginning of the list of read articles.
2541 ;; We read them range by range.
2542 (while
2543 (cond
2544 ((looking-at "[0-9]+")
2545 ;; We narrow and read a number instead of buffer-substring/
e9bd5782 2546 ;; string-to-number because it's faster. narrow/widen is
eec82323
LMI
2547 ;; faster than save-restriction/narrow, and save-restriction
2548 ;; produces a garbage object.
2549 (setq num1 (progn
2550 (narrow-to-region (match-beginning 0) (match-end 0))
2551 (read buf)))
2552 (widen)
2553 ;; If the next character is a dash, then this is a range.
16409b0b 2554 (if (eq (char-after) ?-)
eec82323
LMI
2555 (progn
2556 ;; We read the upper bound of the range.
2557 (forward-char 1)
2558 (if (not (looking-at "[0-9]+"))
2559 ;; This is a buggy line, by we pretend that
2560 ;; it's kinda OK. Perhaps the user should be
2561 ;; dinged?
2562 (push num1 reads)
2563 (push
2564 (cons num1
2565 (progn
2566 (narrow-to-region (match-beginning 0)
2567 (match-end 0))
2568 (read buf)))
2569 reads)
2570 (widen)))
2571 ;; It was just a simple number, so we add it to the
2572 ;; list of ranges.
2573 (push num1 reads))
2574 ;; If the next char in ?\n, then we have reached the end
2575 ;; of the line and return nil.
16409b0b
GM
2576 (not (eq (char-after) ?\n)))
2577 ((eq (char-after) ?\n)
eec82323
LMI
2578 ;; End of line, so we end.
2579 nil)
2580 (t
2581 ;; Not numbers and not eol, so this might be a buggy
2582 ;; line...
2583 (unless (eobp)
2584 ;; If it was eob instead of ?\n, we allow it.
2585 ;; The line was buggy.
2586 (setq group nil)
2587 (gnus-error 3.1 "Mangled line: %s"
01c52d31
MB
2588 (buffer-substring (point-at-bol)
2589 (point-at-eol))))
eec82323 2590 nil))
16409b0b 2591 ;; Skip past ", ". Spaces are invalid in these ranges, but
eec82323
LMI
2592 ;; we allow them, because it's a common mistake to put a
2593 ;; space after the comma.
2594 (skip-chars-forward ", "))
2595
2596 ;; We have already read .newsrc.eld, so we gently update the
2597 ;; data in the hash table with the information we have just
2598 ;; read.
2599 (when group
2600 (let ((info (gnus-get-info group))
2601 level)
2602 (if info
2603 ;; There is an entry for this file in the alist.
2604 (progn
2605 (gnus-info-set-read info (nreverse reads))
2606 ;; We update the level very gently. In fact, we
2607 ;; only change it if there's been a status change
2608 ;; from subscribed to unsubscribed, or vice versa.
2609 (setq level (gnus-info-level info))
2610 (cond ((and (<= level gnus-level-subscribed)
2611 (not subscribed))
2612 (setq level (if reads
2613 gnus-level-default-unsubscribed
2614 (1+ gnus-level-default-unsubscribed))))
2615 ((and (> level gnus-level-subscribed) subscribed)
2616 (setq level gnus-level-default-subscribed)))
2617 (gnus-info-set-level info level))
2618 ;; This is a new group.
2619 (setq info (list group
2620 (if subscribed
2621 gnus-level-default-subscribed
2622 (if reads
2623 (1+ gnus-level-subscribed)
2624 gnus-level-default-unsubscribed))
2625 (nreverse reads))))
2626 (push info newsrc)))))
2627 (forward-line 1))
2628
2629 (setq newsrc (nreverse newsrc))
2630
2631 (if (not already-read)
2632 ()
2633 ;; We now have two newsrc lists - `newsrc', which is what we
2634 ;; have read from .newsrc, and `gnus-newsrc-alist', which is
2635 ;; what we've read from .newsrc.eld. We have to merge these
2636 ;; lists. We do this by "attaching" any (foreign) groups in the
2637 ;; gnus-newsrc-alist to the (native) group that precedes them.
2638 (let ((rc (cdr gnus-newsrc-alist))
2639 (prev gnus-newsrc-alist)
2640 entry mentry)
2641 (while rc
2642 (or (null (nth 4 (car rc))) ; It's a native group.
2643 (assoc (caar rc) newsrc) ; It's already in the alist.
2644 (if (setq entry (assoc (caar prev) newsrc))
2645 (setcdr (setq mentry (memq entry newsrc))
2646 (cons (car rc) (cdr mentry)))
2647 (push (car rc) newsrc)))
2648 (setq prev rc
2649 rc (cdr rc)))))
2650
2651 (setq gnus-newsrc-alist newsrc)
2652 ;; We make the newsrc hashtb.
2653 (gnus-make-hashtable-from-newsrc-alist)
2654
2655 ;; Finally, if we read some options lines, we parse them.
2656 (unless (string= gnus-newsrc-options "")
2657 (gnus-newsrc-parse-options gnus-newsrc-options))))
2658
2659;; Parse options lines to find "options -n !all rec.all" and stuff.
2660;; The return value will be a list on the form
2661;; ((regexp1 . ignore)
2662;; (regexp2 . subscribe)...)
2663;; When handling new newsgroups, groups that match a `ignore' regexp
2664;; will be ignored, and groups that match a `subscribe' regexp will be
2665;; subscribed. A line like
2666;; options -n !all rec.all
2667;; will lead to a list that looks like
2668;; (("^rec\\..+" . subscribe)
2669;; ("^.+" . ignore))
2670;; So all "rec.*" groups will be subscribed, while all the other
2671;; groups will be ignored. Note that "options -n !all rec.all" is very
2672;; different from "options -n rec.all !all".
2673(defun gnus-newsrc-parse-options (options)
2674 (let (out eol)
2675 (save-excursion
2676 (gnus-set-work-buffer)
2677 (insert (regexp-quote options))
2678 ;; First we treat all continuation lines.
2679 (goto-char (point-min))
2680 (while (re-search-forward "\n[ \t]+" nil t)
2681 (replace-match " " t t))
2682 ;; Then we transform all "all"s into ".+"s.
2683 (goto-char (point-min))
2684 (while (re-search-forward "\\ball\\b" nil t)
2685 (replace-match ".+" t t))
2686 (goto-char (point-min))
2687 ;; We remove all other options than the "-n" ones.
2688 (while (re-search-forward "[ \t]-[^n][^-]*" nil t)
2689 (replace-match " ")
2690 (forward-char -1))
2691 (goto-char (point-min))
2692
2693 ;; We are only interested in "options -n" lines - we
2694 ;; ignore the other option lines.
2695 (while (re-search-forward "[ \t]-n" nil t)
2696 (setq eol
2697 (or (save-excursion
01c52d31 2698 (and (re-search-forward "[ \t]-n" (point-at-eol) t)
eec82323 2699 (- (point) 2)))
01c52d31 2700 (point-at-eol)))
eec82323
LMI
2701 ;; Search for all "words"...
2702 (while (re-search-forward "[^ \t,\n]+" eol t)
16409b0b 2703 (if (eq (char-after (match-beginning 0)) ?!)
eec82323
LMI
2704 ;; If the word begins with a bang (!), this is a "not"
2705 ;; spec. We put this spec (minus the bang) and the
2706 ;; symbol `ignore' into the list.
2707 (push (cons (concat
2708 "^" (buffer-substring
2709 (1+ (match-beginning 0))
6748645f
LMI
2710 (match-end 0))
2711 "\\($\\|\\.\\)")
eec82323
LMI
2712 'ignore)
2713 out)
2714 ;; There was no bang, so this is a "yes" spec.
6748645f 2715 (push (cons (concat "^" (match-string 0) "\\($\\|\\.\\)")
eec82323
LMI
2716 'subscribe)
2717 out))))
2718
2719 (setq gnus-newsrc-options-n out))))
2720
23f87bed
MB
2721(eval-and-compile
2722 (defalias 'gnus-long-file-names
2723 (if (fboundp 'msdos-long-file-names)
2724 'msdos-long-file-names
2725 (lambda () t))))
2726
eec82323
LMI
2727(defun gnus-save-newsrc-file (&optional force)
2728 "Save .newsrc file."
2729 ;; Note: We cannot save .newsrc file if all newsgroups are removed
2730 ;; from the variable gnus-newsrc-alist.
2731 (when (and (or gnus-newsrc-alist gnus-killed-list)
2732 gnus-current-startup-file)
54506618
MB
2733 ;; Save agent range limits for the currently active method.
2734 (when gnus-agent
2735 (gnus-agent-save-local force))
2736
eec82323
LMI
2737 (save-excursion
2738 (if (and (or gnus-use-dribble-file gnus-slave)
2739 (not force)
2740 (or (not gnus-dribble-buffer)
2741 (not (buffer-name gnus-dribble-buffer))
20a673b2 2742 (zerop (with-current-buffer gnus-dribble-buffer
eec82323
LMI
2743 (buffer-size)))))
2744 (gnus-message 4 "(No changes need to be saved)")
6748645f 2745 (gnus-run-hooks 'gnus-save-newsrc-hook)
eec82323
LMI
2746 (if gnus-slave
2747 (gnus-slave-save-newsrc)
2748 ;; Save .newsrc.
2749 (when gnus-save-newsrc-file
2750 (gnus-message 8 "Saving %s..." gnus-current-startup-file)
2751 (gnus-gnus-to-newsrc-format)
2752 (gnus-message 8 "Saving %s...done" gnus-current-startup-file))
54506618 2753
eec82323 2754 ;; Save .newsrc.eld.
6748645f 2755 (set-buffer (gnus-get-buffer-create " *Gnus-newsrc*"))
eec82323 2756 (make-local-variable 'version-control)
23f87bed 2757 (setq version-control gnus-backup-startup-file)
eec82323
LMI
2758 (setq buffer-file-name
2759 (concat gnus-current-startup-file ".eld"))
2760 (setq default-directory (file-name-directory buffer-file-name))
16409b0b 2761 (buffer-disable-undo)
eec82323 2762 (erase-buffer)
23f87bed
MB
2763 (gnus-message 5 "Saving %s.eld..." gnus-current-startup-file)
2764
2765 (if gnus-save-startup-file-via-temp-buffer
2766 (let ((coding-system-for-write gnus-ding-file-coding-system)
2767 (standard-output (current-buffer)))
2768 (gnus-gnus-to-quick-newsrc-format)
2769 (gnus-run-hooks 'gnus-save-quick-newsrc-hook)
2770 (save-buffer))
2771 (let ((coding-system-for-write gnus-ding-file-coding-system)
2772 (version-control gnus-backup-startup-file)
2773 (startup-file (concat gnus-current-startup-file ".eld"))
2774 (working-dir (file-name-directory gnus-current-startup-file))
2775 working-file
2776 (i -1))
2777 ;; Generate the name of a non-existent file.
2778 (while (progn (setq working-file
2779 (format
2780 (if (and (eq system-type 'ms-dos)
2781 (not (gnus-long-file-names)))
2782 "%s#%d.tm#" ; MSDOS limits files to 8+3
7c2fb837 2783 "%s#tmp#%d")
23f87bed
MB
2784 working-dir (setq i (1+ i))))
2785 (file-exists-p working-file)))
2786
2787 (unwind-protect
2788 (progn
2789 (gnus-with-output-to-file working-file
2790 (gnus-gnus-to-quick-newsrc-format)
2791 (gnus-run-hooks 'gnus-save-quick-newsrc-hook))
2792
2793 ;; These bindings will mislead the current buffer
2794 ;; into thinking that it is visiting the startup
2795 ;; file.
2796 (let ((buffer-backed-up nil)
2797 (buffer-file-name startup-file)
2798 (file-precious-flag t)
2799 (setmodes (file-modes startup-file)))
2800 ;; Backup the current version of the startup file.
2801 (backup-buffer)
2802
2803 ;; Replace the existing startup file with the temp file.
2804 (rename-file working-file startup-file t)
01c52d31 2805 (gnus-set-file-modes startup-file setmodes)))
23f87bed
MB
2806 (condition-case nil
2807 (delete-file working-file)
2808 (file-error nil)))))
2809
2810 (gnus-kill-buffer (current-buffer))
eec82323
LMI
2811 (gnus-message
2812 5 "Saving %s.eld...done" gnus-current-startup-file))
2813 (gnus-dribble-delete-file)
2814 (gnus-group-set-mode-line)))))
2815
23f87bed
MB
2816(defun gnus-gnus-to-quick-newsrc-format (&optional minimal name &rest specific-variables)
2817 "Print Gnus variables such as `gnus-newsrc-alist' in Lisp format."
627e1fdf 2818 (princ (format ";; -*- mode:emacs-lisp; coding: %s; -*-\n"
a37d67dd 2819 gnus-ding-file-coding-system))
23f87bed
MB
2820 (if name
2821 (princ (format ";; %s\n" name))
2822 (princ ";; Gnus startup file.\n"))
16409b0b 2823
23f87bed
MB
2824 (unless minimal
2825 (princ "\
6748645f
LMI
2826;; Never delete this file -- if you want to force Gnus to read the
2827;; .newsrc file (if you have one), touch .newsrc instead.\n")
23f87bed
MB
2828 (princ "(setq gnus-newsrc-file-version ")
2829 (princ (gnus-prin1-to-string gnus-version))
2830 (princ ")\n"))
2831
2832 (let* ((print-quoted t)
2833 (print-readably t)
2834 (print-escape-multibyte nil)
2835 (print-escape-nonascii t)
2836 (print-length nil)
2837 (print-level nil)
7dafe00b 2838 (print-circle nil)
23f87bed
MB
2839 (print-escape-newlines t)
2840 (gnus-killed-list
eec82323
LMI
2841 (if (and gnus-save-killed-list
2842 (stringp gnus-save-killed-list))
2843 (gnus-strip-killed-list)
2844 gnus-killed-list))
2845 (variables
23f87bed
MB
2846 (or specific-variables
2847 (if gnus-save-killed-list gnus-variable-list
2848 ;; Remove the `gnus-killed-list' from the list of variables
2849 ;; to be saved, if required.
2850 (delq 'gnus-killed-list (copy-sequence gnus-variable-list)))))
eec82323
LMI
2851 ;; Peel off the "dummy" group.
2852 (gnus-newsrc-alist (cdr gnus-newsrc-alist))
2853 variable)
2854 ;; Insert the variables into the file.
2855 (while variables
2856 (when (and (boundp (setq variable (pop variables)))
2857 (symbol-value variable))
01c52d31 2858 (princ "\n(setq ")
23f87bed
MB
2859 (princ (symbol-name variable))
2860 (princ " '")
2861 (prin1 (symbol-value variable))
2862 (princ ")\n")))))
eec82323
LMI
2863
2864(defun gnus-strip-killed-list ()
2865 "Return the killed list minus the groups that match `gnus-save-killed-list'."
2866 (let ((list gnus-killed-list)
2867 olist)
2868 (while list
6748645f 2869 (when (string-match gnus-save-killed-list (car list))
eec82323
LMI
2870 (push (car list) olist))
2871 (pop list))
2872 (nreverse olist)))
2873
2874(defun gnus-gnus-to-newsrc-format ()
2875 ;; Generate and save the .newsrc file.
20a673b2 2876 (with-current-buffer (create-file-buffer gnus-current-startup-file)
eec82323
LMI
2877 (let ((newsrc (cdr gnus-newsrc-alist))
2878 (standard-output (current-buffer))
2879 info ranges range method)
2880 (setq buffer-file-name gnus-current-startup-file)
2881 (setq default-directory (file-name-directory buffer-file-name))
16409b0b 2882 (buffer-disable-undo)
eec82323 2883 (erase-buffer)
01c52d31
MB
2884 ;; Use a unibyte buffer since group names are unibyte strings;
2885 ;; in particular, non-ASCII group names are the ones encoded by
2886 ;; a certain coding system.
2887 (mm-disable-multibyte)
eec82323
LMI
2888 ;; Write options.
2889 (when gnus-newsrc-options
2890 (insert gnus-newsrc-options))
2891 ;; Write subscribed and unsubscribed.
2892 (while (setq info (pop newsrc))
2893 ;; Don't write foreign groups to .newsrc.
2894 (when (or (null (setq method (gnus-info-method info)))
2895 (equal method "native")
2896 (inline (gnus-server-equal method gnus-select-method)))
2897 (insert (gnus-info-group info)
2898 (if (> (gnus-info-level info) gnus-level-subscribed)
2899 "!" ":"))
2900 (when (setq ranges (gnus-info-read info))
2901 (insert " ")
2902 (if (not (listp (cdr ranges)))
2903 (if (= (car ranges) (cdr ranges))
2904 (princ (car ranges))
2905 (princ (car ranges))
2906 (insert "-")
2907 (princ (cdr ranges)))
2908 (while (setq range (pop ranges))
2909 (if (or (atom range) (= (car range) (cdr range)))
2910 (princ (or (and (atom range) range) (car range)))
2911 (princ (car range))
2912 (insert "-")
2913 (princ (cdr range)))
2914 (when ranges
2915 (insert ",")))))
2916 (insert "\n")))
2917 (make-local-variable 'version-control)
2918 (setq version-control 'never)
2919 ;; It has been reported that sometime the modtime on the .newsrc
2920 ;; file seems to be off. We really do want to overwrite it, so
2921 ;; we clear the modtime here before saving. It's a bit odd,
2922 ;; though...
2923 ;; sometimes the modtime clear isn't sufficient. most brute force:
2924 ;; delete the silly thing entirely first. but this fails to provide
2925 ;; such niceties as .newsrc~ creation.
2926 (if gnus-modtime-botch
2927 (delete-file gnus-startup-file)
2928 (clear-visited-file-modtime))
6748645f 2929 (gnus-run-hooks 'gnus-save-standard-newsrc-hook)
01c52d31
MB
2930 (let ((coding-system-for-write 'raw-text))
2931 (save-buffer))
eec82323
LMI
2932 (kill-buffer (current-buffer)))))
2933
2934\f
2935;;;
2936;;; Slave functions.
2937;;;
2938
6748645f
LMI
2939(defvar gnus-slave-mode nil)
2940
2941(defun gnus-slave-mode ()
2942 "Minor mode for slave Gnusae."
bbf52f1e
SM
2943 ;; FIXME: gnus-slave-mode appears to never be set (i.e. it'll always be nil):
2944 ;; Remove, or fix and use define-minor-mode.
01c52d31 2945 (add-minor-mode 'gnus-slave-mode " Slave" (make-sparse-keymap))
6748645f
LMI
2946 (gnus-run-hooks 'gnus-slave-mode-hook))
2947
eec82323 2948(defun gnus-slave-save-newsrc ()
20a673b2 2949 (with-current-buffer gnus-dribble-buffer
eec82323 2950 (let ((slave-name
3efe5554 2951 (mm-make-temp-file (concat gnus-current-startup-file "-slave-")))
eec82323
LMI
2952 (modes (ignore-errors
2953 (file-modes (concat gnus-current-startup-file ".eld")))))
2d2820a4 2954 (let ((coding-system-for-write gnus-ding-file-coding-system))
16409b0b 2955 (gnus-write-buffer slave-name))
eec82323 2956 (when modes
01c52d31 2957 (gnus-set-file-modes slave-name modes)))))
eec82323
LMI
2958
2959(defun gnus-master-read-slave-newsrc ()
2960 (let ((slave-files
2961 (directory-files
2962 (file-name-directory gnus-current-startup-file)
2963 t (concat
2964 "^" (regexp-quote
2965 (concat
2966 (file-name-nondirectory gnus-current-startup-file)
2967 "-slave-")))
2968 t))
2969 file)
2970 (if (not slave-files)
2971 () ; There are no slave files to read.
2972 (gnus-message 7 "Reading slave newsrcs...")
20a673b2 2973 (with-current-buffer (gnus-get-buffer-create " *gnus slave*")
eec82323
LMI
2974 (setq slave-files
2975 (sort (mapcar (lambda (file)
2976 (list (nth 5 (file-attributes file)) file))
2977 slave-files)
2978 (lambda (f1 f2)
2979 (or (< (caar f1) (caar f2))
2980 (< (nth 1 (car f1)) (nth 1 (car f2)))))))
2981 (while slave-files
2982 (erase-buffer)
2983 (setq file (nth 1 (car slave-files)))
16409b0b 2984 (nnheader-insert-file-contents file)
eec82323
LMI
2985 (when (condition-case ()
2986 (progn
2987 (eval-buffer (current-buffer))
2988 t)
2989 (error
2990 (gnus-error 3.2 "Possible error in %s" file)
2991 nil))
2992 (unless gnus-slave ; Slaves shouldn't delete these files.
2993 (ignore-errors
2994 (delete-file file))))
2995 (setq slave-files (cdr slave-files))))
2996 (gnus-dribble-touch)
2997 (gnus-message 7 "Reading slave newsrcs...done"))))
2998
2999\f
3000;;;
3001;;; Group description.
3002;;;
3003
3004(defun gnus-read-all-descriptions-files ()
3005 (let ((methods (cons gnus-select-method
3006 (nconc
3007 (when (gnus-archive-server-wanted-p)
3008 (list "archive"))
3009 gnus-secondary-select-methods))))
3010 (while methods
3011 (gnus-read-descriptions-file (car methods))
3012 (setq methods (cdr methods)))
3013 t))
3014
3015(defun gnus-read-descriptions-file (&optional method)
3016 (let ((method (or method gnus-select-method))
3017 group)
3018 (when (stringp method)
3019 (setq method (gnus-server-to-method method)))
3020 ;; We create the hashtable whether we manage to read the desc file
3021 ;; to avoid trying to re-read after a failed read.
3022 (unless gnus-description-hashtb
3023 (setq gnus-description-hashtb
3024 (gnus-make-hashtable (length gnus-active-hashtb))))
3025 ;; Mark this method's desc file as read.
3026 (gnus-sethash (gnus-group-prefixed-name "" method) "Has read"
3027 gnus-description-hashtb)
3028
3029 (gnus-message 5 "Reading descriptions file via %s..." (car method))
3030 (cond
16409b0b
GM
3031 ((null (gnus-get-function method 'request-list-newsgroups t))
3032 t)
eec82323
LMI
3033 ((not (gnus-check-server method))
3034 (gnus-message 1 "Couldn't open server")
3035 nil)
3036 ((not (gnus-request-list-newsgroups method))
3037 (gnus-message 1 "Couldn't read newsgroups descriptions")
3038 nil)
3039 (t
3040 (save-excursion
bbf52f1e 3041 ;; FIXME: Shouldn't save-restriction be done after set-buffer?
eec82323
LMI
3042 (save-restriction
3043 (set-buffer nntp-server-buffer)
3044 (goto-char (point-min))
3045 (when (or (search-forward "\n.\n" nil t)
3046 (goto-char (point-max)))
3047 (beginning-of-line)
3048 (narrow-to-region (point-min) (point)))
3049 ;; If these are groups from a foreign select method, we insert the
3050 ;; group prefix in front of the group names.
3051 (and method (not (inline
3052 (gnus-server-equal
3053 (gnus-server-get-method nil method)
3054 (gnus-server-get-method
3055 nil gnus-select-method))))
3056 (let ((prefix (gnus-group-prefixed-name "" method)))
3057 (goto-char (point-min))
3058 (while (and (not (eobp))
3059 (progn (insert prefix)
3060 (zerop (forward-line 1)))))))
3061 (goto-char (point-min))
3062 (while (not (eobp))
3063 ;; If we get an error, we set group to 0, which is not a
3064 ;; symbol...
3065 (setq group
3066 (condition-case ()
3067 (let ((obarray gnus-description-hashtb))
3068 ;; Group is set to a symbol interned in this
3069 ;; hash table.
3070 (read nntp-server-buffer))
3071 (error 0)))
3072 (skip-chars-forward " \t")
3073 ;; ... which leads to this line being effectively ignored.
3074 (when (symbolp group)
23f87bed
MB
3075 (let* ((str (buffer-substring
3076 (point) (progn (end-of-line) (point))))
3077 (name (symbol-name group))
3078 (charset
3079 (or (gnus-group-name-charset method name)
3080 (gnus-parameter-charset name)
3081 gnus-default-charset)))
3082 ;; Fixme: Don't decode in unibyte mode.
3083 (when (and str charset (featurep 'mule))
3084 (setq str (mm-decode-coding-string str charset)))
0791fc56 3085 (set group str)))
eec82323
LMI
3086 (forward-line 1))))
3087 (gnus-message 5 "Reading descriptions file...done")
3088 t))))
3089
3090(defun gnus-group-get-description (group)
3091 "Get the description of a group by sending XGTITLE to the server."
3092 (when (gnus-request-group-description group)
20a673b2 3093 (with-current-buffer nntp-server-buffer
eec82323
LMI
3094 (goto-char (point-min))
3095 (when (looking-at "[^ \t]+[ \t]+\\(.*\\)")
3096 (match-string 1)))))
3097
3098;;;###autoload
3099(defun gnus-declare-backend (name &rest abilities)
23f87bed 3100 "Declare back end NAME with ABILITIES as a Gnus back end."
eec82323
LMI
3101 (setq gnus-valid-select-methods
3102 (nconc gnus-valid-select-methods
16409b0b
GM
3103 (list (apply 'list name abilities))))
3104 (gnus-redefine-select-method-widget))
eec82323
LMI
3105
3106(defun gnus-set-default-directory ()
3107 "Set the default directory in the current buffer to `gnus-default-directory'.
3108If this variable is nil, don't do anything."
3109 (setq default-directory
3110 (if (and gnus-default-directory
3111 (file-exists-p gnus-default-directory))
3112 (file-name-as-directory (expand-file-name gnus-default-directory))
3113 default-directory)))
3114
0302b80e
SM
3115(defun gnus-display-time-event-handler ()
3116 (if (and (fboundp 'display-time-event-handler)
3117 (gnus-boundp 'display-time-timer))
3118 (display-time-event-handler)))
23f87bed 3119
01c52d31
MB
3120(defun gnus-check-reasonable-setup ()
3121 ;; Check whether nnml and nnfolder share a directory.
3122 (let ((display-warn
3123 (if (fboundp 'display-warning)
3124 'display-warning
3125 (lambda (type message)
3126 (if noninteractive
3127 (message "Warning (%s): %s" type message)
3128 (let (window)
3129 (with-current-buffer (get-buffer-create "*Warnings*")
3130 (goto-char (point-max))
3131 (unless (bolp)
3132 (insert "\n"))
3133 (insert (format "Warning (%s): %s\n" type message))
3134 (setq window (display-buffer (current-buffer)))
3135 (set-window-start
3136 window
3137 (prog2
3138 (forward-line (- 1 (window-height window)))
3139 (point)
3140 (goto-char (point-max))))))))))
3141 method active actives match)
3142 (dolist (server gnus-server-alist)
3143 (setq method (gnus-server-to-method server)
3144 active (intern (format "%s-active-file" (car method))))
3145 (when (and (member (car method) '(nnml nnfolder))
3146 (gnus-server-opened method)
3147 (boundp active))
3148 (when (setq match (assoc (symbol-value active) actives))
3149 (funcall display-warn 'gnus-server
3150 (format "%s and %s share the same active file %s"
3151 (car method)
3152 (cadr match)
3153 (car match))))
3154 (push (list (symbol-value active) method) actives)))))
23f87bed 3155
eec82323
LMI
3156(provide 'gnus-start)
3157
3158;;; gnus-start.el ends here