git.chise.org Git - elisp/gnus.git-/blob - lisp/gnus-range.el

   1 ;;; gnus-range.el --- range and sequence functions for Gnus
   2
   3 ;; Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
   4
   5 ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
   6 ;; Keywords: news
   7
   8 ;; This file is part of GNU Emacs.
   9
  10 ;; GNU Emacs is free software; you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation; either version 2, or (at your option)
  13 ;; any later version.
  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
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  22 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23 ;; Boston, MA 02111-1307, USA.
  24
  25 ;;; Commentary:
  26
  27 ;;; Code:
  28
  29 (eval-when-compile (require 'cl))
  30
  31 ;;; List and range functions
  32
  33 (defsubst gnus-range-normalize (range)
  34   "Normalize RANGE.
  35 If RANGE is a single range, return (RANGE). Otherwise, return RANGE."
  36   (if (listp (cdr range)) (list range) range))
  37
  38 (defun gnus-last-element (list)
  39   "Return last element of LIST."
  40   (while (cdr list)
  41     (setq list (cdr list)))
  42   (car list))
  43
  44 (defun gnus-copy-sequence (list)
  45   "Do a complete, total copy of a list."
  46   (let (out)
  47     (while (consp list)
  48       (if (consp (car list))
  49           (push (gnus-copy-sequence (pop list)) out)
  50         (push (pop list) out)))
  51     (if list
  52         (nconc (nreverse out) list)
  53       (nreverse out))))
  54
  55 (defun gnus-set-difference (list1 list2)
  56   "Return a list of elements of LIST1 that do not appear in LIST2."
  57   (let ((list1 (copy-sequence list1)))
  58     (while list2
  59       (setq list1 (delq (car list2) list1))
  60       (setq list2 (cdr list2)))
  61     list1))
  62
  63 (defun gnus-sorted-complement (list1 list2)
  64   "Return a list of elements that are in LIST1 or LIST2 but not both.
  65 Both lists have to be sorted over <."
  66   (let (out)
  67     (if (or (null list1) (null list2))
  68         (or list1 list2)
  69       (while (and list1 list2)
  70         (cond ((= (car list1) (car list2))
  71                (setq list1 (cdr list1)
  72                      list2 (cdr list2)))
  73               ((< (car list1) (car list2))
  74                (setq out (cons (car list1) out))
  75                (setq list1 (cdr list1)))
  76               (t
  77                (setq out (cons (car list2) out))
  78                (setq list2 (cdr list2)))))
  79       (nconc (nreverse out) (or list1 list2)))))
  80
  81 (defun gnus-intersection (list1 list2)
  82   (let ((result nil))
  83     (while list2
  84       (when (memq (car list2) list1)
  85         (setq result (cons (car list2) result)))
  86       (setq list2 (cdr list2)))
  87     result))
  88
  89 (defun gnus-sorted-intersection (list1 list2)
  90   ;; LIST1 and LIST2 have to be sorted over <.
  91   (let (out)
  92     (while (and list1 list2)
  93       (cond ((= (car list1) (car list2))
  94              (setq out (cons (car list1) out)
  95                    list1 (cdr list1)
  96                    list2 (cdr list2)))
  97             ((< (car list1) (car list2))
  98              (setq list1 (cdr list1)))
  99             (t
 100              (setq list2 (cdr list2)))))
 101     (nreverse out)))
 102
 103 (defun gnus-set-sorted-intersection (list1 list2)
 104   ;; LIST1 and LIST2 have to be sorted over <.
 105   ;; This function modifies LIST1.
 106   (let* ((top (cons nil list1))
 107          (prev top))
 108     (while (and list1 list2)
 109       (cond ((= (car list1) (car list2))
 110              (setq prev list1
 111                    list1 (cdr list1)
 112                    list2 (cdr list2)))
 113             ((< (car list1) (car list2))
 114              (setcdr prev (cdr list1))
 115              (setq list1 (cdr list1)))
 116             (t
 117              (setq list2 (cdr list2)))))
 118     (setcdr prev nil)
 119     (cdr top)))
 120
 121 (defun gnus-compress-sequence (numbers &optional always-list)
 122   "Convert list of numbers to a list of ranges or a single range.
 123 If ALWAYS-LIST is non-nil, this function will always release a list of
 124 ranges."
 125   (let* ((first (car numbers))
 126          (last (car numbers))
 127          result)
 128     (if (null numbers)
 129         nil
 130       (if (not (listp (cdr numbers)))
 131           numbers
 132         (while numbers
 133           (cond ((= last (car numbers)) nil) ;Omit duplicated number
 134                 ((= (1+ last) (car numbers)) ;Still in sequence
 135                  (setq last (car numbers)))
 136                 (t                      ;End of one sequence
 137                  (setq result
 138                        (cons (if (= first last) first
 139                                (cons first last))
 140                              result))
 141                  (setq first (car numbers))
 142                  (setq last  (car numbers))))
 143           (setq numbers (cdr numbers)))
 144         (if (and (not always-list) (null result))
 145             (if (= first last) (list first) (cons first last))
 146           (nreverse (cons (if (= first last) first (cons first last))
 147                           result)))))))
 148
 149 (defalias 'gnus-uncompress-sequence 'gnus-uncompress-range)
 150 (defun gnus-uncompress-range (ranges)
 151   "Expand a list of ranges into a list of numbers.
 152 RANGES is either a single range on the form `(num . num)' or a list of
 153 these ranges."
 154   (let (first last result)
 155     (cond
 156      ((null ranges)
 157       nil)
 158      ((not (listp (cdr ranges)))
 159       (setq first (car ranges))
 160       (setq last (cdr ranges))
 161       (while (<= first last)
 162         (setq result (cons first result))
 163         (setq first (1+ first)))
 164       (nreverse result))
 165      (t
 166       (while ranges
 167         (if (atom (car ranges))
 168             (when (numberp (car ranges))
 169               (setq result (cons (car ranges) result)))
 170           (setq first (caar ranges))
 171           (setq last  (cdar ranges))
 172           (while (<= first last)
 173             (setq result (cons first result))
 174             (setq first (1+ first))))
 175         (setq ranges (cdr ranges)))
 176       (nreverse result)))))
 177
 178 (defun gnus-add-to-range (ranges list)
 179   "Return a list of ranges that has all articles from both RANGES and LIST.
 180 Note: LIST has to be sorted over `<'."
 181   (if (not ranges)
 182       (gnus-compress-sequence list t)
 183     (setq list (copy-sequence list))
 184     (unless (listp (cdr ranges))
 185       (setq ranges (list ranges)))
 186     (let ((out ranges)
 187           ilist lowest highest temp)
 188       (while (and ranges list)
 189         (setq ilist list)
 190         (setq lowest (or (and (atom (car ranges)) (car ranges))
 191                          (caar ranges)))
 192         (while (and list (cdr list) (< (cadr list) lowest))
 193           (setq list (cdr list)))
 194         (when (< (car ilist) lowest)
 195           (setq temp list)
 196           (setq list (cdr list))
 197           (setcdr temp nil)
 198           (setq out (nconc (gnus-compress-sequence ilist t) out)))
 199         (setq highest (or (and (atom (car ranges)) (car ranges))
 200                           (cdar ranges)))
 201         (while (and list (<= (car list) highest))
 202           (setq list (cdr list)))
 203         (setq ranges (cdr ranges)))
 204       (when list
 205         (setq out (nconc (gnus-compress-sequence list t) out)))
 206       (setq out (sort out (lambda (r1 r2)
 207                             (< (or (and (atom r1) r1) (car r1))
 208                                (or (and (atom r2) r2) (car r2))))))
 209       (setq ranges out)
 210       (while ranges
 211         (if (atom (car ranges))
 212             (when (cdr ranges)
 213               (if (atom (cadr ranges))
 214                   (when (= (1+ (car ranges)) (cadr ranges))
 215                     (setcar ranges (cons (car ranges)
 216                                          (cadr ranges)))
 217                     (setcdr ranges (cddr ranges)))
 218                 (when (= (1+ (car ranges)) (caadr ranges))
 219                   (setcar (cadr ranges) (car ranges))
 220                   (setcar ranges (cadr ranges))
 221                   (setcdr ranges (cddr ranges)))))
 222           (when (cdr ranges)
 223             (if (atom (cadr ranges))
 224                 (when (= (1+ (cdar ranges)) (cadr ranges))
 225                   (setcdr (car ranges) (cadr ranges))
 226                   (setcdr ranges (cddr ranges)))
 227               (when (= (1+ (cdar ranges)) (caadr ranges))
 228                 (setcdr (car ranges) (cdadr ranges))
 229                 (setcdr ranges (cddr ranges))))))
 230         (setq ranges (cdr ranges)))
 231       out)))
 232
 233 (defun gnus-remove-from-range (range1 range2)
 234   "Return a range that has all articles from RANGE2 removed from RANGE1.
 235 The returned range is always a list.  RANGE2 can also be a unsorted
 236 list of articles.  RANGE1 is modified by side effects, RANGE2 is not
 237 modified."
 238   (if (or (null range1) (null range2))
 239       range1
 240     (let (out r1 r2 r1_min r1_max r2_min r2_max
 241               (range2 (gnus-copy-sequence range2)))
 242       (setq range1 (if (listp (cdr range1)) range1 (list range1))
 243             range2 (sort (if (listp (cdr range2)) range2 (list range2))
 244                          (lambda (e1 e2)
 245                            (< (if (consp e1) (car e1) e1)
 246                               (if (consp e2) (car e2) e2))))
 247             r1 (car range1)
 248             r2 (car range2)
 249             r1_min (if (consp r1) (car r1) r1)
 250             r1_max (if (consp r1) (cdr r1) r1)
 251             r2_min (if (consp r2) (car r2) r2)
 252             r2_max (if (consp r2) (cdr r2) r2))
 253       (while (and range1 range2)
 254         (cond ((< r2_max r1_min)        ; r2 < r1
 255                (pop range2)
 256                (setq r2 (car range2)
 257                      r2_min (if (consp r2) (car r2) r2)
 258                      r2_max (if (consp r2) (cdr r2) r2)))
 259               ((and (<= r2_min r1_min) (<= r1_max r2_max)) ; r2 overlap r1
 260                (pop range1)
 261                (setq r1 (car range1)
 262                      r1_min (if (consp r1) (car r1) r1)
 263                      r1_max (if (consp r1) (cdr r1) r1)))
 264               ((and (<= r2_min r1_min) (<= r2_max r1_max)) ; r2 overlap min r1
 265                (pop range2)
 266                (setq r1_min (1+ r2_max)
 267                      r2 (car range2)
 268                      r2_min (if (consp r2) (car r2) r2)
 269                      r2_max (if (consp r2) (cdr r2) r2)))
 270               ((and (<= r1_min r2_min) (<= r2_max r1_max)) ; r2 contained in r1
 271                (if (eq r1_min (1- r2_min))
 272                    (push r1_min out)
 273                  (push (cons r1_min (1- r2_min)) out))
 274                (pop range2)
 275                (if (< r2_max r1_max)    ; finished with r1?
 276                    (setq r1_min (1+ r2_max))
 277                  (pop range1)
 278                  (setq r1 (car range1)
 279                        r1_min (if (consp r1) (car r1) r1)
 280                        r1_max (if (consp r1) (cdr r1) r1)))
 281                (setq r2 (car range2)
 282                      r2_min (if (consp r2) (car r2) r2)
 283                      r2_max (if (consp r2) (cdr r2) r2)))
 284               ((and (<= r2_min r1_max) (<= r1_max r2_max)) ; r2 overlap max r1
 285                (if (eq r1_min (1- r2_min))
 286                    (push r1_min out)
 287                  (push (cons r1_min (1- r2_min)) out))
 288                (pop range1)
 289                (setq r1 (car range1)
 290                      r1_min (if (consp r1) (car r1) r1)
 291                      r1_max (if (consp r1) (cdr r1) r1)))
 292               ((< r1_max r2_min)        ; r2 > r1
 293                (pop range1)
 294                (if (eq r1_min r1_max)
 295                    (push r1_min out)
 296                  (push (cons r1_min r1_max) out))
 297                (setq r1 (car range1)
 298                      r1_min (if (consp r1) (car r1) r1)
 299                      r1_max (if (consp r1) (cdr r1) r1)))))
 300       (when r1
 301         (if (eq r1_min r1_max)
 302             (push r1_min out)
 303           (push (cons r1_min r1_max) out))
 304         (pop range1))
 305       (while range1
 306         (push (pop range1) out))
 307       (nreverse out))))
 308
 309 (defun gnus-member-of-range (number ranges)
 310   (if (not (listp (cdr ranges)))
 311       (and (>= number (car ranges))
 312            (<= number (cdr ranges)))
 313     (let ((not-stop t))
 314       (while (and ranges
 315                   (if (numberp (car ranges))
 316                       (>= number (car ranges))
 317                     (>= number (caar ranges)))
 318                   not-stop)
 319         (when (if (numberp (car ranges))
 320                   (= number (car ranges))
 321                 (and (>= number (caar ranges))
 322                      (<= number (cdar ranges))))
 323           (setq not-stop nil))
 324         (setq ranges (cdr ranges)))
 325       (not not-stop))))
 326
 327 (defun gnus-range-length (range)
 328   "Return the length RANGE would have if uncompressed."
 329   (length (gnus-uncompress-range range)))
 330
 331 (defun gnus-sublist-p (list sublist)
 332   "Test whether all elements in SUBLIST are members of LIST."
 333   (let ((sublistp t))
 334     (while sublist
 335       (unless (memq (pop sublist) list)
 336         (setq sublistp nil
 337               sublist nil)))
 338     sublistp))
 339
 340 (defun gnus-range-add (range1 range2)
 341   "Add RANGE2 to RANGE1 (nondestructively)."
 342   (unless (listp (cdr range1))
 343     (setq range1 (list range1)))
 344   (unless (listp (cdr range2))
 345     (setq range2 (list range2)))
 346   (let ((item1 (pop range1))
 347         (item2 (pop range2))
 348         range item selector)
 349     (while (or item1 item2)
 350       (setq selector
 351             (cond
 352              ((null item1) nil)
 353              ((null item2) t)
 354              ((and (numberp item1) (numberp item2)) (< item1 item2))
 355              ((numberp item1) (< item1 (car item2)))
 356              ((numberp item2) (< (car item1) item2))
 357              (t (< (car item1) (car item2)))))
 358       (setq item
 359             (or
 360              (let ((tmp1 item) (tmp2 (if selector item1 item2)))
 361                (cond
 362                 ((null tmp1) tmp2)
 363                 ((null tmp2) tmp1)
 364                 ((and (numberp tmp1) (numberp tmp2))
 365                  (cond
 366                   ((eq tmp1 tmp2) tmp1)
 367                   ((eq (1+ tmp1) tmp2) (cons tmp1 tmp2))
 368                   ((eq (1+ tmp2) tmp1) (cons tmp2 tmp1))
 369                   (t nil)))
 370                 ((numberp tmp1)
 371                  (cond
 372                   ((and (>= tmp1 (car tmp2)) (<= tmp1 (cdr tmp2))) tmp2)
 373                   ((eq (1+ tmp1) (car tmp2)) (cons tmp1 (cdr tmp2)))
 374                   ((eq (1- tmp1) (cdr tmp2)) (cons (car tmp2) tmp1))
 375                   (t nil)))
 376                 ((numberp tmp2)
 377                  (cond
 378                   ((and (>= tmp2 (car tmp1)) (<= tmp2 (cdr tmp1))) tmp1)
 379                   ((eq (1+ tmp2) (car tmp1)) (cons tmp2 (cdr tmp1)))
 380                   ((eq (1- tmp2) (cdr tmp1)) (cons (car tmp1) tmp2))
 381                   (t nil)))
 382                 ((< (1+ (cdr tmp1)) (car tmp2)) nil)
 383                 ((< (1+ (cdr tmp2)) (car tmp1)) nil)
 384                 (t (cons (min (car tmp1) (car tmp2))
 385                          (max (cdr tmp1) (cdr tmp2))))))
 386              (progn
 387                (if item (push item range))
 388                (if selector item1 item2))))
 389       (if selector
 390           (setq item1 (pop range1))
 391         (setq item2 (pop range2))))
 392     (if item (push item range))
 393     (reverse range)))
 394
 395 (provide 'gnus-range)
 396
 397 ;;; gnus-range.el ends here