]>
Commit | Line | Data |
---|---|---|
1e59de90 | 1 | # Copyright 2021 Nikita Kniazev |
7c673cae FG |
2 | # Copyright 2001, 2002 Dave Abrahams |
3 | # Copyright 2002, 2003 Vladimir Prus | |
4 | # Distributed under the Boost Software License, Version 1.0. | |
1e59de90 | 5 | # (See accompanying file LICENSE.txt or https://www.bfgroup.xyz/b2/LICENSE.txt) |
7c673cae FG |
6 | |
7 | import errors ; | |
8 | ||
9 | ||
10 | rule trim-leading-zeroes ( value ) | |
11 | { | |
12 | return [ CALC $(value) + 0 ] ; | |
13 | } | |
14 | ||
15 | ||
16 | rule check ( numbers * ) | |
17 | { | |
18 | for local n in $(numbers) | |
19 | { | |
20 | switch $(n) | |
21 | { | |
22 | case *[^0-9]* : | |
23 | errors.error $(n) "in" $(numbers) : is not a number ; | |
24 | } | |
25 | } | |
26 | } | |
27 | ||
28 | ||
29 | rule increment ( number ) | |
30 | { | |
31 | return [ CALC $(number) + 1 ] ; | |
32 | } | |
33 | ||
34 | ||
35 | rule decrement ( number ) | |
36 | { | |
37 | return [ CALC $(number) - 1 ] ; | |
38 | } | |
39 | ||
40 | ||
41 | rule range ( start finish ? : step ? ) | |
42 | { | |
43 | if ! $(finish) | |
44 | { | |
45 | finish = $(start) ; | |
46 | start = 1 ; | |
47 | } | |
48 | step ?= 1 ; | |
49 | ||
50 | check $(start) $(finish) $(step) ; | |
51 | ||
52 | if $(finish) != 0 | |
53 | { | |
54 | local result ; | |
55 | while [ less $(start) $(finish) ] || $(start) = $(finish) | |
56 | { | |
57 | result += $(start) ; | |
58 | start = [ CALC $(start) + $(step) ] ; | |
59 | } | |
60 | return $(result) ; | |
61 | } | |
62 | } | |
63 | ||
64 | ||
1e59de90 TL |
65 | rule equal ( n1 n2 ) |
66 | { | |
67 | if [ CALC $(n2) - $(n1) ] = 0 | |
68 | { | |
69 | return true ; | |
70 | } | |
71 | return ; | |
72 | } | |
73 | ||
74 | ||
7c673cae FG |
75 | rule less ( n1 n2 ) |
76 | { | |
77 | switch [ CALC $(n2) - $(n1) ] | |
78 | { | |
79 | case [1-9]* : return true ; | |
80 | } | |
81 | } | |
82 | ||
83 | ||
84 | rule log10 ( number ) | |
85 | { | |
86 | switch $(number) | |
87 | { | |
88 | case *[^0-9]* : errors.error $(number) is not a number ; | |
89 | case 0 : errors.error can't take log of zero ; | |
90 | case [1-9] : return 0 ; | |
91 | case [1-9]? : return 1 ; | |
92 | case [1-9]?? : return 2 ; | |
93 | case [1-9]??? : return 3 ; | |
94 | case [1-9]???? : return 4 ; | |
95 | case [1-9]????? : return 5 ; | |
96 | case [1-9]?????? : return 6 ; | |
97 | case [1-9]??????? : return 7 ; | |
98 | case [1-9]???????? : return 8 ; | |
99 | case [1-9]????????? : return 9 ; | |
100 | case * : | |
101 | { | |
102 | import sequence ; | |
103 | import string ; | |
104 | local chars = [ string.chars $(number) ] ; | |
105 | while $(chars[1]) = 0 | |
106 | { | |
107 | chars = $(chars[2-]) ; | |
108 | } | |
109 | if ! $(chars) | |
110 | { | |
111 | errors.error can't take log of zero ; | |
112 | } | |
113 | else | |
114 | { | |
115 | return [ decrement [ sequence.length $(chars) ] ] ; | |
116 | } | |
117 | } | |
118 | } | |
119 | } | |
120 | ||
121 | ||
122 | rule __test__ ( ) | |
123 | { | |
124 | import assert ; | |
125 | ||
126 | assert.result 1 : increment 0 ; | |
127 | assert.result 2 : increment 1 ; | |
128 | assert.result 1 : decrement 2 ; | |
129 | assert.result 0 : decrement 1 ; | |
130 | assert.result 50 : increment 49 ; | |
131 | assert.result 49 : decrement 50 ; | |
132 | assert.result 99 : increment 98 ; | |
133 | assert.result 99 : decrement 100 ; | |
134 | assert.result 100 : increment 99 ; | |
135 | assert.result 999 : decrement 1000 ; | |
136 | assert.result 1000 : increment 999 ; | |
137 | ||
138 | assert.result 1 2 3 : range 3 ; | |
139 | assert.result 1 2 3 4 5 6 7 8 9 10 11 12 : range 12 ; | |
140 | assert.result 3 4 5 6 7 8 9 10 11 : range 3 11 ; | |
141 | assert.result : range 0 ; | |
142 | assert.result 1 4 7 10 : range 10 : 3 ; | |
143 | assert.result 2 4 6 8 10 : range 2 10 : 2 ; | |
144 | assert.result 25 50 75 100 : range 25 100 : 25 ; | |
145 | ||
146 | assert.result 0 : trim-leading-zeroes 0 ; | |
147 | assert.result 1234 : trim-leading-zeroes 1234 ; | |
148 | assert.result 123456 : trim-leading-zeroes 0000123456 ; | |
149 | assert.result 1000123456 : trim-leading-zeroes 1000123456 ; | |
150 | assert.result 10000 : trim-leading-zeroes 10000 ; | |
151 | assert.result 10000 : trim-leading-zeroes 00010000 ; | |
152 | ||
153 | assert.true less 1 2 ; | |
154 | assert.true less 1 12 ; | |
155 | assert.true less 1 21 ; | |
156 | assert.true less 005 217 ; | |
157 | assert.false less 0 0 ; | |
158 | assert.false less 03 3 ; | |
159 | assert.false less 3 03 ; | |
160 | assert.true less 005 217 ; | |
161 | assert.true less 0005 217 ; | |
162 | assert.true less 5 00217 ; | |
163 | ||
1e59de90 TL |
164 | assert.true equal 0 0 ; |
165 | assert.true equal 00 0 ; | |
166 | assert.true equal 0 00 ; | |
167 | assert.true equal 00 00 ; | |
168 | assert.true equal 00 000 ; | |
169 | assert.true equal 123 123 ; | |
170 | assert.true equal 0123 123 ; | |
171 | assert.true equal 123 0123 ; | |
172 | assert.false equal 0 1 ; | |
173 | assert.false equal 123 124 ; | |
174 | assert.false equal 124 123 ; | |
175 | ||
7c673cae FG |
176 | # TEMPORARY disabled, because nested "try"/"catch" do not work and I do no |
177 | # have the time to fix that right now. | |
178 | if $(0) | |
179 | { | |
180 | try ; | |
181 | { | |
182 | decrement 0 ; | |
183 | } | |
184 | catch can't decrement zero! ; | |
185 | ||
186 | try ; | |
187 | { | |
188 | check foo ; | |
189 | } | |
190 | catch : not a number ; | |
191 | ||
192 | try ; | |
193 | { | |
194 | increment foo ; | |
195 | } | |
196 | catch : not a number ; | |
197 | ||
198 | try ; | |
199 | { | |
200 | log10 0 ; | |
201 | } | |
202 | catch can't take log of zero ; | |
203 | ||
204 | try ; | |
205 | { | |
206 | log10 000 ; | |
207 | } | |
208 | catch can't take log of zero ; | |
209 | ||
210 | } | |
211 | ||
212 | assert.result 0 : log10 1 ; | |
213 | assert.result 0 : log10 9 ; | |
214 | assert.result 1 : log10 10 ; | |
215 | assert.result 1 : log10 99 ; | |
216 | assert.result 2 : log10 100 ; | |
217 | assert.result 2 : log10 101 ; | |
218 | assert.result 2 : log10 125 ; | |
219 | assert.result 2 : log10 999 ; | |
220 | assert.result 3 : log10 1000 ; | |
221 | assert.result 10 : log10 12345678901 ; | |
222 | ||
223 | for local x in [ range 75 110 : 5 ] | |
224 | { | |
225 | for local y in [ range $(x) 111 : 3 ] | |
226 | { | |
227 | if $(x) != $(y) | |
228 | { | |
229 | assert.true less $(x) $(y) ; | |
230 | } | |
231 | } | |
232 | } | |
233 | ||
234 | for local x in [ range 90 110 : 2 ] | |
235 | { | |
236 | for local y in [ range 80 $(x) : 4 ] | |
237 | { | |
238 | assert.false less $(x) $(y) ; | |
239 | } | |
240 | } | |
241 | } |