* lisp/gnus/gnus-agent.el (gnus-agent-load-local)
(gnus-agent-expire-group-1, gnus-agent-update-files-total-fetched-for):
* lisp/gnus/gnus-art.el (gnus-article-header-rank):
* lisp/gnus/gnus-async.el (gnus-async-wait-for-article):
* lisp/gnus/gnus-cache.el (gnus-cache-update-file-total-fetched-for):
* lisp/gnus/gnus-registry.el (gnus-registry-import-eld):
* lisp/gnus/gnus-salt.el (gnus-pick-line-number, gnus-tree-minimize)
(gnus-generate-vertical-tree):
* lisp/gnus/gnus-spec.el (gnus-correct-substring):
* lisp/gnus/gnus-start.el (gnus-ask-server-for-new-groups, gnus-method-rank):
* lisp/gnus/gnus-sum.el (gnus-data-update-list)
(gnus-summary-number-of-articles-in-thread, gnus-build-sparse-threads)
(gnus-summary-prepare-threads, gnus-invisible-cut-children)
(gnus-summary-limit-children, gnus-expunge-thread)
(gnus-summary-refer-references, gnus-summary-update-mark)
(gnus-summary-hide-all-threads, gnus-summary-save-parts-1):
* lisp/gnus/gnus-topic.el (gnus-topic-articles-in-topic)
(gnus-topic-prepare-topic, gnus-topic-display-missing-topic)
(gnus-topic-update-topic-line):
* lisp/gnus/gnus-uu.el (gnus-uu-post-encoded):
* lisp/gnus/gnus-win.el (gnus-configure-frame):
* lisp/gnus/mail-source.el (mail-source-fetch-directory)
(mail-source-fetch-maildir, mail-source-fetch-imap):
* lisp/gnus/message.el (message-remove-header)
(message-remove-first-header, message-make-caesar-translation-table):
* lisp/gnus/mm-encode.el (mm-qp-or-base64):
* lisp/gnus/mml.el (mml-compute-boundary, mml-compute-boundary-1):
* lisp/gnus/nnatom.el (nnatom--read-links):
* lisp/gnus/nnbabyl.el (nnbabyl-retrieve-headers):
* lisp/gnus/nndoc.el (nndoc-oe-dbx-dissection, nndoc-dissect-buffer)
(nndoc-dissect-mime-parts-sub):
* lisp/gnus/nneething.el (nneething-retrieve-headers):
* lisp/gnus/nnheader.el (nnheader-generate-fake-message-id)
(nnheader-insert-head, nnheader-translate-file-chars):
* lisp/gnus/nnimap.el (nnimap-find-wanted-parts-1)
(nnimap-retrieve-group-data-early, nnimap-send-command):
* lisp/gnus/nnmail.el (nnmail-process-babyl-mail-format)
(nnmail-process-unix-mail-format, nnmail-process-mmdf-mail-format)
(nnmail-get-new-mail-1):
* lisp/gnus/nnmaildir.el (nnmaildir--scan):
* lisp/gnus/nnrss.el (nnrss-check-group):
* lisp/gnus/nnselect.el (nnselect-request-thread):
* lisp/gnus/nnspool.el (nnspool-retrieve-headers):
* lisp/gnus/nntp.el (nntp-retrieve-headers)
(nntp-finish-retrieve-group-infos, nntp-retrieve-groups)
(nntp-retrieve-articles, nntp-retrieve-headers-with-xover):
* lisp/gnus/nnvirtual.el (nnvirtual-create-mapping):
* lisp/gnus/nnweb.el (nnweb-google-parse-1, nnweb-google-create-mapping)
(nnweb-gmane-create-mapping):
* lisp/gnus/spam.el (spam-resolve-registrations-routine): Prefer incf to
cl-incf.
(cherry picked from commit
ae8522af41bb67bf417b94ed54146a43fe2150ec)
'gnus-agent-file-loading-local
#'gnus-agent-read-and-cache-local))
(when gnus-agent-article-local-times
- (cl-incf gnus-agent-article-local-times)))
+ (incf gnus-agent-article-local-times)))
gnus-agent-article-local))
(defun gnus-agent-read-and-cache-local (file)
article-number)))
(size (float (file-attribute-size
(file-attributes file-name)))))
- (cl-incf bytes-freed size)
- (cl-incf size-files-deleted size)
- (cl-incf files-deleted)
+ (incf bytes-freed size)
+ (incf size-files-deleted size)
+ (incf files-deleted)
(delete-file file-name))
(push "expired cached article" actions))
(setf (nth 1 entry) nil)
marker
(- marker position-offset)))
- (cl-incf nov-entries-deleted)
+ (incf nov-entries-deleted)
(let* ((from (line-beginning-position))
(to (progn (forward-line 1) (point)))
(freed (- to from)))
- (cl-incf bytes-freed freed)
- (cl-incf position-offset freed)
+ (incf bytes-freed freed)
+ (incf position-offset freed)
(delete-region from to)))
;; If considering all articles is set, I can only
(when (boundp 'gnus-agent-expire-stats)
(let ((stats gnus-agent-expire-stats))
- (cl-incf (nth 2 stats) bytes-freed)
- (cl-incf (nth 1 stats) files-deleted)
- (cl-incf (nth 0 stats) nov-entries-deleted)))
+ (incf (nth 2 stats) bytes-freed)
+ (incf (nth 1 stats) files-deleted)
+ (incf (nth 0 stats) nov-entries-deleted)))
(gnus-agent-update-files-total-fetched-for group (- size-files-deleted)))))))
(let ((sum 0.0)
file)
(while (setq file (pop delta))
- (cl-incf sum (float (or (file-attribute-size
- (file-attributes
- (nnheader-concat
- path
- (if (numberp file)
- (number-to-string file)
- file))))
- 0))))
+ (incf sum (float (or (file-attribute-size
+ (file-attributes
+ (nnheader-concat
+ path
+ (if (numberp file)
+ (number-to-string file)
+ file))))
+ 0))))
(setq delta sum))
(let ((sum (- (nth 2 entry)))
(info (directory-files-and-attributes
path nil "\\`-?[0-9]+\\'" t))
file)
(while (setq file (pop info))
- (cl-incf sum (float (or (file-attribute-size (cdr file)) 0))))
+ (incf sum (float (or (file-attribute-size (cdr file)) 0))))
(setq delta sum))))
(setq gnus-agent-need-update-total-fetched-for t)
- (cl-incf (nth 2 entry) delta))))))
+ (incf (nth 2 entry) delta))))))
(defun gnus-agent-update-view-total-fetched-for
(group agent-over &optional method path)
(if (looking-at (car list))
(setq list nil)
(setq list (cdr list))
- (cl-incf i)))
+ (incf i)))
i))
(defun article-hide-headers (&optional _arg _delete)
;; should check time-since-last-output, which
;; needs to be done in nntp.el.
(while (eq article gnus-async-current-prefetch-article)
- (cl-incf tries)
+ (incf tries)
(when (nntp-accept-process-output proc)
(setq tries 0))
(when (and (not nntp-have-messaged)
(while (setq file (pop files))
(setq attrs (file-attributes file))
(unless (file-attribute-type attrs)
- (cl-incf size (float (file-attribute-size attrs)))))))
+ (incf size (float (file-attribute-size attrs)))))))
(setq gnus-cache-need-update-total-fetched-for t)
- (cl-incf (nth 1 entry) (if subtract (- size) size))))))
+ (incf (nth 1 entry) (if subtract (- size) size))))))
(defun gnus-cache-update-overview-total-fetched-for (group file)
(when gnus-cache-total-fetched-hashtb
(expected (length old))
entry)
(while (car-safe old)
- (cl-incf count)
+ (incf count)
;; todo: use progress reporters.
(when (and (< 0 expected)
(= 0 (mod count 100)))
(defvar gnus-pick-line-number 1)
(defun gnus-pick-line-number ()
"Return the current line number."
- (cl-incf gnus-pick-line-number))
+ (incf gnus-pick-line-number))
(defun gnus-pick-start-reading (&optional catch-up)
"Start reading the picked articles.
(not (one-window-p)))
(let ((windows 0)
tot-win-height)
- (walk-windows (lambda (_window) (cl-incf windows)))
+ (walk-windows (lambda (_window) (incf windows)))
(setq tot-win-height
(- (frame-height)
(* window-min-height (1- windows))
(progn
(goto-char (point-min))
(end-of-line)
- (cl-incf gnus-tmp-indent))
+ (incf gnus-tmp-indent))
;; Recurse downwards in all children of this article.
(while thread
(gnus-generate-vertical-tree
;; Find the start position.
(while (and (< seek length)
(< wseek start))
- (cl-incf wseek (char-width (aref string seek)))
- (cl-incf seek))
+ (incf wseek (char-width (aref string seek)))
+ (incf seek))
(setq wstart seek)
;; Find the end position.
(while (and (<= seek length)
(or (not end)
(<= wseek end)))
- (cl-incf wseek (char-width (aref string seek)))
- (cl-incf seek))
+ (incf wseek (char-width (aref string seek)))
+ (incf seek))
(setq wend seek)
(substring string wstart (1- wend))))
(let ((do-sub (gnus-matches-options-n g-name)))
(cond
((eq do-sub 'subscribe)
- (cl-incf groups)
+ (incf groups)
(puthash g-name nil gnus-killed-hashtb) ;; group
(gnus-call-subscribe-functions
gnus-subscribe-options-newsgroup-method g-name))
((eq do-sub 'ignore)
nil)
(t
- (cl-incf groups)
+ (incf groups)
(puthash g-name nil gnus-killed-hashtb) ;; group
(if gnus-subscribe-hierarchical-interactive
(push g-name new-newsgroups)
(cl-dolist (smethod gnus-secondary-select-methods)
(when (equal method smethod)
(cl-return i))
- (cl-incf i))
+ (incf i))
i)))
;; Just say that all foreign groups have the same rank.
(t
"Add OFFSET to the POS of all data entries in DATA."
(setq gnus-newsgroup-data-reverse nil)
(while data
- (cl-incf (gnus-data-pos (car data)) offset)
+ (incf (gnus-data-pos (car data)) offset)
(setq data (cdr data))))
(defun gnus-summary-article-pseudo-p (article)
1)
(t 0))))
(when (and level (zerop level) gnus-tmp-new-adopts)
- (cl-incf number
+ (incf number
(apply #'+ (mapcar
#'gnus-summary-number-of-articles-in-thread
gnus-tmp-new-adopts))))
(setq end (1+ (point)))
(when (search-backward "<" nil t)
(setq new-child (buffer-substring (point) end))
- (push (list (cl-incf generation)
+ (push (list (incf generation)
child (setq child new-child)
subject date)
relations)))
(nthcdr 1 thread))
stack))
(push (if (nth 1 thread) 1 0) tree-stack)
- (cl-incf gnus-tmp-level)
+ (incf gnus-tmp-level)
(setq threads (if thread-end nil (cdar thread)))
(if gnus-summary-display-while-building
(if building-count
(let ((num 0))
(while threads
(when (memq (mail-header-number (caar threads)) gnus-newsgroup-limit)
- (cl-incf num))
+ (incf num))
(pop threads))
(< num 2)))
gnus-summary-expunge-below))
;; We increase the expunge-tally here, but that has
;; nothing to do with the limits, really.
- (cl-incf gnus-newsgroup-expunged-tally)
+ (incf gnus-newsgroup-expunged-tally)
;; We also mark as read here, if that's wanted.
(when (and gnus-summary-mark-below
(< score gnus-summary-mark-below))
(defun gnus-expunge-thread (thread)
"Mark all articles in THREAD as read."
(let* ((number (mail-header-number (car thread))))
- (cl-incf gnus-newsgroup-expunged-tally)
+ (incf gnus-newsgroup-expunged-tally)
;; We also mark as read here, if that's wanted.
(setq gnus-newsgroup-unreads
(delq number gnus-newsgroup-unreads))
(error "No References in the current article")
;; For each Message-ID in the References header...
(while (string-match "<[^>]*>" ref)
- (cl-incf n)
+ (incf n)
;; ... fetch that article.
(gnus-summary-refer-article
(prog1 (match-string 0 ref)
(re-search-backward "[\n\r]" (line-beginning-position) 'move-to-limit)
(when forward
(when (looking-at "\r")
- (cl-incf forward))
+ (incf forward))
(when (<= (+ forward (point)) (point-max))
;; Go to the right position on the line.
(goto-char (+ forward (point)))
(let ((end nil)
(count 0))
(while (not end)
- (cl-incf count)
+ (incf count)
(when (zerop (mod count 1000))
(message "Hiding all threads... %d" count))
(when (or (not predicate)
(cdr gnus-article-current)
gnus-summary-save-parts-counter))))
dir)))
- (cl-incf gnus-summary-save-parts-counter)
+ (incf gnus-summary-save-parts-counter)
(unless (file-exists-p file)
(mm-save-part-to-file handle file))))))
number)
(while entries
(when (numberp (setq number (car (pop entries))))
- (cl-incf total number)))
+ (incf total number)))
total))
(defun gnus-group-topic (group)
0
;; Insert any sub-topics.
(while topicl
- (cl-incf unread
+ (incf unread
(gnus-topic-prepare-topic
(pop topicl) (1+ level) list-level predicate
(not visiblep) lowest regexp)))
(car entry) (gnus-info-method info)))))
(when (and (listp entry)
(numberp (car entry)))
- (cl-incf unread (car entry)))
+ (incf unread (car entry)))
(when (listp entry)
(setq tick t))))
(goto-char beg)
(cdr gnus-group-list-mode) nil t))
entry)
(while children
- (cl-incf unread (gnus-topic-unread (caar (pop children)))))
+ (incf unread (gnus-topic-unread (caar (pop children)))))
(while (setq entry (pop entries))
(when (numberp (car entry))
- (cl-incf unread (car entry))))
+ (incf unread (car entry))))
(gnus-topic-insert-topic-line
topic t t (car (gnus-topic-find-topology topic)) nil unread all-groups)))
(if reads
(setq unread (- (gnus-group-topic-unread) reads))
(while children
- (cl-incf unread (gnus-topic-unread (caar (pop children)))))
+ (incf unread (gnus-topic-unread (caar (pop children)))))
(while (setq entry (pop entries))
(when (numberp (car entry))
- (cl-incf unread (car entry)))))
+ (incf unread (car entry)))))
(setq old-unread (gnus-group-topic-unread))
;; Insert the topic line.
(gnus-topic-insert-topic-line
(setq length (count-lines (point-min) (point-max)))
(setq parts (/ length gnus-uu-post-length))
(unless (< (% length gnus-uu-post-length) 4)
- (cl-incf parts)))
+ (incf parts)))
(when gnus-uu-post-separate-description
(forward-line -1))
(insert-buffer-substring uubuf beg end)
(insert beg-line "\n")
(setq beg end)
- (cl-incf i)
+ (incf i)
(goto-char (point-min))
(re-search-forward
(concat "^" (regexp-quote mail-header-separator) "$") nil t)
;; Select the frame in question and do more splits there.
(select-frame frame)
(setq fresult (or (gnus-configure-frame (elt subs i)) fresult))
- (cl-incf i))
+ (incf i))
;; Select the frame that has the selected buffer.
(when fresult
(select-frame (window-frame fresult)))))
((eq type 'vertical)
(setq s (max s window-min-height))))
(setcar (cdar comp-subs) s)
- (cl-incf total s)))
+ (incf total s)))
;; Take care of the "1.0" spec.
(if rest
(setcar (cdr rest) (- len total))
(when (and (file-regular-p file)
(funcall predicate file)
(mail-source-movemail file mail-source-crash-box))
- (cl-incf found (mail-source-callback callback file))
+ (incf found (mail-source-callback callback file))
(mail-source-run-script postscript `((?t . ,path)))
(mail-source-delete-crash-box)))
found)))
(insert "\001\001\001\001\n"))
(delete-file file)
nil))))
- (cl-incf found (mail-source-callback callback file))
+ (incf found (mail-source-callback callback file))
(mail-source-delete-crash-box)))))
found)))
(replace-match ">From "))
(goto-char (point-max))))
(nnheader-ms-strip-cr))
- (cl-incf found (mail-source-callback callback server))
+ (incf found (mail-source-callback callback server))
(mail-source-delete-crash-box)
(when (and remove fetchflag)
(setq remove (nreverse remove))
(looking-at "[!-9;-~]+:"))
(looking-at regexp))
(progn
- (cl-incf number)
+ (incf number)
(when first
(setq last t))
(delete-region
(save-excursion
(goto-char (point-min))
(while (re-search-forward regexp nil t)
- (cl-incf count)))
+ (incf count)))
(while (> count 1)
(message-remove-header header nil t)
(decf count))))
"Create a rot table with offset N."
(let ((i -1)
(table (make-string 256 0)))
- (while (< (cl-incf i) 256)
+ (while (< (incf i) 256)
(aset table i i))
(concat
(substring table 0 ?A)
(goto-char (point-min))
(skip-chars-forward "\x20-\x7f\r\n\t" limit)
(while (< (point) limit)
- (cl-incf n8bit)
+ (incf n8bit)
(forward-char 1)
(skip-chars-forward "\x20-\x7f\r\n\t" limit))
(if (or (< (* 6 n8bit) (- limit (point-min)))
(defun mml-compute-boundary (cont)
"Return a unique boundary that does not exist in CONT."
(let ((mml-boundary (funcall mml-boundary-function
- (cl-incf mml-multipart-number))))
+ (incf mml-multipart-number))))
(unless mml-inhibit-compute-boundary
;; This function tries again and again until it has found
;; a unique boundary.
(when (re-search-forward (concat "^--" (regexp-quote mml-boundary))
nil t)
(setq mml-boundary (funcall mml-boundary-function
- (cl-incf mml-multipart-number)))
+ (incf mml-multipart-number)))
(throw 'not-unique nil))))
((eq (car cont) 'multipart)
(mapc #'mml-compute-boundary-1 (cddr cont))))
(lambda (link)
(when-let ((l (car-safe link)))
(or
- (when-let (((eq l 'content))
- (src (dom-attr link 'src))
- (label (concat "Link"
- (and (< 1 (cl-incf alt))
- (format " %s" alt)))))
+ (when-let* (((eq l 'content))
+ (src (dom-attr link 'src))
+ (label (concat "Link"
+ (and (< 1 (incf alt))
+ (format " %s" alt)))))
`(((("text/plain") . ,(format "%s: %s\n" label src))
(("text/html") . ,(format "<a href=\"%s\">[%s]</a> "
src label)))))
- (when-let (((or (eq l 'author) (eq l 'contributor)))
- (name (nnatom--dom-line (dom-child-by-tag link 'name)))
- (name (if (string-blank-p name)
- (concat "Author"
- (and (< 1 (cl-incf aut))
- (format " %s" aut)))
- name))
- (uri (nnatom--dom-line (dom-child-by-tag link 'uri)))
- ((not (string-blank-p uri))))
+ (when-let* (((or (eq l 'author) (eq l 'contributor)))
+ (name (nnatom--dom-line (dom-child-by-tag link 'name)))
+ (name (if (string-blank-p name)
+ (concat "Author"
+ (and (< 1 (incf aut))
+ (format " %s" aut)))
+ name))
+ (uri (nnatom--dom-line (dom-child-by-tag link 'uri)))
+ ((not (string-blank-p uri))))
`(((("text/plain") . ,(format "%s: %s\n" name uri))
(("text/html") . ,(format "<a href=\"%s\">[%s]</a> "
uri name)))))
- (when-let (((eq l 'link))
- (attrs (dom-attributes link))
- (label (or (cdr (assq 'title attrs))
- (pcase (cdr (assq 'rel attrs))
- ("related"
- (concat "Related"
- (and (< 1 (cl-incf rel))
- (format " %s" rel))))
- ("self"
- (concat "More"
- (and (< 1 (cl-incf sel))
- (format " %s" sel))))
- ("enclosure"
- (concat "Enclosure"
- (and (< 1 (cl-incf enc))
- (format " %s" enc))))
- ("via"
- (concat "Source"
- (and (< 1 (cl-incf via))
- (format " %s" via))))
- (_ (if-let
- ((lang (cdr (assq 'hreflang link))))
- (format "Link (%s)" lang)
- (concat
- "Link"
- (and (< 1 (cl-incf alt))
- (format " %s" alt))))))))
- (link (cdr (assq 'href attrs))))
+ (when-let* (((eq l 'link))
+ (attrs (dom-attributes link))
+ (label (or (cdr (assq 'title attrs))
+ (pcase (cdr (assq 'rel attrs))
+ ("related"
+ (concat "Related"
+ (and (< 1 (incf rel))
+ (format " %s" rel))))
+ ("self"
+ (concat "More"
+ (and (< 1 (incf sel))
+ (format " %s" sel))))
+ ("enclosure"
+ (concat "Enclosure"
+ (and (< 1 (incf enc))
+ (format " %s" enc))))
+ ("via"
+ (concat "Source"
+ (and (< 1 (incf via))
+ (format " %s" via))))
+ (_ (if-let*
+ ((lang (cdr (assq 'hreflang link))))
+ (format "Link (%s)" lang)
+ (concat
+ "Link"
+ (and (< 1 (incf alt))
+ (format " %s" alt))))))))
+ (link (cdr (assq 'href attrs))))
`(((("text/plain") . ,(format "%s: %s\n" label link))
(("text/html") . ,(format "<a href=\"%s\">[%s]</a> "
link label))))))))
(insert ".\n"))
(and (numberp nnmail-large-newsgroup)
(> number nnmail-large-newsgroup)
- (zerop (% (cl-incf count) 20))
+ (zerop (% (incf count) 20))
(nnheader-message 5 "nnbabyl: Receiving headers... %d%%"
(floor (* count 100.0) number))))
(setq blk (nndoc-oe-dbx-decode-block)))
(while (and blk (> (car blk) 0) (or (zerop (nth 3 blk))
(> (nth 3 blk) p)))
- (push (list (cl-incf i) p nil nil nil 0) nndoc-dissection-alist)
+ (push (list (incf i) p nil nil nil 0) nndoc-dissection-alist)
(while (and (> (car blk) 0) (> (nth 3 blk) p))
(goto-char (1+ (nth 3 blk)))
(setq blk (nndoc-oe-dbx-decode-block)))
(and (re-search-backward nndoc-file-end nil t)
(beginning-of-line)))))
(setq body-end (point))
- (push (list (cl-incf i) head-begin head-end body-begin body-end
+ (push (list (incf i) head-begin head-end body-begin body-end
(count-lines body-begin body-end))
nndoc-dissection-alist)))))
(setq nndoc-dissection-alist (nreverse nndoc-dissection-alist))))
(replace-match line t t summary-insert)
(concat summary-insert line)))))
;; Generate dissection information for this entity.
- (push (list (cl-incf nndoc-mime-split-ordinal)
+ (push (list (incf nndoc-mime-split-ordinal)
head-begin head-end body-begin body-end
(count-lines body-begin body-end)
article-insert summary-insert)
part-begin part-end article-insert
(concat position
(and position ".")
- (format "%d" (cl-incf part-counter)))
+ (format "%d" (incf part-counter)))
message-id)))))))))
;;;###autoload
(nneething-insert-head file)
(insert ".\n"))
- (cl-incf count)
+ (incf count)
(and large
(zerop (% count 20))
(format "fake+none+%s+%d" gnus-newsgroup-name number)
(format "fake+none+%s+%s"
gnus-newsgroup-name
- (int-to-string (cl-incf nnheader-fake-message-id)))))
+ (int-to-string (incf nnheader-fake-message-id)))))
(defsubst nnheader-fake-message-id-p (id)
(save-match-data ; regular message-id's are <.*>
(while (and (eq nnheader-head-chop-length
(nth 1 (mm-insert-file-contents
file nil beg
- (cl-incf beg nnheader-head-chop-length))))
+ (incf beg nnheader-head-chop-length))))
;; CRLF or CR might be used for the line-break code.
(prog1 (not (re-search-forward "\n\r?\n\\|\r\r" nil t))
(goto-char (point-max)))
(when (setq trans (cdr (assq (aref leaf i)
nnheader-file-name-translation-alist)))
(aset leaf i trans))
- (cl-incf i))
+ (incf i))
(concat path leaf))))
(defun nnheader-report (backend &rest args)
(equal id "1")
(string-match nnimap-fetch-partial-articles type))
(push id parts))))
- (cl-incf num)))
+ (incf num)))
(nreverse parts)))
(deffoo nnimap-request-group (group &optional server dont-check info)
(if (and active uidvalidity unexist)
;; Fetch the last 100 flags.
(setq start (max 1 (- (cdr active) 100)))
- (cl-incf (nnimap-initial-resync nnimap-object))
+ (incf (nnimap-initial-resync nnimap-object))
(setq start 1))
(push (list (nnimap-send-command "%s %S" command
(nnimap-group-to-imap group))
(get-buffer-process (current-buffer))
(nnimap-log-command
(format "%d %s%s\n"
- (cl-incf nnimap-sequence)
+ (incf nnimap-sequence)
(apply #'format args)
(if (nnimap-newlinep nnimap-object)
""
(narrow-to-region start (point))
(goto-char (point-min))
(nnmail-check-duplication message-id func artnum-func)
- (cl-incf count)
+ (incf count)
(setq end (point-max))))
(goto-char end))
count))
(save-restriction
(narrow-to-region start (point))
(goto-char (point-min))
- (cl-incf count)
+ (incf count)
(nnmail-check-duplication message-id func artnum-func)
(setq end (point-max))))
(goto-char end)))
(save-restriction
(narrow-to-region start (point))
(goto-char (point-min))
- (cl-incf count)
+ (incf count)
(nnmail-check-duplication message-id func artnum-func junk-func)
(setq end (point-max))))
(goto-char end)
((error quit)
(message "Mail source %s failed: %s" source cond)
0)))
- (cl-incf total new)
- (cl-incf i)))
+ (incf total new)
+ (incf i)))
;; If we did indeed read any incoming spools, we save all info.
(if (zerop total)
(when mail-source-plugged
;; then look in marks directories
(not (file-exists-p (concat cdir prefix)))
(file-exists-p (concat ndir prefix)))
- (cl-incf num)))))
+ (incf num)))))
(setf (nnmaildir--grp-cache group) (make-vector num nil))
(let ((inhibit-quit t))
(puthash gname group groups))
(setq enclosure (list url name len type))))
(push
(list
- (cl-incf nnrss-group-max)
+ (incf nnrss-group-max)
(current-time)
url
(and subject (nnrss-mime-encode-string subject))
(push (1+ seq) old-arts)
(setq gnus-newsgroup-selection
(vconcat gnus-newsgroup-selection (vector article)))
- (cl-incf last)))
+ (incf last)))
(gnus-search-run-query
(list (cons 'search-query-spec query-spec)
(cons 'search-group-spec group-spec))))
(delete-region (point) (point-max)))
(and do-message
- (zerop (% (cl-incf count) 20))
+ (zerop (% (incf count) 20))
(nnheader-message 5 "nnspool: Receiving headers... %d%%"
(floor (* count 100.0) number))))
;; `articles' is either a list of article numbers
;; or a list of article IDs.
article))
- (cl-incf count)
+ (incf count)
;; Every 400 requests we have to read the stream in
;; order to avoid deadlocks.
(when (or (null articles) ;All requests have been sent.
;; Count replies.
(while (nntp-next-result-arrived-p)
(setq last-point (point))
- (cl-incf received))
+ (incf received))
(< received count))
;; If number of headers is greater than 100, give
;; informative messages.
"^[.]"
"^[0-9]")
nil t)
- (cl-incf received))
+ (incf received))
(setq last-point (point))
(< received count)))
(nntp-accept-response))
(throw 'done nil))
;; Send the command to the server.
(nntp-send-command nil command (pop groups))
- (cl-incf count)
+ (incf count)
;; Every 400 requests we have to read the stream in
;; order to avoid deadlocks.
(when (or (null groups) ;All requests have been sent.
(goto-char last-point)
;; Count replies.
(while (re-search-forward "^[0-9]" nil t)
- (cl-incf received))
+ (incf received))
(setq last-point (point))
(< received count)))
(nntp-accept-response))))
;; `articles' is either a list of article numbers
;; or a list of article IDs.
article))
- (cl-incf count)
+ (incf count)
;; Every 400 requests we have to read the stream in
;; order to avoid deadlocks.
(when (or (null articles) ;All requests have been sent.
(while (nntp-next-result-arrived-p)
(aset map received (cons (aref map received) (point)))
(setq last-point (point))
- (cl-incf received))
+ (incf received))
(< received count))
;; If number of headers is greater than 100, give
;; informative messages.
;; Count replies.
(while (re-search-forward "^\\([0-9][0-9][0-9]\\) .*\n"
nil t)
- (cl-incf received)
+ (incf received)
(setq status (match-string 1))
(if (string-match "^[45]" status)
(setq status 'error)
;; We need to convert the unreads to reads. We compress the
;; sequence as we go, otherwise it could be huge.
- (while (and (<= (cl-incf i) nnvirtual-mapping-len)
+ (while (and (<= (incf i) nnvirtual-mapping-len)
unreads)
(if (= i (car unreads))
(setq unreads (cdr unreads))
;; try to get a range.
(setq beg i)
- (while (and (<= (cl-incf i) nnvirtual-mapping-len)
+ (while (and (<= (incf i) nnvirtual-mapping-len)
(not (= i (car unreads)))))
(setq i (- i 1))
(if (= i beg)
(current-time-string)))
(setq From (match-string 4)))
(widen)
- (cl-incf i)
+ (incf i)
(unless (nnweb-get-hashtb url)
(push
(list
- (cl-incf (cdr active))
+ (incf (cdr active))
(make-full-mail-header
(cdr active) (if Newsgroups
(concat "(" Newsgroups ") " Subject)
(nconc nnweb-articles (nnweb-google-parse-1)))
;; Check if there are more articles to fetch
(goto-char (point-min))
- (cl-incf i 100)
+ (incf i 100)
(if (or (not (re-search-forward
"<a [^>]+href=\"\n?\\([^>\" \n\t]+\\)[^<]*<img[^>]+src=[^>]+next"
nil t))
(rfc2047-encode-string subject))
(unless (nnweb-get-hashtb (mail-header-xref header))
- (setf (mail-header-number header) (cl-incf (cdr active)))
+ (setf (mail-header-number header) (incf (cdr active)))
(push (list (mail-header-number header) header) map)
(nnweb-set-hashtb (cadar map) (car map))))))
(forward-line 1)))
;; eliminate duplicates
(dolist (article (copy-sequence ulist))
(when (memq article rlist)
- (cl-incf delcount)
+ (incf delcount)
(setq rlist (delq article rlist))
(setq ulist (delq article ulist))))
projects / emacs.git / commitdiff