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, 2001, 2002
   4 ;;        Free Software Foundation, Inc.
   5
   6 ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
   7 ;; Keywords: news
   8
   9 ;; This file is part of GNU Emacs.
  10
  11 ;; GNU Emacs is free software; you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation; either version 2, or (at your option)
  14 ;; any later version.
  15
  16 ;; GNU Emacs is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  23 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  24 ;; Boston, MA 02111-1307, USA.
  25
  26 ;;; Commentary:
  27
  28 ;;; Code:
  29
  30 (eval-when-compile (require 'cl))
  31
  32 ;;; List and range functions
  33
  34 (defsubst gnus-range-normalize (range)
  35   "Normalize RANGE.
  36 If RANGE is a single range, return (RANGE). Otherwise, return RANGE."
  37   (if (listp (cdr-safe range)) range (list range)))
  38
  39 (defun gnus-last-element (list)
  40   "Return last element of LIST."
  41   (while (cdr list)
  42     (setq list (cdr list)))
  43   (car list))
  44
  45 (defun gnus-copy-sequence (list)
  46   "Do a complete, total copy of a list."
  47   (let (out)
  48     (while (consp list)
  49       (if (consp (car list))
  50           (push (gnus-copy-sequence (pop list)) out)
  51         (push (pop list) out)))
  52     (if list
  53         (nconc (nreverse out) list)
  54       (nreverse out))))
  55
  56 (defun gnus-set-difference (list1 list2)
  57   "Return a list of elements of LIST1 that do not appear in LIST2."
  58   (let ((list1 (copy-sequence list1)))
  59     (while list2
  60       (setq list1 (delq (car list2) list1))
  61       (setq list2 (cdr list2)))
  62     list1))
  63
  64 (defun gnus-range-difference (range1 range2)
  65   "Return the range of elements in RANGE1 that do not appear in RANGE2.
  66 Both ranges must be in ascending order."
  67   (setq range1 (gnus-range-normalize range1))
  68   (setq range2 (gnus-range-normalize range2))
  69   (let* ((new-range (cons nil (copy-sequence range1)))
  70          (r new-range)
  71          (safe t))
  72     (while (cdr r)
  73       (let* ((r1 (cadr r))
  74              (r2 (car range2))
  75              (min1 (if (numberp r1) r1 (car r1)))
  76              (max1 (if (numberp r1) r1 (cdr r1)))
  77              (min2 (if (numberp r2) r2 (car r2)))
  78              (max2 (if (numberp r2) r2 (cdr r2))))
  79
  80         (cond ((> min1 max1)
  81                ;; Invalid range: may result from overlap condition (below)
  82                ;; remove Invalid range
  83                (setcdr r (cddr r)))
  84               ((and (= min1 max1)
  85                     (listp r1))
  86                ;; Inefficient representation: may result from overlap condition (below)
  87                (setcar (cdr r) min1))
  88               ((not min2)
  89                ;; All done with range2
  90                (setq r nil))
  91               ((< max1 min2)
  92                ;; No overlap: range1 preceeds range2
  93                (pop r))
  94               ((< max2 min1)
  95                ;; No overlap: range2 preceeds range1
  96                (pop range2))
  97               ((and (<= min2 min1) (<= max1 max2))
  98                ;; Complete overlap: range1 removed
  99                (setcdr r (cddr r)))
 100               (t
 101                (setcdr r (nconc (list (cons min1 (1- min2)) (cons (1+ max2) max1)) (cddr r)))))))
 102     (cdr new-range)))
 103
 104
 105
 106 ;;;###autoload
 107 (defun gnus-sorted-difference (list1 list2)
 108   "Return a list of elements of LIST1 that do not appear in LIST2.
 109 Both lists have to be sorted over <.
 110 The tail of LIST1 is not copied."
 111   (let (out)
 112     (while (and list1 list2)
 113       (cond ((= (car list1) (car list2))
 114              (setq list1 (cdr list1)
 115                    list2 (cdr list2)))
 116             ((< (car list1) (car list2))
 117              (setq out (cons (car list1) out))
 118              (setq list1 (cdr list1)))
 119             (t
 120              (setq list2 (cdr list2)))))
 121     (nconc (nreverse out) list1)))
 122
 123 ;;;###autoload
 124 (defun gnus-sorted-ndifference (list1 list2)
 125   "Return a list of elements of LIST1 that do not appear in LIST2.
 126 Both lists have to be sorted over <.
 127 LIST1 is modified."
 128   (let* ((top (cons nil list1))
 129          (prev top))
 130     (while (and list1 list2)
 131       (cond ((= (car list1) (car list2))
 132              (setcdr prev (cdr list1))
 133              (setq list1 (cdr list1)
 134                    list2 (cdr list2)))
 135             ((< (car list1) (car list2))
 136              (setq prev list1
 137                    list1 (cdr list1)))
 138             (t
 139              (setq list2 (cdr list2)))))
 140     (cdr top)))
 141
 142 ;;;###autoload
 143 (defun gnus-sorted-complement (list1 list2)
 144   "Return a list of elements that are in LIST1 or LIST2 but not both.
 145 Both lists have to be sorted over <."
 146   (let (out)
 147     (if (or (null list1) (null list2))
 148         (or list1 list2)
 149       (while (and list1 list2)
 150         (cond ((= (car list1) (car list2))
 151                (setq list1 (cdr list1)
 152                      list2 (cdr list2)))
 153               ((< (car list1) (car list2))
 154                (setq out (cons (car list1) out))
 155                (setq list1 (cdr list1)))
 156               (t
 157                (setq out (cons (car list2) out))
 158                (setq list2 (cdr list2)))))
 159       (nconc (nreverse out) (or list1 list2)))))
 160
 161 ;;;###autoload
 162 (defun gnus-intersection (list1 list2)
 163   (let ((result nil))
 164     (while list2
 165       (when (memq (car list2) list1)
 166         (setq result (cons (car list2) result)))
 167       (setq list2 (cdr list2)))
 168     result))
 169
 170 ;;;###autoload
 171 (defun gnus-sorted-intersection (list1 list2)
 172   "Return intersection of LIST1 and LIST2.
 173 LIST1 and LIST2 have to be sorted over <."
 174   (let (out)
 175     (while (and list1 list2)
 176       (cond ((= (car list1) (car list2))
 177              (setq out (cons (car list1) out)
 178                    list1 (cdr list1)
 179                    list2 (cdr list2)))
 180             ((< (car list1) (car list2))
 181              (setq list1 (cdr list1)))
 182             (t
 183              (setq list2 (cdr list2)))))
 184     (nreverse out)))
 185
 186 ;;;###autoload
 187 (defalias 'gnus-set-sorted-intersection 'gnus-sorted-nintersection)
 188
 189 ;;;###autoload
 190 (defun gnus-sorted-nintersection (list1 list2)
 191   "Return intersection of LIST1 and LIST2 by modifying cdr pointers of LIST1.
 192 LIST1 and LIST2 have to be sorted over <."
 193   (let* ((top (cons nil list1))
 194          (prev top))
 195     (while (and list1 list2)
 196       (cond ((= (car list1) (car list2))
 197              (setq prev list1
 198                    list1 (cdr list1)
 199                    list2 (cdr list2)))
 200             ((< (car list1) (car list2))
 201              (setcdr prev (cdr list1))
 202              (setq list1 (cdr list1)))
 203             (t
 204              (setq list2 (cdr list2)))))
 205     (setcdr prev nil)
 206     (cdr top)))
 207
 208 ;;;###autoload
 209 (defun gnus-sorted-union (list1 list2)
 210   "Return union of LIST1 and LIST2.
 211 LIST1 and LIST2 have to be sorted over <."
 212   (let (out)
 213     (while (and list1 list2)
 214       (cond ((= (car list1) (car list2))
 215              (setq out (cons (car list1) out)
 216                    list1 (cdr list1)
 217                    list2 (cdr list2)))
 218             ((< (car list1) (car list2))
 219              (setq out (cons (car list1) out)
 220                    list1 (cdr list1)))
 221             (t
 222              (setq out (cons (car list2) out)
 223                    list2 (cdr list2)))))
 224     (while list1
 225       (setq out (cons (car list1) out)
 226             list1 (cdr list1)))
 227     (while list2
 228       (setq out (cons (car list2) out)
 229             list2 (cdr list2)))
 230     (nreverse out)))
 231
 232 ;;;###autoload
 233 (defun gnus-sorted-nunion (list1 list2)
 234   "Return union of LIST1 and LIST2 by modifying cdr pointers of LIST1.
 235 LIST1 and LIST2 have to be sorted over <."
 236   (let* ((top (cons nil list1))
 237          (prev top))
 238     (while (and list1 list2)
 239       (cond ((= (car list1) (car list2))
 240              (setq prev list1
 241                    list1 (cdr list1)
 242                    list2 (cdr list2)))
 243             ((< (car list1) (car list2))
 244              (setq prev list1
 245                    list1 (cdr list1)))
 246             (t
 247              (setcdr prev (list (car list2)))
 248              (setq prev (cdr prev)
 249                    list2 (cdr list2))
 250              (setcdr prev list1))))
 251     (while list2
 252       (setcdr prev (list (car list2)))
 253       (setq prev (cdr prev)
 254             list2 (cdr list2)))
 255     (cdr top)))
 256
 257 (defun gnus-compress-sequence (numbers &optional always-list)
 258   "Convert list of numbers to a list of ranges or a single range.
 259 If ALWAYS-LIST is non-nil, this function will always release a list of
 260 ranges."
 261   (let* ((first (car numbers))
 262          (last (car numbers))
 263          result)
 264     (if (null numbers)
 265         nil
 266       (if (not (listp (cdr numbers)))
 267           numbers
 268         (while numbers
 269           (cond ((= last (car numbers)) nil) ;Omit duplicated number
 270                 ((= (1+ last) (car numbers)) ;Still in sequence
 271                  (setq last (car numbers)))
 272                 (t                      ;End of one sequence
 273                  (setq result
 274                        (cons (if (= first last) first
 275                                (cons first last))
 276                              result))
 277                  (setq first (car numbers))
 278                  (setq last  (car numbers))))
 279           (setq numbers (cdr numbers)))
 280         (if (and (not always-list) (null result))
 281             (if (= first last) (list first) (cons first last))
 282           (nreverse (cons (if (= first last) first (cons first last))
 283                           result)))))))
 284
 285 (defalias 'gnus-uncompress-sequence 'gnus-uncompress-range)
 286 (defun gnus-uncompress-range (ranges)
 287   "Expand a list of ranges into a list of numbers.
 288 RANGES is either a single range on the form `(num . num)' or a list of
 289 these ranges."
 290   (let (first last result)
 291     (cond
 292      ((null ranges)
 293       nil)
 294      ((not (listp (cdr ranges)))
 295       (setq first (car ranges))
 296       (setq last (cdr ranges))
 297       (while (<= first last)
 298         (setq result (cons first result))
 299         (setq first (1+ first)))
 300       (nreverse result))
 301      (t
 302       (while ranges
 303         (if (atom (car ranges))
 304             (when (numberp (car ranges))
 305               (setq result (cons (car ranges) result)))
 306           (setq first (caar ranges))
 307           (setq last  (cdar ranges))
 308           (while (<= first last)
 309             (setq result (cons first result))
 310             (setq first (1+ first))))
 311         (setq ranges (cdr ranges)))
 312       (nreverse result)))))
 313
 314 (defun gnus-add-to-range (ranges list)
 315   "Return a list of ranges that has all articles from both RANGES and LIST.
 316 Note: LIST has to be sorted over `<'."
 317   (if (not ranges)
 318       (gnus-compress-sequence list t)
 319     (setq list (copy-sequence list))
 320     (unless (listp (cdr ranges))
 321       (setq ranges (list ranges)))
 322     (let ((out ranges)
 323           ilist lowest highest temp)
 324       (while (and ranges list)
 325         (setq ilist list)
 326         (setq lowest (or (and (atom (car ranges)) (car ranges))
 327                          (caar ranges)))
 328         (while (and list (cdr list) (< (cadr list) lowest))
 329           (setq list (cdr list)))
 330         (when (< (car ilist) lowest)
 331           (setq temp list)
 332           (setq list (cdr list))
 333           (setcdr temp nil)
 334           (setq out (nconc (gnus-compress-sequence ilist t) out)))
 335         (setq highest (or (and (atom (car ranges)) (car ranges))
 336                           (cdar ranges)))
 337         (while (and list (<= (car list) highest))
 338           (setq list (cdr list)))
 339         (setq ranges (cdr ranges)))
 340       (when list
 341         (setq out (nconc (gnus-compress-sequence list t) out)))
 342       (setq out (sort out (lambda (r1 r2)
 343                             (< (or (and (atom r1) r1) (car r1))
 344                                (or (and (atom r2) r2) (car r2))))))
 345       (setq ranges out)
 346       (while ranges
 347         (if (atom (car ranges))
 348             (when (cdr ranges)
 349               (if (atom (cadr ranges))
 350                   (when (= (1+ (car ranges)) (cadr ranges))
 351                     (setcar ranges (cons (car ranges)
 352                                          (cadr ranges)))
 353                     (setcdr ranges (cddr ranges)))
 354                 (when (= (1+ (car ranges)) (caadr ranges))
 355                   (setcar (cadr ranges) (car ranges))
 356                   (setcar ranges (cadr ranges))
 357                   (setcdr ranges (cddr ranges)))))
 358           (when (cdr ranges)
 359             (if (atom (cadr ranges))
 360                 (when (= (1+ (cdar ranges)) (cadr ranges))
 361                   (setcdr (car ranges) (cadr ranges))
 362                   (setcdr ranges (cddr ranges)))
 363               (when (= (1+ (cdar ranges)) (caadr ranges))
 364                 (setcdr (car ranges) (cdadr ranges))
 365                 (setcdr ranges (cddr ranges))))))
 366         (setq ranges (cdr ranges)))
 367       out)))
 368
 369 (defun gnus-remove-from-range (range1 range2)
 370   "Return a range that has all articles from RANGE2 removed from RANGE1.
 371 The returned range is always a list.  RANGE2 can also be a unsorted
 372 list of articles.  RANGE1 is modified by side effects, RANGE2 is not
 373 modified."
 374   (if (or (null range1) (null range2))
 375       range1
 376     (let (out r1 r2 r1_min r1_max r2_min r2_max
 377               (range2 (gnus-copy-sequence range2)))
 378       (setq range1 (if (listp (cdr range1)) range1 (list range1))
 379             range2 (sort (if (listp (cdr range2)) range2 (list range2))
 380                          (lambda (e1 e2)
 381                            (< (if (consp e1) (car e1) e1)
 382                               (if (consp e2) (car e2) e2))))
 383             r1 (car range1)
 384             r2 (car range2)
 385             r1_min (if (consp r1) (car r1) r1)
 386             r1_max (if (consp r1) (cdr r1) r1)
 387             r2_min (if (consp r2) (car r2) r2)
 388             r2_max (if (consp r2) (cdr r2) r2))
 389       (while (and range1 range2)
 390         (cond ((< r2_max r1_min)        ; r2 < r1
 391                (pop range2)
 392                (setq r2 (car range2)
 393                      r2_min (if (consp r2) (car r2) r2)
 394                      r2_max (if (consp r2) (cdr r2) r2)))
 395               ((and (<= r2_min r1_min) (<= r1_max r2_max)) ; r2 overlap r1
 396                (pop range1)
 397                (setq r1 (car range1)
 398                      r1_min (if (consp r1) (car r1) r1)
 399                      r1_max (if (consp r1) (cdr r1) r1)))
 400               ((and (<= r2_min r1_min) (<= r2_max r1_max)) ; r2 overlap min r1
 401                (pop range2)
 402                (setq r1_min (1+ r2_max)
 403                      r2 (car range2)
 404                      r2_min (if (consp r2) (car r2) r2)
 405                      r2_max (if (consp r2) (cdr r2) r2)))
 406               ((and (<= r1_min r2_min) (<= r2_max r1_max)) ; r2 contained in r1
 407                (if (eq r1_min (1- r2_min))
 408                    (push r1_min out)
 409                  (push (cons r1_min (1- r2_min)) out))
 410                (pop range2)
 411                (if (< r2_max r1_max)    ; finished with r1?
 412                    (setq r1_min (1+ r2_max))
 413                  (pop range1)
 414                  (setq r1 (car range1)
 415                        r1_min (if (consp r1) (car r1) r1)
 416                        r1_max (if (consp r1) (cdr r1) r1)))
 417                (setq r2 (car range2)
 418                      r2_min (if (consp r2) (car r2) r2)
 419                      r2_max (if (consp r2) (cdr r2) r2)))
 420               ((and (<= r2_min r1_max) (<= r1_max r2_max)) ; r2 overlap max r1
 421                (if (eq r1_min (1- r2_min))
 422                    (push r1_min out)
 423                  (push (cons r1_min (1- r2_min)) out))
 424                (pop range1)
 425                (setq r1 (car range1)
 426                      r1_min (if (consp r1) (car r1) r1)
 427                      r1_max (if (consp r1) (cdr r1) r1)))
 428               ((< r1_max r2_min)        ; r2 > r1
 429                (pop range1)
 430                (if (eq r1_min r1_max)
 431                    (push r1_min out)
 432                  (push (cons r1_min r1_max) out))
 433                (setq r1 (car range1)
 434                      r1_min (if (consp r1) (car r1) r1)
 435                      r1_max (if (consp r1) (cdr r1) r1)))))
 436       (when r1
 437         (if (eq r1_min r1_max)
 438             (push r1_min out)
 439           (push (cons r1_min r1_max) out))
 440         (pop range1))
 441       (while range1
 442         (push (pop range1) out))
 443       (nreverse out))))
 444
 445 (defun gnus-member-of-range (number ranges)
 446   (if (not (listp (cdr ranges)))
 447       (and (>= number (car ranges))
 448            (<= number (cdr ranges)))
 449     (let ((not-stop t))
 450       (while (and ranges
 451                   (if (numberp (car ranges))
 452                       (>= number (car ranges))
 453                     (>= number (caar ranges)))
 454                   not-stop)
 455         (when (if (numberp (car ranges))
 456                   (= number (car ranges))
 457                 (and (>= number (caar ranges))
 458                      (<= number (cdar ranges))))
 459           (setq not-stop nil))
 460         (setq ranges (cdr ranges)))
 461       (not not-stop))))
 462
 463 (defun gnus-list-range-intersection (list ranges)
 464   "Return a list of numbers in LIST that are members of RANGES.
 465 LIST is a sorted list."
 466   (setq ranges (gnus-range-normalize ranges))
 467   (let (number result)
 468     (while (setq number (pop list))
 469       (while (and ranges
 470                   (if (numberp (car ranges))
 471                       (< (car ranges) number)
 472                     (< (cdar ranges) number)))
 473         (setq ranges (cdr ranges)))
 474       (when (and ranges
 475                  (if (numberp (car ranges))
 476                       (= (car ranges) number)
 477                    ;; (caar ranges) <= number <= (cdar ranges)
 478                    (>= number (caar ranges))))
 479         (push number result)))
 480     (nreverse result)))
 481
 482 (defalias 'gnus-inverse-list-range-intersection 'gnus-list-range-difference)
 483
 484 (defun gnus-list-range-difference (list ranges)
 485   "Return a list of numbers in LIST that are not members of RANGES.
 486 LIST is a sorted list."
 487   (setq ranges (gnus-range-normalize ranges))
 488   (let (number result)
 489     (while (setq number (pop list))
 490       (while (and ranges
 491                   (if (numberp (car ranges))
 492                       (< (car ranges) number)
 493                     (< (cdar ranges) number)))
 494         (setq ranges (cdr ranges)))
 495       (when (or (not ranges)
 496                 (if (numberp (car ranges))
 497                     (not (= (car ranges) number))
 498                   ;; not ((caar ranges) <= number <= (cdar ranges))
 499                   (< number (caar ranges))))
 500         (push number result)))
 501     (nreverse result)))
 502
 503 (defun gnus-range-length (range)
 504   "Return the length RANGE would have if uncompressed."
 505   (cond
 506    ((null range)
 507     0)
 508    ((not (listp (cdr range)))
 509     (- (cdr range) (car range) -1))
 510    (t
 511     (let ((sum 0))
 512       (dolist (x range sum)
 513         (setq sum
 514               (+ sum (if (consp x) (- (cdr x) (car x) -1) 1))))))))
 515
 516 (defun gnus-sublist-p (list sublist)
 517   "Test whether all elements in SUBLIST are members of LIST."
 518   (let ((sublistp t))
 519     (while sublist
 520       (unless (memq (pop sublist) list)
 521         (setq sublistp nil
 522               sublist nil)))
 523     sublistp))
 524
 525 (defun gnus-range-add (range1 range2)
 526   "Add RANGE2 to RANGE1 (nondestructively)."
 527   (unless (listp (cdr range1))
 528     (setq range1 (list range1)))
 529   (unless (listp (cdr range2))
 530     (setq range2 (list range2)))
 531   (let ((item1 (pop range1))
 532         (item2 (pop range2))
 533         range item selector)
 534     (while (or item1 item2)
 535       (setq selector
 536             (cond
 537              ((null item1) nil)
 538              ((null item2) t)
 539              ((and (numberp item1) (numberp item2)) (< item1 item2))
 540              ((numberp item1) (< item1 (car item2)))
 541              ((numberp item2) (< (car item1) item2))
 542              (t (< (car item1) (car item2)))))
 543       (setq item
 544             (or
 545              (let ((tmp1 item) (tmp2 (if selector item1 item2)))
 546                (cond
 547                 ((null tmp1) tmp2)
 548                 ((null tmp2) tmp1)
 549                 ((and (numberp tmp1) (numberp tmp2))
 550                  (cond
 551                   ((eq tmp1 tmp2) tmp1)
 552                   ((eq (1+ tmp1) tmp2) (cons tmp1 tmp2))
 553                   ((eq (1+ tmp2) tmp1) (cons tmp2 tmp1))
 554                   (t nil)))
 555                 ((numberp tmp1)
 556                  (cond
 557                   ((and (>= tmp1 (car tmp2)) (<= tmp1 (cdr tmp2))) tmp2)
 558                   ((eq (1+ tmp1) (car tmp2)) (cons tmp1 (cdr tmp2)))
 559                   ((eq (1- tmp1) (cdr tmp2)) (cons (car tmp2) tmp1))
 560                   (t nil)))
 561                 ((numberp tmp2)
 562                  (cond
 563                   ((and (>= tmp2 (car tmp1)) (<= tmp2 (cdr tmp1))) tmp1)
 564                   ((eq (1+ tmp2) (car tmp1)) (cons tmp2 (cdr tmp1)))
 565                   ((eq (1- tmp2) (cdr tmp1)) (cons (car tmp1) tmp2))
 566                   (t nil)))
 567                 ((< (1+ (cdr tmp1)) (car tmp2)) nil)
 568                 ((< (1+ (cdr tmp2)) (car tmp1)) nil)
 569                 (t (cons (min (car tmp1) (car tmp2))
 570                          (max (cdr tmp1) (cdr tmp2))))))
 571              (progn
 572                (if item (push item range))
 573                (if selector item1 item2))))
 574       (if selector
 575           (setq item1 (pop range1))
 576         (setq item2 (pop range2))))
 577     (if item (push item range))
 578     (reverse range)))
 579
 580 ;;;###autoload
 581 (defun gnus-add-to-sorted-list (list num)
 582   "Add NUM into sorted LIST by side effect."
 583   (let* ((top (cons nil list))
 584          (prev top))
 585     (while (and list (< (car list) num))
 586       (setq prev list
 587             list (cdr list)))
 588     (unless (eq (car list) num)
 589       (setcdr prev (cons num list)))
 590     (cdr top)))
 591
 592 (provide 'gnus-range)
 593
 594 ;;; gnus-range.el ends here