cgit.sxemacs.org Git - gnus/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, 2003, 2004,
   4 ;;   2005, 2006, 2007, 2008, 2009, 2010 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 3 of the License, or
  14 ;; (at your option) 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.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 ;;; Commentary:
  25
  26 ;;; Code:
  27
  28 (eval-when-compile (require 'cl))
  29
  30 ;;; List and range functions
  31
  32 (defsubst gnus-range-normalize (range)
  33   "Normalize RANGE.
  34 If RANGE is a single range, return (RANGE). Otherwise, return RANGE."
  35   (if (listp (cdr-safe range)) range (list range)))
  36
  37 (defun gnus-last-element (list)
  38   "Return last element of LIST."
  39   (while (cdr list)
  40     (setq list (cdr list)))
  41   (car list))
  42
  43 (defun gnus-copy-sequence (list)
  44   "Do a complete, total copy of a list."
  45   (let (out)
  46     (while (consp list)
  47       (if (consp (car list))
  48           (push (gnus-copy-sequence (pop list)) out)
  49         (push (pop list) out)))
  50     (if list
  51         (nconc (nreverse out) list)
  52       (nreverse out))))
  53
  54 (defun gnus-set-difference (list1 list2)
  55   "Return a list of elements of LIST1 that do not appear in LIST2."
  56   (let ((list1 (copy-sequence list1)))
  57     (while list2
  58       (setq list1 (delq (car list2) list1))
  59       (setq list2 (cdr list2)))
  60     list1))
  61
  62 (defun gnus-range-nconcat (&rest ranges)
  63   "Return a range comprising all the RANGES, which are pre-sorted.
  64 RANGES will be destructively altered."
  65   (setq ranges (delete nil ranges))
  66   (let* ((result (gnus-range-normalize (pop ranges)))
  67          (last (last result)))
  68     (dolist (range ranges)
  69       (setq range (gnus-range-normalize range))
  70       ;; Normalize the single-number case, so that we don't need to
  71       ;; special-case that so much.
  72       (when (numberp (car last))
  73         (setcar last (cons (car last) (car last))))
  74       (when (numberp (car range))
  75         (setcar range (cons (car range) (car range))))
  76       (if (= (1+ (cdar last)) (caar range))
  77           (progn
  78             (setcdr (car last) (cdar range))
  79             (setcdr last (cdr range)))
  80         (setcdr last range)
  81         ;; Denormalize back, since we couldn't join the ranges up.
  82         (when (= (caar range) (cdar range))
  83           (setcar range (caar range)))
  84         (when (= (caar last) (cdar last))
  85           (setcar last (caar last))))
  86       (setq last (last last)))
  87     (if (and (consp (car result))
  88              (= (length result) 1))
  89         (car result)
  90       result)))
  91
  92 (defun gnus-range-difference (range1 range2)
  93   "Return the range of elements in RANGE1 that do not appear in RANGE2.
  94 Both ranges must be in ascending order."
  95   (setq range1 (gnus-range-normalize range1))
  96   (setq range2 (gnus-range-normalize range2))
  97   (let* ((new-range (cons nil (copy-sequence range1)))
  98          (r new-range)
  99          (safe t))
 100     (while (cdr r)
 101       (let* ((r1 (cadr r))
 102              (r2 (car range2))
 103              (min1 (if (numberp r1) r1 (car r1)))
 104              (max1 (if (numberp r1) r1 (cdr r1)))
 105              (min2 (if (numberp r2) r2 (car r2)))
 106              (max2 (if (numberp r2) r2 (cdr r2))))
 107
 108         (cond ((> min1 max1)
 109                ;; Invalid range: may result from overlap condition (below)
 110                ;; remove Invalid range
 111                (setcdr r (cddr r)))
 112               ((and (= min1 max1)
 113                     (listp r1))
 114                ;; Inefficient representation: may result from overlap condition (below)
 115                (setcar (cdr r) min1))
 116               ((not min2)
 117                ;; All done with range2
 118                (setq r nil))
 119               ((< max1 min2)
 120                ;; No overlap: range1 preceeds range2
 121                (pop r))
 122               ((< max2 min1)
 123                ;; No overlap: range2 preceeds range1
 124                (pop range2))
 125               ((and (<= min2 min1) (<= max1 max2))
 126                ;; Complete overlap: range1 removed
 127                (setcdr r (cddr r)))
 128               (t
 129                (setcdr r (nconc (list (cons min1 (1- min2)) (cons (1+ max2) max1)) (cddr r)))))))
 130     (cdr new-range)))
 131
 132
 133
 134 ;;;###autoload
 135 (defun gnus-sorted-difference (list1 list2)
 136   "Return a list of elements of LIST1 that do not appear in LIST2.
 137 Both lists have to be sorted over <.
 138 The tail of LIST1 is not copied."
 139   (let (out)
 140     (while (and list1 list2)
 141       (cond ((= (car list1) (car list2))
 142              (setq list1 (cdr list1)
 143                    list2 (cdr list2)))
 144             ((< (car list1) (car list2))
 145              (setq out (cons (car list1) out))
 146              (setq list1 (cdr list1)))
 147             (t
 148              (setq list2 (cdr list2)))))
 149     (nconc (nreverse out) list1)))
 150
 151 ;;;###autoload
 152 (defun gnus-sorted-ndifference (list1 list2)
 153   "Return a list of elements of LIST1 that do not appear in LIST2.
 154 Both lists have to be sorted over <.
 155 LIST1 is modified."
 156   (let* ((top (cons nil list1))
 157          (prev top))
 158     (while (and list1 list2)
 159       (cond ((= (car list1) (car list2))
 160              (setcdr prev (cdr list1))
 161              (setq list1 (cdr list1)
 162                    list2 (cdr list2)))
 163             ((< (car list1) (car list2))
 164              (setq prev list1
 165                    list1 (cdr list1)))
 166             (t
 167              (setq list2 (cdr list2)))))
 168     (cdr top)))
 169
 170 ;;;###autoload
 171 (defun gnus-sorted-complement (list1 list2)
 172   "Return a list of elements that are in LIST1 or LIST2 but not both.
 173 Both lists have to be sorted over <."
 174   (let (out)
 175     (if (or (null list1) (null list2))
 176         (or list1 list2)
 177       (while (and list1 list2)
 178         (cond ((= (car list1) (car list2))
 179                (setq list1 (cdr list1)
 180                      list2 (cdr list2)))
 181               ((< (car list1) (car list2))
 182                (setq out (cons (car list1) out))
 183                (setq list1 (cdr list1)))
 184               (t
 185                (setq out (cons (car list2) out))
 186                (setq list2 (cdr list2)))))
 187       (nconc (nreverse out) (or list1 list2)))))
 188
 189 ;;;###autoload
 190 (defun gnus-intersection (list1 list2)
 191   (let ((result nil))
 192     (while list2
 193       (when (memq (car list2) list1)
 194         (setq result (cons (car list2) result)))
 195       (setq list2 (cdr list2)))
 196     result))
 197
 198 ;;;###autoload
 199 (defun gnus-sorted-intersection (list1 list2)
 200   "Return intersection of LIST1 and LIST2.
 201 LIST1 and LIST2 have to be sorted over <."
 202   (let (out)
 203     (while (and list1 list2)
 204       (cond ((= (car list1) (car list2))
 205              (setq out (cons (car list1) out)
 206                    list1 (cdr list1)
 207                    list2 (cdr list2)))
 208             ((< (car list1) (car list2))
 209              (setq list1 (cdr list1)))
 210             (t
 211              (setq list2 (cdr list2)))))
 212     (nreverse out)))
 213
 214 ;;;###autoload
 215 (defun gnus-sorted-range-intersection (range1 range2)
 216   "Return intersection of RANGE1 and RANGE2.
 217 RANGE1 and RANGE2 have to be sorted over <."
 218   (let* (out
 219          (min1 (car range1))
 220          (max1 (if (numberp min1)
 221                    (if (numberp (cdr range1))
 222                        (prog1 (cdr range1)
 223                          (setq range1 nil)) min1)
 224                  (prog1 (cdr min1)
 225                    (setq min1 (car min1)))))
 226          (min2 (car range2))
 227          (max2 (if (numberp min2)
 228                    (if (numberp (cdr range2))
 229                        (prog1 (cdr range2)
 230                          (setq range2 nil)) min2)
 231                  (prog1 (cdr min2)
 232                    (setq min2 (car min2))))))
 233     (setq range1 (cdr range1)
 234           range2 (cdr range2))
 235     (while (and min1 min2)
 236       (cond ((< max1 min2)              ; range1 preceeds range2
 237              (setq range1 (cdr range1)
 238                    min1 nil))
 239             ((< max2 min1)              ; range2 preceeds range1
 240              (setq range2 (cdr range2)
 241                    min2 nil))
 242             (t                     ; some sort of overlap is occurring
 243              (let ((min (max min1 min2))
 244                    (max (min max1 max2)))
 245                (setq out (if (= min max)
 246                              (cons min out)
 247                            (cons (cons min max) out))))
 248              (if (< max1 max2)          ; range1 ends before range2
 249                  (setq min1 nil)        ; incr range1
 250                (setq min2 nil))))       ; incr range2
 251       (unless min1
 252         (setq min1 (car range1)
 253               max1 (if (numberp min1) min1 (prog1 (cdr min1) (setq min1 (car min1))))