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