lispdoc: implemented the whole URI syntax; updated URIs in all docstrings to be writt...
[com-informatimago:com-informatimago.git] / common-lisp / cesarum / version.lisp
1 ;;;; -*- mode:lisp;coding:utf-8 -*-
2 ;;;;**************************************************************************
3 ;;;;FILE:               version.lisp
4 ;;;;LANGUAGE:           Common-Lisp
5 ;;;;SYSTEM:             Common-Lisp
6 ;;;;USER-INTERFACE:     NONE
7 ;;;;DESCRIPTION
8 ;;;;    
9 ;;;;    See defpackage documentation string.
10 ;;;;    
11 ;;;;AUTHORS
12 ;;;;    <PJB> Pascal J. Bourguignon <pjb@informatimago.com>
13 ;;;;MODIFICATIONS
14 ;;;;    2010-07-18 <PJB> Extracted from script.lisp (extracted from .clisprc).
15 ;;;;BUGS
16 ;;;;LEGAL
17 ;;;;    AGPL3
18 ;;;;    
19 ;;;;    Copyright Pascal J. Bourguignon 2010 - 2012
20 ;;;;    
21 ;;;;    This program is free software: you can redistribute it and/or modify
22 ;;;;    it under the terms of the GNU Affero General Public License as published by
23 ;;;;    the Free Software Foundation, either version 3 of the License, or
24 ;;;;    (at your option) any later version.
25 ;;;;    
26 ;;;;    This program is distributed in the hope that it will be useful,
27 ;;;;    but WITHOUT ANY WARRANTY; without even the implied warranty of
28 ;;;;    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
29 ;;;;    GNU Affero General Public License for more details.
30 ;;;;    
31 ;;;;    You should have received a copy of the GNU Affero General Public License
32 ;;;;    along with this program.  If not, see <http://www.gnu.org/licenses/>
33 ;;;;**************************************************************************
34
35 (defpackage "COM.INFORMATIMAGO.COMMON-LISP.CESARUM.VERSION"
36   (:use "COMMON-LISP")
37   (:export
38    "VERSION"
39    "VERSION="     "VERSION<"    "VERSION<="
40    "VERSION/="    "VERSION>"    "VERSION>="
41    "RT-VERSION="  "RT-VERSION<" "RT-VERSION<="
42    "RT-VERSION/=" "RT-VERSION>" "RT-VERSION>="
43    )
44   (:documentation "
45
46 This package exports functions to get and compare lisp implementation
47 versions.
48
49
50
51 License:
52
53     AGPL3
54     
55     Copyright Pascal J. Bourguignon 2010 - 2012
56     
57     This program is free software: you can redistribute it and/or modify
58     it under the terms of the GNU Affero General Public License as published by
59     the Free Software Foundation, either version 3 of the License, or
60     (at your option) any later version.
61     
62     This program is distributed in the hope that it will be useful,
63     but WITHOUT ANY WARRANTY; without even the implied warranty of
64     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
65     GNU Affero General Public License for more details.
66     
67     You should have received a copy of the GNU Affero General Public License
68     along with this program.
69     If not, see <http://www.gnu.org/licenses/>
70
71 "))
72 (in-package "COM.INFORMATIMAGO.COMMON-LISP.CESARUM.VERSION")
73
74
75 (defun version (&optional (version-string (lisp-implementation-version)))
76   "
77 Parse the version in the version-string or (lisp-implementation-version)
78 This is expected to be a sequence of integers separated by dots.
79 Return it as a list of integers.
80 "
81   (loop
82      :with r = '()
83      :with start = 0
84      :do (multiple-value-bind (n p)
85              (parse-integer version-string :start start :junk-allowed t)
86            (push n r)
87            (if (or (<= (length version-string) p)
88                    (char= #\space (aref version-string p)))
89                (return-from version (nreverse r))   
90             (setf start (1+ p))))))
91
92 (defun version= (a b)
93   "Compare versions A and B, which may be either lists of integers, or a dotted string."
94   (let ((a (if (stringp a) (version a) a))
95         (b (if (stringp b) (version b) b)))
96     (equal a b)))
97
98
99 (defun version/= (a b)
100   "Compare versions A and B, which may be either lists of integers, or a dotted string."
101   (not (version= a b)))
102
103
104 (defun version< (a b)
105   "Compare versions A and B, which may be either lists of integers, or a dotted string."
106   (let ((a (if (stringp a) (version a) a))
107         (b (if (stringp b) (version b) b)))
108     (cond
109       ((null a)            (not (null b)))
110       ((null b)            nil)
111       ((< (car a) (car b)) t)
112       ((= (car a) (car b)) (version< (cdr a) (cdr b)))
113       (t                   nil))))
114
115
116 (defun version<= (a b)
117   "Compare versions A and B, which may be either lists of integers, or a dotted string."
118   (let ((a (if (stringp a) (version a) a))
119         (b (if (stringp b) (version b) b)))
120     (or (version= a b) (version< a b))))
121
122
123 (defun version>  (a b)
124   "Compare versions A and B, which may be either lists of integers, or a dotted string."
125   (version<  b a))
126
127
128 (defun version>= (a b)
129   "Compare versions A and B, which may be either lists of integers, or a dotted string."
130   (version<= b a))
131
132
133 (defun rt-version=  (a b)
134   "Compare versions A and B, which may be either lists of integers, or a dotted string,
135 returning either (:AND) or (:OR), for use as a read-time feature expression.
136    #.#+(version:rt-version= \"1.0\" (version:version)) read-only-in-version-1.0
137 "
138   (if (version=  a b) '(:and) '(:or)))
139
140
141 (defun rt-version<  (a b)
142   "
143 Compare versions A and B, which may be either lists of integers, or a dotted string,
144 returning either (:AND) or (:OR), for use as a read-time feature expression.
145    #.#+(version:rt-version= \"1.0\" (version:version)) read-only-in-version-1.0
146 "
147   (if (version<  a b) '(:and) '(:or)))
148
149
150 (defun rt-version<= (a b)
151   "
152 Compare versions A and B, which may be either lists of integers, or a dotted string,
153 returning either (:AND) or (:OR), for use as a read-time feature expression.
154    #.#+(version:rt-version= \"1.0\" (version:version)) read-only-in-version-1.0
155 "
156   (if (version<= a b) '(:and) '(:or)))
157
158
159 (defun rt-version>  (a b)
160   "
161 Compare versions A and B, which may be either lists of integers, or a dotted string,
162 returning either (:AND) or (:OR), for use as a read-time feature expression.
163    #.#+(version:rt-version= \"1.0\" (version:version)) read-only-in-version-1.0
164 "
165   (rt-version< b a))
166
167
168 (defun rt-version>= (a b)
169   "
170 Compare versions A and B, which may be either lists of integers, or a dotted string,
171 returning either (:AND) or (:OR), for use as a read-time feature expression.
172    #.#+(version:rt-version= \"1.0\" (version:version)) read-only-in-version-1.0
173 "
174   (rt-version<= b a))
175
176 ;;;; THE END ;;;;