1 | #ash# set +o posix
|
---|
2 | #ash# declare -i iv jv
|
---|
3 |
|
---|
4 | echo "Format: 'expected actual'"
|
---|
5 |
|
---|
6 | iv=$(( 3 + 5 * 32 ))
|
---|
7 | echo 163 $iv
|
---|
8 | #ash# iv=iv+3
|
---|
9 | #ash# echo 166 $iv
|
---|
10 | iv=2
|
---|
11 | jv=iv
|
---|
12 |
|
---|
13 | : $((jv *= 2)) ##hush## let "jv *= 2"
|
---|
14 | echo 4 $jv
|
---|
15 | jv=$(( $jv << 2 ))
|
---|
16 | echo 16 $jv
|
---|
17 |
|
---|
18 | : $((jv=$jv / 2)) ##hush## let jv="$jv / 2"
|
---|
19 | echo 8 $jv
|
---|
20 | #ash# jv="jv >> 2"
|
---|
21 | : $((jv=jv >> 2)) ##hush## let jv="jv >> 2"
|
---|
22 | echo 2 $jv
|
---|
23 |
|
---|
24 | iv=$((iv+ $jv))
|
---|
25 | echo 4 $iv
|
---|
26 | echo 2 $((iv -= jv))
|
---|
27 | echo 2 $iv
|
---|
28 | echo 1 $(( iv == jv ))
|
---|
29 | echo 0 $(( iv != $jv ))
|
---|
30 | echo 0 $(( iv < jv ))
|
---|
31 | echo 0 $(( $iv > $jv ))
|
---|
32 | echo 1 $(( iv <= $jv ))
|
---|
33 | echo 1 $(( $iv >= jv ))
|
---|
34 |
|
---|
35 | echo 2 $jv
|
---|
36 | echo -3 $(( ~$jv ))
|
---|
37 | echo -2 $(( ~1 ))
|
---|
38 | echo 1 $(( ! 0 ))
|
---|
39 |
|
---|
40 | echo 0 $(( jv % 2 ))
|
---|
41 | echo 2 $(( $iv % 4 ))
|
---|
42 |
|
---|
43 | echo 131072 $(( iv <<= 16 ))
|
---|
44 | echo 29 $(( iv %= 33 ))
|
---|
45 |
|
---|
46 | echo 33 $(( 33 & 55 ))
|
---|
47 | echo 49 $(( 33 | 17 ))
|
---|
48 |
|
---|
49 | echo 1 $(( iv && $jv ))
|
---|
50 | echo 1 $(( $iv || jv ))
|
---|
51 |
|
---|
52 | echo 0 $(( iv && 0 ))
|
---|
53 | echo 0 $(( iv & 0 ))
|
---|
54 | echo 1 $(( iv && 1 ))
|
---|
55 | echo 1 $(( iv & 1 ))
|
---|
56 |
|
---|
57 | echo 1 $(( $jv || 0 ))
|
---|
58 | echo 2 $(( jv | 0 ))
|
---|
59 | echo 3 $(( jv | 1 ))
|
---|
60 | echo 1 $(( $jv || 1 ))
|
---|
61 |
|
---|
62 | : $((iv *= jv)) ##hush## let 'iv *= jv'
|
---|
63 | echo 58 $iv
|
---|
64 | echo 2 $jv
|
---|
65 | : $((jv += $iv)) ##hush## let "jv += $iv"
|
---|
66 | echo 60 $jv
|
---|
67 |
|
---|
68 | echo 1 $(( jv /= iv ))
|
---|
69 | echo 256 $(( jv <<= 8 ))
|
---|
70 | echo 16 $(( jv >>= 4 ))
|
---|
71 |
|
---|
72 | echo 62 $(( iv |= 4 ))
|
---|
73 | echo 4 $(( iv &= 4 ))
|
---|
74 |
|
---|
75 | echo 29 $(( iv += (jv + 9)))
|
---|
76 | echo 5 $(( (iv + 4) % 7 ))
|
---|
77 |
|
---|
78 | echo unary plus, minus
|
---|
79 | echo -4 $(( +4 - 8 ))
|
---|
80 | echo 4 $(( -4 + 8 ))
|
---|
81 |
|
---|
82 | echo conditional expressions
|
---|
83 | echo 1 $(( 4<5 ? 1 : 32))
|
---|
84 | echo 32 $(( 4>5 ? 1 : 32))
|
---|
85 | echo 32 $(( 4>(2+3) ? 1 : 32))
|
---|
86 | echo 1 $(( 4<(2+3) ? 1 : 32))
|
---|
87 | echo 1 $(( (2+2)<(2+3) ? 1 : 32))
|
---|
88 | echo 32 $(( (2+2)>(2+3) ? 1 : 32))
|
---|
89 |
|
---|
90 | echo 'check that parentheses in `cmd` are interpreted correctly'
|
---|
91 | # \x28 is '('
|
---|
92 | echo 3 $(( ( `printf '(\x28 1'` + `echo 2\)\)` ) ))
|
---|
93 |
|
---|
94 | echo check that the unevaluated part of the ternary operator does not do evaluation or assignment
|
---|
95 | x=i+=2
|
---|
96 | y=j+=2
|
---|
97 | #ash# declare -i i=1 j=1
|
---|
98 | i=1
|
---|
99 | j=1
|
---|
100 | echo 20 $((1 ? 20 : (x+=2)))
|
---|
101 | #ash# echo $i,$x # ash mishandles this
|
---|
102 | echo 30 $((0 ? (y+=2) : 30))
|
---|
103 | #ash# echo $j,$y # ash mishandles this
|
---|
104 |
|
---|
105 | x=i+=2
|
---|
106 | y=j+=2
|
---|
107 | #ash# declare -i i=1 j=1
|
---|
108 | i=1
|
---|
109 | j=1
|
---|
110 | echo 20 $((1 ? 20 : (x+=2)))
|
---|
111 | #ash# echo $i,$x # ash mishandles this
|
---|
112 | echo 30 $((0 ? (y+=2) : 30))
|
---|
113 | #ash# echo $i,$y # ash mishandles this
|
---|
114 |
|
---|
115 | echo check precedence of assignment vs. conditional operator
|
---|
116 | # should be an error
|
---|
117 | #ash# declare -i x=2
|
---|
118 | x=2
|
---|
119 | #ashnote# bash reports error but continues, ash aborts - using subshell to 'emulate' bash:
|
---|
120 | ( y=$((1 ? 20 : x+=2)) )
|
---|
121 |
|
---|
122 | echo check precedence of assignment vs. conditional operator
|
---|
123 | #ash# declare -i x=2
|
---|
124 | x=2
|
---|
125 | # ash says "line NNN: syntax error: 0 ? x+=2 : 20"
|
---|
126 | #ash# echo 20 $((0 ? x+=2 : 20))
|
---|
127 |
|
---|
128 | echo associativity of assignment-operator operator
|
---|
129 | #ash# declare -i i=1 j=2 k=3
|
---|
130 | i=1
|
---|
131 | j=2
|
---|
132 | k=3
|
---|
133 | echo 6 $((i += j += k))
|
---|
134 | echo 6,5,3 $i,$j,$k
|
---|
135 |
|
---|
136 | echo octal, hex
|
---|
137 | echo 263 $(( 0x100 | 007 ))
|
---|
138 | echo 255 $(( 0xff ))
|
---|
139 | #ash# echo 255 $(( 16#ff ))
|
---|
140 | #ash# echo 127 $(( 16#FF/2 ))
|
---|
141 | #ash# echo 36 $(( 8#44 ))
|
---|
142 |
|
---|
143 | echo 40 $(( 8 ^ 32 ))
|
---|
144 |
|
---|
145 | #ash# # other bases
|
---|
146 | #ash# echo 10 $(( 16#a ))
|
---|
147 | #ash# echo 10 $(( 32#a ))
|
---|
148 | #ash# echo 10 $(( 56#a ))
|
---|
149 | #ash# echo 10 $(( 64#a ))
|
---|
150 | #ash#
|
---|
151 | #ash# echo 10 $(( 16#A ))
|
---|
152 | #ash# echo 10 $(( 32#A ))
|
---|
153 | #ash# echo 36 $(( 56#A ))
|
---|
154 | #ash# echo 36 $(( 64#A ))
|
---|
155 | #ash#
|
---|
156 | #ash# echo 62 $(( 64#@ ))
|
---|
157 | #ash# echo 63 $(( 64#_ ))
|
---|
158 |
|
---|
159 | #ash# # weird bases (error)
|
---|
160 | #ash# echo $(( 3425#56 ))
|
---|
161 |
|
---|
162 | #ash# # missing number after base
|
---|
163 | #ash# echo 0 $(( 2# ))
|
---|
164 |
|
---|
165 | # these should generate errors
|
---|
166 | ( echo $(( 7 = 43 )) )
|
---|
167 | #ash# echo $(( 2#44 ))
|
---|
168 | ( echo $(( 44 / 0 )) )
|
---|
169 | ( let 'jv += $iv' )
|
---|
170 | ( echo $(( jv += \$iv )) )
|
---|
171 | ( let 'rv = 7 + (43 * 6' )
|
---|
172 |
|
---|
173 | #ash# # more errors
|
---|
174 | #ash# declare -i i
|
---|
175 | #ash# i=0#4
|
---|
176 | #ash# i=2#110#11
|
---|
177 |
|
---|
178 | ((echo abc; echo def;); echo ghi)
|
---|
179 |
|
---|
180 | #ash# if (((4+4) + (4 + 7))); then
|
---|
181 | #ash# echo ok
|
---|
182 | #ash# fi
|
---|
183 |
|
---|
184 | #ash# (()) # make sure the null expression works OK
|
---|
185 |
|
---|
186 | #ash# a=(0 2 4 6)
|
---|
187 | #ash# echo 6 $(( a[1] + a[2] ))
|
---|
188 | #ash# echo 1 $(( (a[1] + a[2]) == a[3] ))
|
---|
189 | #ash# (( (a[1] + a[2]) == a[3] )) ; echo 0 $?
|
---|
190 |
|
---|
191 | # test pushing and popping the expression stack
|
---|
192 | unset A
|
---|
193 | A="4 + "
|
---|
194 | ( echo A $(( ( 4 + A ) + 4 )) )
|
---|
195 | A="3 + 5"
|
---|
196 | echo 16 $(( ( 4 + A ) + 4 ))
|
---|
197 |
|
---|
198 | # badly-formed conditional expressions
|
---|
199 | ( echo $(( 4 ? : $A )) )
|
---|
200 | ( echo $(( 1 ? 20 )) )
|
---|
201 | ( echo $(( 4 ? 20 : )) )
|
---|
202 |
|
---|
203 | # precedence and short-circuit evaluation
|
---|
204 | B=9
|
---|
205 | echo 9 $B
|
---|
206 |
|
---|
207 | # error
|
---|
208 | ( echo $(( 0 && B=42 )); echo 9 $B )
|
---|
209 |
|
---|
210 | # error
|
---|
211 | ( echo $(( 1 || B=88 )); echo 9 $B )
|
---|
212 |
|
---|
213 | # ash mistakenly evaluates B=... below
|
---|
214 | #ash# echo 0 $(( 0 && (B=42) ))
|
---|
215 | echo 9 $B
|
---|
216 | #ash# echo 0 $(( (${$} - $$) && (B=42) ))
|
---|
217 | echo 9 $B
|
---|
218 | #ash# echo 1 $(( 1 || (B=88) ))
|
---|
219 | echo 9 $B
|
---|
220 |
|
---|
221 |
|
---|
222 | # until command with (( )) command
|
---|
223 | x=7
|
---|
224 |
|
---|
225 | echo 7 $x
|
---|
226 | #ash# until (( x == 4 ))
|
---|
227 | until test "$x" = 4
|
---|
228 | do
|
---|
229 | echo $x
|
---|
230 | x=4
|
---|
231 | done
|
---|
232 |
|
---|
233 | echo 4 $x
|
---|
234 |
|
---|
235 | # exponentiation
|
---|
236 | echo 32767 $(( 2**15 - 1))
|
---|
237 | echo 32768 $(( 2**(16-1)))
|
---|
238 | echo 131072 $(( 2**16*2 ))
|
---|
239 | echo 2147483647 $(( 2**31-1))
|
---|
240 | echo 1 $(( 2**0 ))
|
---|
241 |
|
---|
242 | # {pre,post}-{inc,dec}rement and associated errors
|
---|
243 |
|
---|
244 | x=4
|
---|
245 |
|
---|
246 | echo 4 $x
|
---|
247 | echo 4 $(( x++ ))
|
---|
248 | echo 5 $x
|
---|
249 | echo 5 $(( x-- ))
|
---|
250 | echo 4 $x
|
---|
251 |
|
---|
252 | echo 3 $(( --x ))
|
---|
253 | echo 3 $x
|
---|
254 |
|
---|
255 | echo 4 $(( ++x ))
|
---|
256 | echo 4 $x
|
---|
257 |
|
---|
258 | # bash 3.2 apparently thinks that ++7 is 7
|
---|
259 | #ash# echo 7 $(( ++7 ))
|
---|
260 | ( echo $(( 7-- )) )
|
---|
261 |
|
---|
262 | ( echo $(( --x=7 )) )
|
---|
263 | ( echo $(( ++x=7 )) )
|
---|
264 |
|
---|
265 | ( echo $(( x++=7 )) )
|
---|
266 | ( echo $(( x--=7 )) )
|
---|
267 |
|
---|
268 | echo 4 $x
|
---|
269 |
|
---|
270 | echo 7 $(( +7 ))
|
---|
271 | echo -7 $(( -7 ))
|
---|
272 |
|
---|
273 | # bash 3.2 apparently thinks that ++7 is 7
|
---|
274 | #ash# echo $(( ++7 ))
|
---|
275 | #ash# echo $(( --7 ))
|
---|
276 |
|
---|
277 | ${THIS_SH} ./arith1.sub
|
---|
278 | ${THIS_SH} ./arith2.sub
|
---|
279 |
|
---|
280 | x=4
|
---|
281 | y=7
|
---|
282 |
|
---|
283 | #ash# (( x=8 , y=12 ))
|
---|
284 | x=8
|
---|
285 | y=12
|
---|
286 | echo $x $y
|
---|
287 |
|
---|
288 | #ash# # should be an error
|
---|
289 | #ash# (( x=9 y=41 ))
|
---|
290 |
|
---|
291 | # These are errors
|
---|
292 | unset b
|
---|
293 | ( echo $((a b)) )
|
---|
294 | #ash# ((a b))
|
---|
295 |
|
---|
296 | n=42
|
---|
297 | printf "%d\n" $n
|
---|
298 | printf "%i\n" $n
|
---|
299 | #ash# echo $(( 8#$(printf "%o\n" $n) ))
|
---|
300 | printf "%u\n" $n
|
---|
301 | #ash# echo $(( 16#$(printf "%x\n" $n) ))
|
---|
302 | #ash# echo $(( 16#$(printf "%X\n" $n) ))
|
---|
303 |
|
---|
304 | # causes longjmp botches through bash-2.05b
|
---|
305 | a[b[c]d]=e
|
---|