1	#!/usr/bin/env bash
2	#
3	# Interesting interpretation of constants.
4	#
5	# "Constants with a leading 0 are interpreted as octal numbers. A leading ‘0x’
6	# or ‘0X’ denotes hexadecimal. Otherwise, numbers take the form [base#]n, where
7	# the optional base is a decimal number between 2 and 64 representing the
8	# arithmetic base, and n is a number in that base. If base# is omitted, then
9	# base 10 is used. When specifying n, the digits greater than 9 are represented
10	# by the lowercase letters, the uppercase letters, ‘@’, and ‘_’, in that order.
11	# If base is less than or equal to 36, lowercase and uppercase letters may be
12	# used interchangeably to represent numbers between 10 and 35. "
13	#
14	# NOTE $(( 8#9 )) can fail, and this can be done at parse time...
15
16	### Side Effect in Array Indexing
17	a=(4 5 6)
18	echo "${a[b=2]} b=$b"
19	# stdout: 6 b=2
20	# OK zsh stdout: 5 b=2
21	# N-I dash stdout-json: ""
22	# N-I dash status: 2
23
24	### Add one to var
25	i=1
26	echo $(($i+1))
27	# stdout: 2
28
29	### $ is optional
30	i=1
31	echo $((i+1))
32	# stdout: 2
33
34	### SimpleVarSub within arith
35	echo $(($j + 1))
36	# stdout: 1
37
38	### BracedVarSub within ArithSub
39	echo $((${j:-5} + 1))
40	# stdout: 6
41
42	### Arith word part
43	foo=1; echo $((foo+1))bar$(($foo+1))
44	# stdout: 2bar2
45
46	### Arith sub with word parts
47	# Making 13 from two different kinds of sub. Geez.
48	echo $((1 + $(echo 1)${undefined:-3}))
49	# stdout: 14
50
51	### Constant with quotes like '1'
52	# NOTE: Compare with [[. That is a COMMAND level expression, while this is a
53	# WORD level expression.
54	echo $(('1' + 2))
55	# status: 0
56	# N-I bash/zsh status: 1
57	# N-I dash status: 2
58
59	### Arith sub within arith sub
60	# This is unnecessary but works in all shells.
61	echo $((1 + $((2 + 3)) + 4))
62	# stdout: 10
63
64	### Backticks within arith sub
65	# This is unnecessary but works in all shells.
66	echo $((`echo 1` + 2))
67	# stdout: 3
68
69	### Invalid string to int
70	# bash, mksh, and zsh all treat strings that don't look like numbers as zero.
71	s=foo
72	echo $((s+5))
73	# OK dash stdout-json: ""
74	# OK dash status: 2
75	# OK bash/mksh/zsh/osh stdout: 5
76	# OK bash/mksh/zsh/osh status: 0
77
78	### Invalid string to int with strict-arith
79	set -o strict-arith || true
80	s=foo
81	echo $s
82	echo $((s+5))
83	# status: 1
84	# stdout-json: "foo\n"
85	# N-I bash status: 0
86	# N-I bash stdout-json: "foo\n5\n"
87	# N-I dash status: 2
88	# N-I dash stdout-json: ""
89	# N-I mksh status: 1
90	# N-I mksh stdout-json: ""
91	# N-I zsh status: 1
92	# N-I zsh stdout-json: ""
93
94	### Newline in the middle of expression
95	echo $((1
96	+ 2))
97	# stdout: 3
98
99	### Ternary operator
100	a=1
101	b=2
102	echo $((a>b?5:10))
103	# stdout: 10
104
105	### Preincrement
106	a=4
107	echo $((++a))
108	echo $a
109	# stdout-json: "5\n5\n"
110	# N-I dash status: 0
111	# N-I dash stdout-json: "4\n4\n"
112
113	### Postincrement
114	a=4
115	echo $((a++))
116	echo $a
117	# stdout-json: "4\n5\n"
118	# N-I dash status: 2
119	# N-I dash stdout-json: ""
120
121	### Increment undefined variables
122	(( undef1++ ))
123	(( ++undef2 ))
124	echo "[$undef1][$undef2]"
125	# stdout: [1][1]
126	# N-I dash stdout-json: "[][]\n"
127
128	### Increment and decrement array
129	a=(5 6 7 8)
130	(( a[0]++, ++a[1], a[2]--, --a[3] ))
131	(( undef[0]++, ++undef[1], undef[2]--, --undef[3] ))
132	echo "${a[@]}" - "${undef[@]}"
133	# stdout: 6 7 6 7 - 1 1 -1 -1
134	# N-I dash stdout-json: ""
135	# N-I dash status: 2
136	# BUG zsh stdout: 5 6 7 8 -
137
138	### Increment undefined variables with nounset
139	set -o nounset
140	(( undef1++ ))
141	(( ++undef2 ))
142	echo "[$undef1][$undef2]"
143	# stdout-json: ""
144	# status: 1
145	# OK dash status: 2
146	# BUG mksh/zsh status: 0
147	# BUG mksh/zsh stdout-json: "[1][1]\n"
148
149	### Comma operator (borrowed from C)
150	a=1
151	b=2
152	echo $((a,(b+1)))
153	# stdout: 3
154	# N-I dash status: 2
155	# N-I dash stdout-json: ""
156
157	### Augmented assignment
158	a=4
159	echo $((a+=1))
160	echo $a
161	# stdout-json: "5\n5\n"
162
163	### Comparison Ops
164	echo $(( 1 == 1 ))
165	echo $(( 1 != 1 ))
166	echo $(( 1 < 1 ))
167	echo $(( 1 <= 1 ))
168	echo $(( 1 > 1 ))
169	echo $(( 1 >= 1 ))
170	# stdout-json: "1\n0\n0\n1\n0\n1\n"
171
172	### Logical Ops
173	echo $((1 || 2))
174	echo $((1 && 2))
175	echo $((!(1 || 2)))
176	# stdout-json: "1\n1\n0\n"
177
178	### Logical Ops Short Circuit
179	x=11
180	(( 1 || (x = 22) ))
181	echo $x
182	(( 0 || (x = 33) ))
183	echo $x
184	(( 0 && (x = 44) ))
185	echo $x
186	(( 1 && (x = 55) ))
187	echo $x
188	# stdout-json: "11\n33\n33\n55\n"
189	# N-I dash stdout-json: "11\n11\n11\n11\n"
190
191	### Bitwise ops
192	echo $((1|2))
193	echo $((1&2))
194	echo $((1^2))
195	echo $((~(1|2)))
196	# stdout-json: "3\n0\n3\n-4\n"
197
198	### Unary minus and plus
199	a=1
200	b=3
201	echo $((- a + + b))
202	# stdout-json: "2\n"
203
204	### No floating point
205	echo $((1 + 2.3))
206	# status: 2
207	# OK bash/mksh status: 1
208	# BUG zsh status: 0
209
210	### Array indexing in arith
211	# zsh does 1-based indexing!
212	array=(1 2 3 4)
213	echo $((array[1] + array[2]*3))
214	# stdout: 11
215	# OK zsh stdout: 7
216	# N-I dash status: 2
217	# N-I dash stdout-json: ""
218
219	### Constants in base 36
220	echo $((36#a))-$((36#z))
221	# stdout: 10-35
222	# N-I dash stdout-json: ""
223	# N-I dash status: 2
224
225	### Constants in bases 2 to 64
226	# This is a truly bizarre syntax. Oh it comes from zsh... which allows 36.
227	echo $((64#a))-$((64#z)), $((64#A))-$((64#Z)), $((64#@)), $(( 64#_ ))
228	# stdout: 10-35, 36-61, 62, 63
229	# N-I dash stdout-json: ""
230	# N-I dash status: 2
231	# N-I mksh/zsh stdout-json: ""
232	# N-I mksh/zsh status: 1
233
234	### Dynamic base constants
235	base=16
236	echo $(( ${base}#a ))
237	# stdout: 10
238	# N-I dash stdout-json: ""
239	# N-I dash status: 2
240
241	### Octal constant
242	echo $(( 011 ))
243	# stdout: 9
244	# N-I mksh/zsh stdout: 11
245
246	### Dynamic octal constant
247	zero=0
248	echo $(( ${zero}11 ))
249	# stdout: 9
250	# N-I mksh/zsh stdout: 11
251
252	### Dynamic hex constants
253	zero=0
254	echo $(( ${zero}xAB ))
255	# stdout: 171
256
257	### Dynamic var names - result of runtime parse/eval
258	foo=5
259	x=oo
260	echo $(( foo + f$x + 1 ))
261	# stdout: 11
262
263	### Bizarre recursive name evaluation - result of runtime parse/eval
264	foo=5
265	bar=foo
266	spam=bar
267	eggs=spam
268	echo $((foo+1)) $((bar+1)) $((spam+1)) $((eggs+1))
269	# stdout: 6 6 6 6
270	# N-I dash stdout-json: ""
271	# N-I dash status: 2
272
273	### nounset with arithmetic
274	set -o nounset
275	x=$(( y + 5 ))
276	echo "should not get here: x=${x:-<unset>}"
277	# stdout-json: ""
278	# status: 1
279	# BUG dash/mksh/zsh stdout: should not get here: x=5
280	# BUG dash/mksh/zsh status: 0
281
282	### Integer Overflow
283	set -o nounset
284	echo $(( 999999 * 999999 * 999999 * 999999 ))
285	# stdout: 999996000005999996000001
286	# BUG dash/bash/zsh stdout: -1996229794797103359
287	# BUG mksh stdout: -15640831
288
289	### Invalid LValue
290	a=9
291	(( (a + 2) = 3 ))
292	echo $a
293	# status: 2
294	# stdout-json: ""
295	# OK bash/mksh/zsh stdout: 9
296	# OK bash/mksh/zsh status: 0
297	# dash doesn't implement assignment
298	# N-I dash status: 2
299	# N-I dash stdout-json: ""
300
301	### Invalid LValue that looks like array
302	(( 1[2] = 3 ))
303	echo "status=$?"
304	# status: 2
305	# stdout-json: ""
306	# OK bash stdout: status=1
307	# OK bash status: 0
308	# OK mksh/zsh stdout: status=2
309	# OK mksh/zsh status: 0
310	# N-I dash stdout: status=127
311	# N-I dash status: 0
312
313	### Invalid LValue: two sets of brackets
314	(( a[1][2] = 3 ))
315	echo "status=$?"
316	# shells treat this as a NON-fatal error
317	# status: 2
318	# stdout-json: ""
319	# OK bash stdout: status=1
320	# OK mksh/zsh stdout: status=2
321	# OK bash/mksh/zsh status: 0
322	# dash doesn't implement assignment
323	# N-I dash stdout: status=127
324	# N-I dash status: 0
325
326
327