blob: 6cca4292651b64012ac71f58ece3feb0ab48198e (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
|
#!/bin/sh
# Build and test all included SubX programs:
# translate them into ELF binaries
# compare the generated binaries with what's already in git
# run/test the ELF binaries in emulated mode (unless $NO_EMULATION)
# run/test the ELF binaries in native mode (if on Linux)
#
# Example usage:
# test_apps # compare generated binaries, run them in emulated and native mode
# test_apps record # run binaries in emulated and native mode
# NO_EMULATION=1 test_apps # compare generated binaries, run them in native mode
# NO_EMULATION=1 test_apps record # run binaries just in native mode
set -e
cd `dirname $0`
test $NO_EMULATION || EMULATED=1
test $EMULATED && echo 'testing emulated runs'
test `uname` = 'Linux' && NATIVE=1
test $NATIVE && echo 'testing native runs'
./build
export OS=${OS:-linux}
echo "== translating and running using C++"
# example programs
echo ex1
./bootstrap translate init.$OS apps/ex1.subx -o apps/ex1
test "$1" = 'record' || git diff --exit-code apps/ex1
test $EMULATED && {
./bootstrap run apps/ex1 || ret=$?
test $ret -eq 42 # life, the universe and everything
}
test $NATIVE && {
apps/ex1 || ret=$?
test $ret -eq 42 # life, the universe and everything
}
echo ex2
./bootstrap translate init.$OS apps/ex2.subx -o apps/ex2
test "$1" = 'record' || git diff --exit-code apps/ex2
test $EMULATED && {
./bootstrap run apps/ex2 || ret=$?
test $ret -eq 2 # 1 + 1
}
test $NATIVE && {
apps/ex2 || ret=$?
test $ret -eq 2 # 1 + 1
}
echo ex3
./bootstrap translate init.$OS apps/ex3.subx -o apps/ex3
test "$1" = 'record' || git diff --exit-code apps/ex3
test $EMULATED && {
./bootstrap run apps/ex3 || ret=$?
test $ret -eq 55 # 1 + 2 + ... + 10
}
test $NATIVE && {
apps/ex3 || ret=$?
test $ret -eq 55 # 1 + 2 + ... + 10
}
echo ex4
./bootstrap translate init.$OS apps/ex4.subx -o apps/ex4
test "$1" = 'record' || git diff --exit-code apps/ex4
test $EMULATED && {
echo a | ./bootstrap run apps/ex4 >ex4.out || true
test `cat ex4.out` = 'a'
}
test $NATIVE && {
echo a | apps/ex4 >ex4.out || true
test `cat ex4.out` = 'a'
}
echo ex5
./bootstrap translate init.$OS apps/ex5.subx -o apps/ex5
test "$1" = 'record' || git diff --exit-code apps/ex5
test $EMULATED && {
echo a | ./bootstrap run apps/ex5 >ex5.out || true
test `cat ex5.out` = 'a'
}
test $NATIVE && {
echo a | apps/ex5 >ex5.out || true
test `cat ex5.out` = 'a'
}
echo ex6
./bootstrap translate init.$OS apps/ex6.subx -o apps/ex6
test "$1" = 'record' || git diff --exit-code apps/ex6
test $EMULATED && {
./bootstrap run apps/ex6 >ex6.out || true
test "`cat ex6.out`" = 'Hello, world!'
}
test $NATIVE && {
apps/ex6 >ex6.out || true
test "`cat ex6.out`" = 'Hello, world!'
}
echo ex7
./bootstrap translate init.$OS apps/ex7.subx -o apps/ex7
test "$1" = 'record' || git diff --exit-code apps/ex7
test $EMULATED && {
./bootstrap run apps/ex7 || ret=$?
test $ret -eq 97 # 'a'
}
test $NATIVE && {
apps/ex7 || ret=$?
test $ret -eq 97 # 'a'
}
echo ex8
./bootstrap translate init.$OS apps/ex8.subx -o apps/ex8
test "$1" = 'record' || git diff --exit-code apps/ex8
test $EMULATED && {
./bootstrap run apps/ex8 abcd || ret=$?
test $ret -eq 4 # length('abcd')
}
test $NATIVE && {
apps/ex8 abcd || ret=$?
test $ret -eq 4 # length('abcd')
}
echo ex9
./bootstrap translate init.$OS apps/ex9.subx -o apps/ex9
test "$1" = 'record' || git diff --exit-code apps/ex9
test $EMULATED && {
./bootstrap run apps/ex9 z x || ret=$?
test $ret -eq 2 # 'z' - 'x'
}
test $NATIVE && {
apps/ex9 z x || ret=$?
test $ret -eq 2 # 'z' - 'x'
}
echo ex10
./bootstrap translate init.$OS apps/ex10.subx -o apps/ex10
test "$1" = 'record' || git diff --exit-code apps/ex10
test $EMULATED && {
./bootstrap run apps/ex10 abc abc || ret=$?
test $ret -eq 1 # equal
./bootstrap run apps/ex10 abc abcd # 0; not equal
}
test $NATIVE && {
apps/ex10 abc abc || ret=$?
test $ret -eq 1 # equal
apps/ex10 abc abcd # 0; not equal
}
echo ex11
./bootstrap translate init.$OS apps/ex11.subx -o apps/ex11
test "$1" = 'record' || git diff --exit-code apps/ex11
test $EMULATED && {
./bootstrap run apps/ex11
echo
}
test $NATIVE && {
apps/ex11
echo
}
echo ex12
./bootstrap translate init.$OS apps/ex12.subx -o apps/ex12
test "$1" = 'record' || git diff --exit-code apps/ex12
test $EMULATED && ./bootstrap run apps/ex12 # final byte of mmap'd address is well-nigh guaranteed to be 0
test $NATIVE && apps/ex12
echo ex13
./bootstrap translate init.$OS apps/ex13.subx -o apps/ex13
test "$1" = 'record' || git diff --exit-code apps/ex13
test $EMULATED && {
./bootstrap run apps/ex13 || ret=$?
test $ret -eq 1 # 3 == 3
}
test $NATIVE && {
apps/ex13 || ret=$?
test $ret -eq 1 # 3 == 3
}
# Larger apps that use the standard library.
echo factorial
./bootstrap translate init.$OS 0[0-8]*.subx apps/factorial.subx -o apps/factorial
test "$1" = 'record' || git diff --exit-code apps/factorial
test $EMULATED && {
./bootstrap run apps/factorial || ret=$?
test $ret -eq 120 # factorial(5)
./bootstrap run apps/factorial test
echo
}
test $NATIVE && {
apps/factorial || ret=$?
test $ret -eq 120 # factorial(5)
apps/factorial test
echo
}
echo crenshaw2-1
./bootstrap translate init.$OS 0[0-8]*.subx apps/crenshaw2-1.subx -o apps/crenshaw2-1
test "$1" = 'record' || git diff --exit-code apps/crenshaw2-1
test $EMULATED && {
./bootstrap run apps/crenshaw2-1 test
echo
}
test $NATIVE && {
apps/crenshaw2-1 test
echo
}
echo crenshaw2-1b
./bootstrap translate init.$OS 0[0-8]*.subx apps/crenshaw2-1b.subx -o apps/crenshaw2-1b
test "$1" = 'record' || git diff --exit-code apps/crenshaw2-1b
test $EMULATED && {
./bootstrap run apps/crenshaw2-1b test
echo
}
test $NATIVE && {
apps/crenshaw2-1b test
echo
}
# Phases of the self-hosted SubX translator.
for phase in hex survey pack assort dquotes tests
do
echo $phase
./bootstrap translate init.$OS 0[0-8]*.subx apps/subx-params.subx apps/$phase.subx -o apps/$phase
test "$1" = 'record' || git diff --exit-code apps/$phase
test $EMULATED && {
./bootstrap run apps/$phase test
echo
}
test $NATIVE && {
apps/$phase test
echo
}
done
# Higher-level syntax.
# Certain phases of translation run native beyond this point. We're starting
# to go beyond functionality of the C++ bootstrap.
echo sigils
./bootstrap translate init.$OS 0*.subx apps/subx-params.subx apps/sigils.subx -o apps/sigils
[ "$1" != record ] && git diff --exit-code apps/sigils
test $EMULATED && {
./bootstrap run apps/sigils test
echo
}
test `uname` = 'Linux' && {
apps/sigils test
echo
}
test $NATIVE || { echo 'there are more tests, but you need Linux to run them'; exit 0; }
echo calls
cat init.$OS 0*.subx apps/subx-params.subx apps/calls.subx | apps/sigils > a.sigils
./bootstrap translate a.sigils -o apps/calls
[ "$1" != record ] && git diff --exit-code apps/calls
test $EMULATED && {
./bootstrap run apps/calls test
echo
}
test `uname` = 'Linux' && {
apps/calls test
echo
}
echo braces
cat init.$OS 0*.subx apps/subx-params.subx apps/braces.subx | apps/calls | apps/sigils > a.sigils
./bootstrap translate a.sigils -o apps/braces
[ "$1" != record ] && git diff --exit-code apps/braces
test $EMULATED && {
./bootstrap run apps/braces test
echo
}
test `uname` = 'Linux' && {
apps/braces test
echo
}
echo mu
cat init.$OS [0-9]*.subx apps/mu.subx | apps/braces | apps/calls | apps/sigils > a.sigils
./bootstrap translate a.sigils -o apps/mu
[ "$1" != record ] && git diff --exit-code apps/mu
test $EMULATED && {
./bootstrap run apps/mu test
echo
}
test `uname` = 'Linux' && {
apps/mu test
echo
}
test $NATIVE || exit 0
echo "== translating using SubX (native only)"
# example programs
for n in `seq 1 12`
do
echo ex$n
./translate_subx init.$OS apps/ex$n.subx
diff apps/ex$n a.elf
done
# Larger apps that use the standard library.
for app in factorial crenshaw2-1 crenshaw2-1b
do
echo $app
./translate_subx init.$OS 0[0-8]*.subx apps/$app.subx
diff apps/$app a.elf
done
# Phases of the self-hosted SubX translator.
for app in hex survey pack assort dquotes tests
do
echo $app
./translate_subx init.$OS 0[0-8]*.subx apps/subx-params.subx apps/$app.subx
diff apps/$app a.elf
done
for app in sigils calls braces
do
echo $app
./translate_subx init.$OS 0*.subx apps/subx-params.subx apps/$app.subx
diff apps/$app a.elf
done
#? # Mu translator
#? echo mu
#? ./translate_subx init.$OS [0-9]*.subx apps/mu.subx
#? diff apps/mu a.elf
exit 0
|