git.iko.soy/Idris-dev
on master help sign in
Merge pull request #1604 from evanrinehart/bits-rts-bug
bc8fa59Edwin Brady
rts/idris_bitstring.c+217−89
compare with master
unifiedsplit
@@ -1,58 +1,66 @@
1#include "idris_rts.h"
1#include "idris_rts.h"
2
2
3VAL idris_b8CopyForGC(VM *vm, VAL a) {
3VAL idris_b8CopyForGC(VM *vm, VAL a) {
4+ uint8_t A = a->info.bits8;
4 VAL cl = allocate(vm, sizeof(Closure), 1);
5 VAL cl = allocate(vm, sizeof(Closure), 1);
5 SETTY(cl, BITS8);
6 SETTY(cl, BITS8);
6− cl->info.bits8 = a->info.bits8;
7+ cl->info.bits8 = A;
7 return cl;
8 return cl;
8}
9}
9
10
10VAL idris_b16CopyForGC(VM *vm, VAL a) {
11VAL idris_b16CopyForGC(VM *vm, VAL a) {
12+ uint16_t A = a->info.bits16;
11 VAL cl = allocate(vm, sizeof(Closure), 1);
13 VAL cl = allocate(vm, sizeof(Closure), 1);
12 SETTY(cl, BITS16);
14 SETTY(cl, BITS16);
13− cl->info.bits16 = a->info.bits16;
15+ cl->info.bits16 = A;
14 return cl;
16 return cl;
15}
17}
16
18
17VAL idris_b32CopyForGC(VM *vm, VAL a) {
19VAL idris_b32CopyForGC(VM *vm, VAL a) {
20+ uint32_t A = a->info.bits32;
18 VAL cl = allocate(vm, sizeof(Closure), 1);
21 VAL cl = allocate(vm, sizeof(Closure), 1);
19 SETTY(cl, BITS32);
22 SETTY(cl, BITS32);
20− cl->info.bits32 = a->info.bits32;
23+ cl->info.bits32 = A;
21 return cl;
24 return cl;
22}
25}
23
26
24VAL idris_b64CopyForGC(VM *vm, VAL a) {
27VAL idris_b64CopyForGC(VM *vm, VAL a) {
28+ uint64_t A = a->info.bits64;
25 VAL cl = allocate(vm, sizeof(Closure), 1);
29 VAL cl = allocate(vm, sizeof(Closure), 1);
26 SETTY(cl, BITS64);
30 SETTY(cl, BITS64);
27− cl->info.bits64 = a->info.bits64;
31+ cl->info.bits64 = A;
28 return cl;
32 return cl;
29}
33}
30
34
31VAL idris_b8(VM *vm, VAL a) {
35VAL idris_b8(VM *vm, VAL a) {
36+ uint8_t A = GETINT(a);
32 VAL cl = allocate(vm, sizeof(Closure), 0);
37 VAL cl = allocate(vm, sizeof(Closure), 0);
33 SETTY(cl, BITS8);
38 SETTY(cl, BITS8);
34− cl->info.bits8 = (uint8_t) GETINT(a);
39+ cl->info.bits8 = (uint8_t) A;
35 return cl;
40 return cl;
36}
41}
37
42
38VAL idris_b16(VM *vm, VAL a) {
43VAL idris_b16(VM *vm, VAL a) {
44+ uint16_t A = GETINT(a);
39 VAL cl = allocate(vm, sizeof(Closure), 0);
45 VAL cl = allocate(vm, sizeof(Closure), 0);
40 SETTY(cl, BITS16);
46 SETTY(cl, BITS16);
41− cl->info.bits16 = (uint16_t) GETINT(a);
47+ cl->info.bits16 = (uint16_t) A;
42 return cl;
48 return cl;
43}
49}
44
50
45VAL idris_b32(VM *vm, VAL a) {
51VAL idris_b32(VM *vm, VAL a) {
52+ uint32_t A = GETINT(a);
46 VAL cl = allocate(vm, sizeof(Closure), 0);
53 VAL cl = allocate(vm, sizeof(Closure), 0);
47 SETTY(cl, BITS32);
54 SETTY(cl, BITS32);
48− cl->info.bits32 = (uint32_t) GETINT(a);
55+ cl->info.bits32 = (uint32_t) A;
49 return cl;
56 return cl;
50}
57}
51
58
52VAL idris_b64(VM *vm, VAL a) {
59VAL idris_b64(VM *vm, VAL a) {
60+ uint64_t A = GETINT(a);
53 VAL cl = allocate(vm, sizeof(Closure), 0);
61 VAL cl = allocate(vm, sizeof(Closure), 0);
54 SETTY(cl, BITS64);
62 SETTY(cl, BITS64);
55− cl->info.bits64 = (uint64_t) GETINT(a);
63+ cl->info.bits64 = (uint64_t) A;
56 return cl;
64 return cl;
57}
65}
58
66
@@ -89,51 +97,65 @@ VAL idris_b64const(VM *vm, uint64_t a) {
89}
97}
90
98
91VAL idris_b8Plus(VM *vm, VAL a, VAL b) {
99VAL idris_b8Plus(VM *vm, VAL a, VAL b) {
100+ uint8_t A = a->info.bits8;
101+ uint8_t B = b->info.bits8;
92 VAL cl = allocate(vm, sizeof(Closure), 0);
102 VAL cl = allocate(vm, sizeof(Closure), 0);
93 SETTY(cl, BITS8);
103 SETTY(cl, BITS8);
94− cl->info.bits8 = a->info.bits8 + b->info.bits8;
104+ cl->info.bits8 = A + B;
95 return cl;
105 return cl;
96}
106}
97
107
98VAL idris_b8Minus(VM *vm, VAL a, VAL b) {
108VAL idris_b8Minus(VM *vm, VAL a, VAL b) {
109+ uint8_t A = a->info.bits8;
110+ uint8_t B = b->info.bits8;
99 VAL cl = allocate(vm, sizeof(Closure), 0);
111 VAL cl = allocate(vm, sizeof(Closure), 0);
100 SETTY(cl, BITS8);
112 SETTY(cl, BITS8);
101− cl->info.bits8 = a->info.bits8 - b->info.bits8;
113+ cl->info.bits8 = A - B;
102 return cl;
114 return cl;
103}
115}
104
116
105VAL idris_b8Times(VM *vm, VAL a, VAL b) {
117VAL idris_b8Times(VM *vm, VAL a, VAL b) {
118+ uint8_t A = a->info.bits8;
119+ uint8_t B = b->info.bits8;
106 VAL cl = allocate(vm, sizeof(Closure), 0);
120 VAL cl = allocate(vm, sizeof(Closure), 0);
107 SETTY(cl, BITS8);
121 SETTY(cl, BITS8);
108− cl->info.bits8 = a->info.bits8 * b->info.bits8;
122+ cl->info.bits8 = A * B;
109 return cl;
123 return cl;
110}
124}
111
125
112VAL idris_b8UDiv(VM *vm, VAL a, VAL b) {
126VAL idris_b8UDiv(VM *vm, VAL a, VAL b) {
127+ uint8_t A = a->info.bits8;
128+ uint8_t B = b->info.bits8;
113 VAL cl = allocate(vm, sizeof(Closure), 0);
129 VAL cl = allocate(vm, sizeof(Closure), 0);
114 SETTY(cl, BITS8);
130 SETTY(cl, BITS8);
115− cl->info.bits8 = a->info.bits8 / b->info.bits8;
131+ cl->info.bits8 = A / B;
116 return cl;
132 return cl;
117}
133}
118
134
119VAL idris_b8SDiv(VM *vm, VAL a, VAL b) {
135VAL idris_b8SDiv(VM *vm, VAL a, VAL b) {
136+ uint8_t A = a->info.bits8;
137+ uint8_t B = b->info.bits8;
120 VAL cl = allocate(vm, sizeof(Closure), 0);
138 VAL cl = allocate(vm, sizeof(Closure), 0);
121 SETTY(cl, BITS8);
139 SETTY(cl, BITS8);
122− cl->info.bits8 = (uint8_t) (((int8_t) a->info.bits8) / ((int8_t) b->info.bits8));
140+ cl->info.bits8 = (uint8_t) (((int8_t) A) / ((int8_t) B));
123 return cl;
141 return cl;
124}
142}
125
143
126VAL idris_b8URem(VM *vm, VAL a, VAL b) {
144VAL idris_b8URem(VM *vm, VAL a, VAL b) {
145+ uint8_t A = a->info.bits8;
146+ uint8_t B = b->info.bits8;
127 VAL cl = allocate(vm, sizeof(Closure), 0);
147 VAL cl = allocate(vm, sizeof(Closure), 0);
128 SETTY(cl, BITS8);
148 SETTY(cl, BITS8);
129− cl->info.bits8 = a->info.bits8 % b->info.bits8;
149+ cl->info.bits8 = A % B;
130 return cl;
150 return cl;
131}
151}
132
152
133VAL idris_b8SRem(VM *vm, VAL a, VAL b) {
153VAL idris_b8SRem(VM *vm, VAL a, VAL b) {
154+ uint8_t A = a->info.bits8;
155+ uint8_t B = b->info.bits8;
134 VAL cl = allocate(vm, sizeof(Closure), 0);
156 VAL cl = allocate(vm, sizeof(Closure), 0);
135 SETTY(cl, BITS8);
157 SETTY(cl, BITS8);
136− cl->info.bits8 = (uint8_t) (((int8_t) a->info.bits8) % ((int8_t) b->info.bits8));
158+ cl->info.bits8 = (uint8_t) (((int8_t) A) % ((int8_t) B));
137 return cl;
159 return cl;
138}
160}
139
161
@@ -158,102 +180,127 @@ VAL idris_b8Gte(VM *vm, VAL a, VAL b) {
158}
180}
159
181
160VAL idris_b8Compl(VM *vm, VAL a) {
182VAL idris_b8Compl(VM *vm, VAL a) {
183+ uint8_t A = a->info.bits8;
161 VAL cl = allocate(vm, sizeof(Closure), 0);
184 VAL cl = allocate(vm, sizeof(Closure), 0);
162 SETTY(cl, BITS8);
185 SETTY(cl, BITS8);
163− cl->info.bits8 = ~ a->info.bits8;
186+ cl->info.bits8 = ~ A;
164 return cl;
187 return cl;
165}
188}
166
189
167VAL idris_b8And(VM *vm, VAL a, VAL b) {
190VAL idris_b8And(VM *vm, VAL a, VAL b) {
191+ uint8_t A = a->info.bits8;
192+ uint8_t B = b->info.bits8;
168 VAL cl = allocate(vm, sizeof(Closure), 0);
193 VAL cl = allocate(vm, sizeof(Closure), 0);
169 SETTY(cl, BITS8);
194 SETTY(cl, BITS8);
170− cl->info.bits8 = a->info.bits8 & b->info.bits8;
195+ cl->info.bits8 = A & B;
171 return cl;
196 return cl;
172}
197}
173
198
174VAL idris_b8Or(VM *vm, VAL a, VAL b) {
199VAL idris_b8Or(VM *vm, VAL a, VAL b) {
200+ uint8_t A = a->info.bits8;
201+ uint8_t B = b->info.bits8;
175 VAL cl = allocate(vm, sizeof(Closure), 0);
202 VAL cl = allocate(vm, sizeof(Closure), 0);
176 SETTY(cl, BITS8);
203 SETTY(cl, BITS8);
177− cl->info.bits8 = a->info.bits8 | b->info.bits8;
204+ cl->info.bits8 = A | B;
178 return cl;
205 return cl;
179}
206}
180
207
181VAL idris_b8Xor(VM *vm, VAL a, VAL b) {
208VAL idris_b8Xor(VM *vm, VAL a, VAL b) {
209+ uint8_t A = a->info.bits8;
210+ uint8_t B = b->info.bits8;
182 VAL cl = allocate(vm, sizeof(Closure), 0);
211 VAL cl = allocate(vm, sizeof(Closure), 0);
183 SETTY(cl, BITS8);
212 SETTY(cl, BITS8);
184− cl->info.bits8 = a->info.bits8 ^ b->info.bits8;
213+ cl->info.bits8 = A ^ B;
185 return cl;
214 return cl;
186}
215}
187
216
188VAL idris_b8Shl(VM *vm, VAL a, VAL b) {
217VAL idris_b8Shl(VM *vm, VAL a, VAL b) {
218+ uint8_t A = a->info.bits8;
219+ uint8_t B = b->info.bits8;
189 VAL cl = allocate(vm, sizeof(Closure), 0);
220 VAL cl = allocate(vm, sizeof(Closure), 0);
190 SETTY(cl, BITS8);
221 SETTY(cl, BITS8);
191− cl->info.bits8 = a->info.bits8 << b->info.bits8;
222+ cl->info.bits8 = A << B;
192 return cl;
223 return cl;
193}
224}
194
225
195VAL idris_b8LShr(VM *vm, VAL a, VAL b) {
226VAL idris_b8LShr(VM *vm, VAL a, VAL b) {
227+ uint8_t A = a->info.bits8;
228+ uint8_t B = b->info.bits8;
196 VAL cl = allocate(vm, sizeof(Closure), 0);
229 VAL cl = allocate(vm, sizeof(Closure), 0);
197 SETTY(cl, BITS8);
230 SETTY(cl, BITS8);
198− cl->info.bits8 = a->info.bits8 >> b->info.bits8;
231+ cl->info.bits8 = A >> B;
199 return cl;
232 return cl;
200}
233}
201
234
202VAL idris_b8AShr(VM *vm, VAL a, VAL b) {
235VAL idris_b8AShr(VM *vm, VAL a, VAL b) {
236+ uint8_t A = a->info.bits8;
237+ uint8_t B = b->info.bits8;
203 VAL cl = allocate(vm, sizeof(Closure), 0);
238 VAL cl = allocate(vm, sizeof(Closure), 0);
204 SETTY(cl, BITS8);
239 SETTY(cl, BITS8);
205− cl->info.bits8 = (uint8_t) (((int8_t)a->info.bits8) >> ((int8_t)b->info.bits8));
240+ cl->info.bits8 = (uint8_t) (((int8_t) A) >> ((int8_t) B));
206 return cl;
241 return cl;
207}
242}
208
243
209VAL idris_b16Plus(VM *vm, VAL a, VAL b) {
244VAL idris_b16Plus(VM *vm, VAL a, VAL b) {
245+ uint16_t A = a->info.bits16;
246+ uint16_t B = b->info.bits16;
210 VAL cl = allocate(vm, sizeof(Closure), 0);
247 VAL cl = allocate(vm, sizeof(Closure), 0);
211 SETTY(cl, BITS16);
248 SETTY(cl, BITS16);
212− cl->info.bits16 = a->info.bits16 + b->info.bits16;
249+ cl->info.bits16 = A + B;
213 return cl;
250 return cl;
214}
251}
215
252
216VAL idris_b16Minus(VM *vm, VAL a, VAL b) {
253VAL idris_b16Minus(VM *vm, VAL a, VAL b) {
254+ uint16_t A = a->info.bits16;
255+ uint16_t B = b->info.bits16;
217 VAL cl = allocate(vm, sizeof(Closure), 0);
256 VAL cl = allocate(vm, sizeof(Closure), 0);
218 SETTY(cl, BITS16);
257 SETTY(cl, BITS16);
219− cl->info.bits16 = a->info.bits16 - b->info.bits16;
258+ cl->info.bits16 = A - B;
220 return cl;
259 return cl;
221}
260}
222
261
223VAL idris_b16Times(VM *vm, VAL a, VAL b) {
262VAL idris_b16Times(VM *vm, VAL a, VAL b) {
263+ uint16_t A = a->info.bits16;
264+ uint16_t B = b->info.bits16;
224 VAL cl = allocate(vm, sizeof(Closure), 0);
265 VAL cl = allocate(vm, sizeof(Closure), 0);
225 SETTY(cl, BITS16);
266 SETTY(cl, BITS16);
226− cl->info.bits16 = a->info.bits16 * b->info.bits16;
267+ cl->info.bits16 = A * B;
227 return cl;
268 return cl;
228}
269}
229
270
230VAL idris_b16UDiv(VM *vm, VAL a, VAL b) {
271VAL idris_b16UDiv(VM *vm, VAL a, VAL b) {
272+ uint16_t A = a->info.bits16;
273+ uint16_t B = b->info.bits16;
231 VAL cl = allocate(vm, sizeof(Closure), 0);
274 VAL cl = allocate(vm, sizeof(Closure), 0);
232 SETTY(cl, BITS16);
275 SETTY(cl, BITS16);
233− cl->info.bits16 = a->info.bits16 / b->info.bits16;
276+ cl->info.bits16 = A / B;
234 return cl;
277 return cl;
235}
278}
236
279
237VAL idris_b16SDiv(VM *vm, VAL a, VAL b) {
280VAL idris_b16SDiv(VM *vm, VAL a, VAL b) {
281+ uint16_t A = a->info.bits16;
282+ uint16_t B = b->info.bits16;
238 VAL cl = allocate(vm, sizeof(Closure), 0);
283 VAL cl = allocate(vm, sizeof(Closure), 0);
239 SETTY(cl, BITS16);
284 SETTY(cl, BITS16);
240− cl->info.bits16 =
241− (uint16_t) (((int16_t) a->info.bits16) / ((int16_t) b->info.bits16));
285+ cl->info.bits16 = (uint16_t) (((int16_t) A) / ((int16_t) B));
242 return cl;
286 return cl;
243}
287}
244
288
245VAL idris_b16URem(VM *vm, VAL a, VAL b) {
289VAL idris_b16URem(VM *vm, VAL a, VAL b) {
290+ uint16_t A = a->info.bits16;
291+ uint16_t B = b->info.bits16;
246 VAL cl = allocate(vm, sizeof(Closure), 0);
292 VAL cl = allocate(vm, sizeof(Closure), 0);
247 SETTY(cl, BITS16);
293 SETTY(cl, BITS16);
248− cl->info.bits16 = a->info.bits16 % b->info.bits16;
294+ cl->info.bits16 = A % B;
249 return cl;
295 return cl;
250}
296}
251
297
252VAL idris_b16SRem(VM *vm, VAL a, VAL b) {
298VAL idris_b16SRem(VM *vm, VAL a, VAL b) {
299+ uint16_t A = a->info.bits16;
300+ uint16_t B = b->info.bits16;
253 VAL cl = allocate(vm, sizeof(Closure), 0);
301 VAL cl = allocate(vm, sizeof(Closure), 0);
254 SETTY(cl, BITS16);
302 SETTY(cl, BITS16);
255− cl->info.bits16 =
256− (uint16_t) (((int16_t) a->info.bits16) % ((int16_t) b->info.bits16));
303+ cl->info.bits16 = (uint16_t) (((int16_t) A) % ((int16_t) B));
257 return cl;
304 return cl;
258}
305}
259
306
@@ -278,102 +325,127 @@ VAL idris_b16Gte(VM *vm, VAL a, VAL b) {
278}
325}
279
326
280VAL idris_b16Compl(VM *vm, VAL a) {
327VAL idris_b16Compl(VM *vm, VAL a) {
328+ uint16_t A = a->info.bits16;
281 VAL cl = allocate(vm, sizeof(Closure), 0);
329 VAL cl = allocate(vm, sizeof(Closure), 0);
282 SETTY(cl, BITS16);
330 SETTY(cl, BITS16);
283− cl->info.bits16 = ~ a->info.bits16;
331+ cl->info.bits16 = ~ A;
284 return cl;
332 return cl;
285}
333}
286
334
287VAL idris_b16And(VM *vm, VAL a, VAL b) {
335VAL idris_b16And(VM *vm, VAL a, VAL b) {
336+ uint16_t A = a->info.bits16;
337+ uint16_t B = b->info.bits16;
288 VAL cl = allocate(vm, sizeof(Closure), 0);
338 VAL cl = allocate(vm, sizeof(Closure), 0);
289 SETTY(cl, BITS16);
339 SETTY(cl, BITS16);
290− cl->info.bits16 = a->info.bits16 & b->info.bits16;
340+ cl->info.bits16 = A & B;
291 return cl;
341 return cl;
292}
342}
293
343
294VAL idris_b16Or(VM *vm, VAL a, VAL b) {
344VAL idris_b16Or(VM *vm, VAL a, VAL b) {
345+ uint16_t A = a->info.bits16;
346+ uint16_t B = b->info.bits16;
295 VAL cl = allocate(vm, sizeof(Closure), 0);
347 VAL cl = allocate(vm, sizeof(Closure), 0);
296 SETTY(cl, BITS16);
348 SETTY(cl, BITS16);
297− cl->info.bits16 = a->info.bits16 | b->info.bits16;
349+ cl->info.bits16 = A | B;
298 return cl;
350 return cl;
299}
351}
300
352
301VAL idris_b16Xor(VM *vm, VAL a, VAL b) {
353VAL idris_b16Xor(VM *vm, VAL a, VAL b) {
354+ uint16_t A = a->info.bits16;
355+ uint16_t B = b->info.bits16;
302 VAL cl = allocate(vm, sizeof(Closure), 0);
356 VAL cl = allocate(vm, sizeof(Closure), 0);
303 SETTY(cl, BITS16);
357 SETTY(cl, BITS16);
304− cl->info.bits16 = a->info.bits16 ^ b->info.bits16;
358+ cl->info.bits16 = A ^ B;
305 return cl;
359 return cl;
306}
360}
307
361
308VAL idris_b16Shl(VM *vm, VAL a, VAL b) {
362VAL idris_b16Shl(VM *vm, VAL a, VAL b) {
363+ uint16_t A = a->info.bits16;
364+ uint16_t B = b->info.bits16;
309 VAL cl = allocate(vm, sizeof(Closure), 0);
365 VAL cl = allocate(vm, sizeof(Closure), 0);
310 SETTY(cl, BITS16);
366 SETTY(cl, BITS16);
311− cl->info.bits16 = a->info.bits16 << b->info.bits16;
367+ cl->info.bits16 = A << B;
312 return cl;
368 return cl;
313}
369}
314
370
315VAL idris_b16LShr(VM *vm, VAL a, VAL b) {
371VAL idris_b16LShr(VM *vm, VAL a, VAL b) {
372+ uint16_t A = a->info.bits16;
373+ uint16_t B = b->info.bits16;
316 VAL cl = allocate(vm, sizeof(Closure), 0);
374 VAL cl = allocate(vm, sizeof(Closure), 0);
317 SETTY(cl, BITS16);
375 SETTY(cl, BITS16);
318− cl->info.bits16 = a->info.bits16 >> b->info.bits16;
376+ cl->info.bits16 = A >> B;
319 return cl;
377 return cl;
320}
378}
321
379
322VAL idris_b16AShr(VM *vm, VAL a, VAL b) {
380VAL idris_b16AShr(VM *vm, VAL a, VAL b) {
381+ uint16_t A = a->info.bits16;
382+ uint16_t B = b->info.bits16;
323 VAL cl = allocate(vm, sizeof(Closure), 0);
383 VAL cl = allocate(vm, sizeof(Closure), 0);
324 SETTY(cl, BITS16);
384 SETTY(cl, BITS16);
325− cl->info.bits16 = (uint16_t) (((int16_t)a->info.bits16) >> ((int16_t)b->info.bits16));
385+ cl->info.bits16 = (uint16_t) (((int16_t) A) >> ((int16_t) B));
326 return cl;
386 return cl;
327}
387}
328
388
329VAL idris_b32Plus(VM *vm, VAL a, VAL b) {
389VAL idris_b32Plus(VM *vm, VAL a, VAL b) {
390+ uint32_t A = a->info.bits32;
391+ uint32_t B = b->info.bits32;
330 VAL cl = allocate(vm, sizeof(Closure), 0);
392 VAL cl = allocate(vm, sizeof(Closure), 0);
331 SETTY(cl, BITS32);
393 SETTY(cl, BITS32);
332− cl->info.bits32 = a->info.bits32 + b->info.bits32;
394+ cl->info.bits32 = A + B;
333 return cl;
395 return cl;
334}
396}
335
397
336VAL idris_b32Minus(VM *vm, VAL a, VAL b) {
398VAL idris_b32Minus(VM *vm, VAL a, VAL b) {
399+ uint32_t A = a->info.bits32;
400+ uint32_t B = b->info.bits32;
337 VAL cl = allocate(vm, sizeof(Closure), 0);
401 VAL cl = allocate(vm, sizeof(Closure), 0);
338 SETTY(cl, BITS32);
402 SETTY(cl, BITS32);
339− cl->info.bits32 = a->info.bits32 - b->info.bits32;
403+ cl->info.bits32 = A - B;
340 return cl;
404 return cl;
341}
405}
342
406
343VAL idris_b32Times(VM *vm, VAL a, VAL b) {
407VAL idris_b32Times(VM *vm, VAL a, VAL b) {
408+ uint32_t A = a->info.bits32;
409+ uint32_t B = b->info.bits32;
344 VAL cl = allocate(vm, sizeof(Closure), 0);
410 VAL cl = allocate(vm, sizeof(Closure), 0);
345 SETTY(cl, BITS32);
411 SETTY(cl, BITS32);
346− cl->info.bits32 = a->info.bits32 * b->info.bits32;
412+ cl->info.bits32 = A * B;
347 return cl;
413 return cl;
348}
414}
349
415
350VAL idris_b32UDiv(VM *vm, VAL a, VAL b) {
416VAL idris_b32UDiv(VM *vm, VAL a, VAL b) {
417+ uint32_t A = a->info.bits32;
418+ uint32_t B = b->info.bits32;
351 VAL cl = allocate(vm, sizeof(Closure), 0);
419 VAL cl = allocate(vm, sizeof(Closure), 0);
352 SETTY(cl, BITS32);
420 SETTY(cl, BITS32);
353− cl->info.bits32 = a->info.bits32 / b->info.bits32;
421+ cl->info.bits32 = A / B;
354 return cl;
422 return cl;
355}
423}
356
424
357VAL idris_b32SDiv(VM *vm, VAL a, VAL b) {
425VAL idris_b32SDiv(VM *vm, VAL a, VAL b) {
426+ uint32_t A = a->info.bits32;
427+ uint32_t B = b->info.bits32;
358 VAL cl = allocate(vm, sizeof(Closure), 0);
428 VAL cl = allocate(vm, sizeof(Closure), 0);
359 SETTY(cl, BITS32);
429 SETTY(cl, BITS32);
360− cl->info.bits32 =
361− (uint32_t) (((int32_t) a->info.bits32) / ((int32_t) b->info.bits32));
430+ cl->info.bits32 = (uint32_t) (((int32_t) A) / ((int32_t) B));
362 return cl;
431 return cl;
363}
432}
364
433
365VAL idris_b32URem(VM *vm, VAL a, VAL b) {
434VAL idris_b32URem(VM *vm, VAL a, VAL b) {
435+ uint32_t A = a->info.bits32;
436+ uint32_t B = b->info.bits32;
366 VAL cl = allocate(vm, sizeof(Closure), 0);
437 VAL cl = allocate(vm, sizeof(Closure), 0);
367 SETTY(cl, BITS32);
438 SETTY(cl, BITS32);
368− cl->info.bits32 = a->info.bits32 % b->info.bits32;
439+ cl->info.bits32 = A % B;
369 return cl;
440 return cl;
370}
441}
371
442
372VAL idris_b32SRem(VM *vm, VAL a, VAL b) {
443VAL idris_b32SRem(VM *vm, VAL a, VAL b) {
444+ uint32_t A = a->info.bits32;
445+ uint32_t B = b->info.bits32;
373 VAL cl = allocate(vm, sizeof(Closure), 0);
446 VAL cl = allocate(vm, sizeof(Closure), 0);
374 SETTY(cl, BITS32);
447 SETTY(cl, BITS32);
375− cl->info.bits32 =
376− (uint32_t) (((int32_t) a->info.bits32) % ((int32_t) b->info.bits32));
448+ cl->info.bits32 = (uint32_t) (((int32_t) A) % ((int32_t) B));
377 return cl;
449 return cl;
378}
450}
379
451
@@ -398,102 +470,127 @@ VAL idris_b32Gte(VM *vm, VAL a, VAL b) {
398}
470}
399
471
400VAL idris_b32Compl(VM *vm, VAL a) {
472VAL idris_b32Compl(VM *vm, VAL a) {
473+ uint32_t A = a->info.bits32;
401 VAL cl = allocate(vm, sizeof(Closure), 0);
474 VAL cl = allocate(vm, sizeof(Closure), 0);
402 SETTY(cl, BITS32);
475 SETTY(cl, BITS32);
403− cl->info.bits32 = ~ a->info.bits32;
476+ cl->info.bits32 = ~ A;
404 return cl;
477 return cl;
405}
478}
406
479
407VAL idris_b32And(VM *vm, VAL a, VAL b) {
480VAL idris_b32And(VM *vm, VAL a, VAL b) {
481+ uint32_t A = a->info.bits32;
482+ uint32_t B = b->info.bits32;
408 VAL cl = allocate(vm, sizeof(Closure), 0);
483 VAL cl = allocate(vm, sizeof(Closure), 0);
409 SETTY(cl, BITS32);
484 SETTY(cl, BITS32);
410− cl->info.bits32 = a->info.bits32 & b->info.bits32;
485+ cl->info.bits32 = A & B;
411 return cl;
486 return cl;
412}
487}
413
488
414VAL idris_b32Or(VM *vm, VAL a, VAL b) {
489VAL idris_b32Or(VM *vm, VAL a, VAL b) {
490+ uint32_t A = a->info.bits32;
491+ uint32_t B = b->info.bits32;
415 VAL cl = allocate(vm, sizeof(Closure), 0);
492 VAL cl = allocate(vm, sizeof(Closure), 0);
416 SETTY(cl, BITS32);
493 SETTY(cl, BITS32);
417− cl->info.bits32 = a->info.bits32 | b->info.bits32;
494+ cl->info.bits32 = A | B;
418 return cl;
495 return cl;
419}
496}
420
497
421VAL idris_b32Xor(VM *vm, VAL a, VAL b) {
498VAL idris_b32Xor(VM *vm, VAL a, VAL b) {
499+ uint32_t A = a->info.bits32;
500+ uint32_t B = b->info.bits32;
422 VAL cl = allocate(vm, sizeof(Closure), 0);
501 VAL cl = allocate(vm, sizeof(Closure), 0);
423 SETTY(cl, BITS32);
502 SETTY(cl, BITS32);
424− cl->info.bits32 = a->info.bits32 ^ b->info.bits32;
503+ cl->info.bits32 = A ^ B;
425 return cl;
504 return cl;
426}
505}
427
506
428VAL idris_b32Shl(VM *vm, VAL a, VAL b) {
507VAL idris_b32Shl(VM *vm, VAL a, VAL b) {
508+ uint32_t A = a->info.bits32;
509+ uint32_t B = b->info.bits32;
429 VAL cl = allocate(vm, sizeof(Closure), 0);
510 VAL cl = allocate(vm, sizeof(Closure), 0);
430 SETTY(cl, BITS32);
511 SETTY(cl, BITS32);
431− cl->info.bits32 = a->info.bits32 << b->info.bits32;
512+ cl->info.bits32 = A << B;
432 return cl;
513 return cl;
433}
514}
434
515
435VAL idris_b32LShr(VM *vm, VAL a, VAL b) {
516VAL idris_b32LShr(VM *vm, VAL a, VAL b) {
517+ uint32_t A = a->info.bits32;
518+ uint32_t B = b->info.bits32;
436 VAL cl = allocate(vm, sizeof(Closure), 0);
519 VAL cl = allocate(vm, sizeof(Closure), 0);
437 SETTY(cl, BITS32);
520 SETTY(cl, BITS32);
438− cl->info.bits32 = a->info.bits32 >> b->info.bits32;
521+ cl->info.bits32 = A >> B;
439 return cl;
522 return cl;
440}
523}
441
524
442VAL idris_b32AShr(VM *vm, VAL a, VAL b) {
525VAL idris_b32AShr(VM *vm, VAL a, VAL b) {
526+ uint32_t A = a->info.bits32;
527+ uint32_t B = b->info.bits32;
443 VAL cl = allocate(vm, sizeof(Closure), 0);
528 VAL cl = allocate(vm, sizeof(Closure), 0);
444 SETTY(cl, BITS32);
529 SETTY(cl, BITS32);
445− cl->info.bits32 = (uint32_t) (((int32_t)a->info.bits32) >> ((int32_t)b->info.bits32));
530+ cl->info.bits32 = (uint32_t) (((int32_t)A) >> ((int32_t)B));
446 return cl;
531 return cl;
447}
532}
448
533
449VAL idris_b64Plus(VM *vm, VAL a, VAL b) {
534VAL idris_b64Plus(VM *vm, VAL a, VAL b) {
535+ uint64_t A = a->info.bits64;
536+ uint64_t B = b->info.bits64;
450 VAL cl = allocate(vm, sizeof(Closure), 0);
537 VAL cl = allocate(vm, sizeof(Closure), 0);
451 SETTY(cl, BITS64);
538 SETTY(cl, BITS64);
452− cl->info.bits64 = a->info.bits64 + b->info.bits64;
539+ cl->info.bits64 = A + B;
453 return cl;
540 return cl;
454}
541}
455
542
456VAL idris_b64Minus(VM *vm, VAL a, VAL b) {
543VAL idris_b64Minus(VM *vm, VAL a, VAL b) {
544+ uint64_t A = a->info.bits64;
545+ uint64_t B = b->info.bits64;
457 VAL cl = allocate(vm, sizeof(Closure), 0);
546 VAL cl = allocate(vm, sizeof(Closure), 0);
458 SETTY(cl, BITS64);
547 SETTY(cl, BITS64);
459− cl->info.bits64 = a->info.bits64 - b->info.bits64;
548+ cl->info.bits64 = A - B;
460 return cl;
549 return cl;
461}
550}
462
551
463VAL idris_b64Times(VM *vm, VAL a, VAL b) {
552VAL idris_b64Times(VM *vm, VAL a, VAL b) {
553+ uint64_t A = a->info.bits64;
554+ uint64_t B = b->info.bits64;
464 VAL cl = allocate(vm, sizeof(Closure), 0);
555 VAL cl = allocate(vm, sizeof(Closure), 0);
465 SETTY(cl, BITS64);
556 SETTY(cl, BITS64);
466− cl->info.bits64 = a->info.bits64 * b->info.bits64;
557+ cl->info.bits64 = A * B;
467 return cl;
558 return cl;
468}
559}
469
560
470VAL idris_b64UDiv(VM *vm, VAL a, VAL b) {
561VAL idris_b64UDiv(VM *vm, VAL a, VAL b) {
562+ uint64_t A = a->info.bits64;
563+ uint64_t B = b->info.bits64;
471 VAL cl = allocate(vm, sizeof(Closure), 0);
564 VAL cl = allocate(vm, sizeof(Closure), 0);
472 SETTY(cl, BITS64);
565 SETTY(cl, BITS64);
473− cl->info.bits64 = a->info.bits64 / b->info.bits64;
566+ cl->info.bits64 = A / B;
474 return cl;
567 return cl;
475}
568}
476
569
477VAL idris_b64SDiv(VM *vm, VAL a, VAL b) {
570VAL idris_b64SDiv(VM *vm, VAL a, VAL b) {
571+ uint64_t A = a->info.bits64;
572+ uint64_t B = b->info.bits64;
478 VAL cl = allocate(vm, sizeof(Closure), 0);
573 VAL cl = allocate(vm, sizeof(Closure), 0);
479 SETTY(cl, BITS64);
574 SETTY(cl, BITS64);
480− cl->info.bits64 =
481− (uint64_t) (((int64_t) a->info.bits64) / ((int64_t) b->info.bits64));
575+ cl->info.bits64 = (uint64_t) (((int64_t) A) / ((int64_t) B));
482 return cl;
576 return cl;
483}
577}
484
578
485VAL idris_b64URem(VM *vm, VAL a, VAL b) {
579VAL idris_b64URem(VM *vm, VAL a, VAL b) {
580+ uint64_t A = a->info.bits64;
581+ uint64_t B = b->info.bits64;
486 VAL cl = allocate(vm, sizeof(Closure), 0);
582 VAL cl = allocate(vm, sizeof(Closure), 0);
487 SETTY(cl, BITS64);
583 SETTY(cl, BITS64);
488− cl->info.bits64 = a->info.bits64 % b->info.bits64;
584+ cl->info.bits64 = A % B;
489 return cl;
585 return cl;
490}
586}
491
587
492VAL idris_b64SRem(VM *vm, VAL a, VAL b) {
588VAL idris_b64SRem(VM *vm, VAL a, VAL b) {
589+ uint64_t A = a->info.bits64;
590+ uint64_t B = b->info.bits64;
493 VAL cl = allocate(vm, sizeof(Closure), 0);
591 VAL cl = allocate(vm, sizeof(Closure), 0);
494 SETTY(cl, BITS64);
592 SETTY(cl, BITS64);
495− cl->info.bits64 =
496− (uint64_t) (((int64_t) a->info.bits64) % ((int64_t) b->info.bits64));
593+ cl->info.bits64 = (uint64_t) (((int64_t) A) % ((int64_t) B));
497 return cl;
594 return cl;
498}
595}
499
596
@@ -518,177 +615,208 @@ VAL idris_b64Gte(VM *vm, VAL a, VAL b) {
518}
615}
519
616
520VAL idris_b64Compl(VM *vm, VAL a) {
617VAL idris_b64Compl(VM *vm, VAL a) {
618+ uint64_t A = a->info.bits64;
521 VAL cl = allocate(vm, sizeof(Closure), 0);
619 VAL cl = allocate(vm, sizeof(Closure), 0);
522 SETTY(cl, BITS64);
620 SETTY(cl, BITS64);
523− cl->info.bits64 = ~ a->info.bits64;
621+ cl->info.bits64 = ~ A;
524 return cl;
622 return cl;
525}
623}
526
624
527VAL idris_b64And(VM *vm, VAL a, VAL b) {
625VAL idris_b64And(VM *vm, VAL a, VAL b) {
626+ uint64_t A = a->info.bits64;
627+ uint64_t B = b->info.bits64;
528 VAL cl = allocate(vm, sizeof(Closure), 0);
628 VAL cl = allocate(vm, sizeof(Closure), 0);
529 SETTY(cl, BITS64);
629 SETTY(cl, BITS64);
530− cl->info.bits64 = a->info.bits64 & b->info.bits64;
630+ cl->info.bits64 = A & B;
531 return cl;
631 return cl;
532}
632}
533
633
534VAL idris_b64Or(VM *vm, VAL a, VAL b) {
634VAL idris_b64Or(VM *vm, VAL a, VAL b) {
635+ uint64_t A = a->info.bits64;
636+ uint64_t B = b->info.bits64;
535 VAL cl = allocate(vm, sizeof(Closure), 0);
637 VAL cl = allocate(vm, sizeof(Closure), 0);
536 SETTY(cl, BITS64);
638 SETTY(cl, BITS64);
537− cl->info.bits64 = a->info.bits64 | b->info.bits64;
639+ cl->info.bits64 = A | B;
538 return cl;
640 return cl;
539}
641}
540
642
541VAL idris_b64Xor(VM *vm, VAL a, VAL b) {
643VAL idris_b64Xor(VM *vm, VAL a, VAL b) {
644+ uint64_t A = a->info.bits64;
645+ uint64_t B = b->info.bits64;
542 VAL cl = allocate(vm, sizeof(Closure), 0);
646 VAL cl = allocate(vm, sizeof(Closure), 0);
543 SETTY(cl, BITS64);
647 SETTY(cl, BITS64);
544− cl->info.bits64 = a->info.bits64 ^ b->info.bits64;
648+ cl->info.bits64 = A ^ B;
545 return cl;
649 return cl;
546}
650}
547
651
548VAL idris_b64Shl(VM *vm, VAL a, VAL b) {
652VAL idris_b64Shl(VM *vm, VAL a, VAL b) {
653+ uint64_t A = a->info.bits64;
654+ uint64_t B = b->info.bits64;
549 VAL cl = allocate(vm, sizeof(Closure), 0);
655 VAL cl = allocate(vm, sizeof(Closure), 0);
550 SETTY(cl, BITS64);
656 SETTY(cl, BITS64);
551− cl->info.bits64 = a->info.bits64 << b->info.bits64;
657+ cl->info.bits64 = A << B;
552 return cl;
658 return cl;
553}
659}
554
660
555VAL idris_b64LShr(VM *vm, VAL a, VAL b) {
661VAL idris_b64LShr(VM *vm, VAL a, VAL b) {
662+ uint64_t A = a->info.bits64;
663+ uint64_t B = b->info.bits64;
556 VAL cl = allocate(vm, sizeof(Closure), 0);
664 VAL cl = allocate(vm, sizeof(Closure), 0);
557 SETTY(cl, BITS64);
665 SETTY(cl, BITS64);
558− cl->info.bits64 = a->info.bits64 >> b->info.bits64;
666+ cl->info.bits64 = A >> B;
559 return cl;
667 return cl;
560}
668}
561
669
562VAL idris_b64AShr(VM *vm, VAL a, VAL b) {
670VAL idris_b64AShr(VM *vm, VAL a, VAL b) {
671+ uint64_t A = a->info.bits64;
672+ uint64_t B = b->info.bits64;
563 VAL cl = allocate(vm, sizeof(Closure), 0);
673 VAL cl = allocate(vm, sizeof(Closure), 0);
564 SETTY(cl, BITS64);
674 SETTY(cl, BITS64);
565− cl->info.bits64 = (uint64_t) (((int64_t)a->info.bits64) >> ((int64_t)b->info.bits64));
675+ cl->info.bits64 = (uint64_t) (((int64_t) A) >> ((int64_t) B));
566 return cl;
676 return cl;
567}
677}
568
678
569VAL idris_b8Z16(VM *vm, VAL a) {
679VAL idris_b8Z16(VM *vm, VAL a) {
680+ uint8_t A = a->info.bits8;
570 VAL cl = allocate(vm, sizeof(Closure), 0);
681 VAL cl = allocate(vm, sizeof(Closure), 0);
571 SETTY(cl, BITS16);
682 SETTY(cl, BITS16);
572− cl->info.bits16 = (uint16_t) a->info.bits8;
683+ cl->info.bits16 = (uint16_t) A;
573 return cl;
684 return cl;
574}
685}
575
686
576VAL idris_b8Z32(VM *vm, VAL a) {
687VAL idris_b8Z32(VM *vm, VAL a) {
688+ uint8_t A = a->info.bits8;
577 VAL cl = allocate(vm, sizeof(Closure), 0);
689 VAL cl = allocate(vm, sizeof(Closure), 0);
578 SETTY(cl, BITS32);
690 SETTY(cl, BITS32);
579− cl->info.bits32 = (uint32_t) a->info.bits8;
691+ cl->info.bits32 = (uint32_t) A;
580 return cl;
692 return cl;
581}
693}
582
694
583VAL idris_b8Z64(VM *vm, VAL a) {
695VAL idris_b8Z64(VM *vm, VAL a) {
696+ uint8_t A = a->info.bits8;
584 VAL cl = allocate(vm, sizeof(Closure), 0);
697 VAL cl = allocate(vm, sizeof(Closure), 0);
585− SETTY(cl, BITS16);
698+ SETTY(cl, BITS64);
586− cl->info.bits64 = (uint64_t) a->info.bits8;
699+ cl->info.bits64 = (uint64_t) A;
587 return cl;
700 return cl;
588}
701}
589
702
590VAL idris_b8S16(VM *vm, VAL a) {
703VAL idris_b8S16(VM *vm, VAL a) {
704+ uint8_t A = a->info.bits8;
591 VAL cl = allocate(vm, sizeof(Closure), 0);
705 VAL cl = allocate(vm, sizeof(Closure), 0);
592 SETTY(cl, BITS16);
706 SETTY(cl, BITS16);
593− cl->info.bits16 = (uint16_t) (int16_t) (int8_t) a->info.bits8;
707+ cl->info.bits16 = (uint16_t) (int16_t) (int8_t) A;
594 return cl;
708 return cl;
595}
709}
596
710
597VAL idris_b8S32(VM *vm, VAL a) {
711VAL idris_b8S32(VM *vm, VAL a) {
712+ uint8_t A = a->info.bits8;
598 VAL cl = allocate(vm, sizeof(Closure), 0);
713 VAL cl = allocate(vm, sizeof(Closure), 0);
599 SETTY(cl, BITS32);
714 SETTY(cl, BITS32);
600− cl->info.bits32 = (uint32_t) (int32_t) (int8_t) a->info.bits8;
715+ cl->info.bits32 = (uint32_t) (int32_t) (int8_t) A;
601 return cl;
716 return cl;
602}
717}
603
718
604VAL idris_b8S64(VM *vm, VAL a) {
719VAL idris_b8S64(VM *vm, VAL a) {
720+ uint8_t A = a->info.bits8;
605 VAL cl = allocate(vm, sizeof(Closure), 0);
721 VAL cl = allocate(vm, sizeof(Closure), 0);
606 SETTY(cl, BITS64);
722 SETTY(cl, BITS64);
607− cl->info.bits64 = (uint64_t) (int64_t) (int8_t) a->info.bits8;
723+ cl->info.bits64 = (uint64_t) (int64_t) (int8_t) A;
608 return cl;
724 return cl;
609}
725}
610
726
611VAL idris_b16Z32(VM *vm, VAL a) {
727VAL idris_b16Z32(VM *vm, VAL a) {
728+ uint16_t A = a->info.bits16;
612 VAL cl = allocate(vm, sizeof(Closure), 0);
729 VAL cl = allocate(vm, sizeof(Closure), 0);
613 SETTY(cl, BITS32);
730 SETTY(cl, BITS32);
614− cl->info.bits32 = (uint32_t) a->info.bits16;
731+ cl->info.bits32 = (uint32_t) A;
615 return cl;
732 return cl;
616}
733}
617
734
618VAL idris_b16Z64(VM *vm, VAL a) {
735VAL idris_b16Z64(VM *vm, VAL a) {
736+ uint16_t A = a->info.bits16;
619 VAL cl = allocate(vm, sizeof(Closure), 0);
737 VAL cl = allocate(vm, sizeof(Closure), 0);
620 SETTY(cl, BITS64);
738 SETTY(cl, BITS64);
621− cl->info.bits64 = (uint64_t) a->info.bits16;
739+ cl->info.bits64 = (uint64_t) A;
622 return cl;
740 return cl;
623}
741}
624
742
625VAL idris_b16S32(VM *vm, VAL a) {
743VAL idris_b16S32(VM *vm, VAL a) {
744+ uint16_t A = a->info.bits16;
626 VAL cl = allocate(vm, sizeof(Closure), 0);
745 VAL cl = allocate(vm, sizeof(Closure), 0);
627 SETTY(cl, BITS32);
746 SETTY(cl, BITS32);
628− cl->info.bits32 = (uint32_t) (int32_t) (int16_t) a->info.bits16;
747+ cl->info.bits32 = (uint32_t) (int32_t) (int16_t) A;
629 return cl;
748 return cl;
630}
749}
631
750
632VAL idris_b16S64(VM *vm, VAL a) {
751VAL idris_b16S64(VM *vm, VAL a) {
752+ uint16_t A = a->info.bits16;
633 VAL cl = allocate(vm, sizeof(Closure), 0);
753 VAL cl = allocate(vm, sizeof(Closure), 0);
634 SETTY(cl, BITS64);
754 SETTY(cl, BITS64);
635− cl->info.bits64 = (uint64_t) (int64_t) (int16_t) a->info.bits16;
755+ cl->info.bits64 = (uint64_t) (int64_t) (int16_t) A;
636 return cl;
756 return cl;
637}
757}
638
758
639VAL idris_b16T8(VM *vm, VAL a) {
759VAL idris_b16T8(VM *vm, VAL a) {
760+ uint16_t A = a->info.bits16;
640 VAL cl = allocate(vm, sizeof(Closure), 0);
761 VAL cl = allocate(vm, sizeof(Closure), 0);
641 SETTY(cl, BITS8);
762 SETTY(cl, BITS8);
642− cl->info.bits8 = (uint8_t) a->info.bits16;
763+ cl->info.bits8 = (uint8_t) A;
643 return cl;
764 return cl;
644}
765}
645
766
646VAL idris_b32Z64(VM *vm, VAL a) {
767VAL idris_b32Z64(VM *vm, VAL a) {
768+ uint32_t A = a->info.bits32;
647 VAL cl = allocate(vm, sizeof(Closure), 0);
769 VAL cl = allocate(vm, sizeof(Closure), 0);
648 SETTY(cl, BITS64);
770 SETTY(cl, BITS64);
649− cl->info.bits64 = (uint64_t) a->info.bits32;
771+ cl->info.bits64 = (uint64_t) A;
650 return cl;
772 return cl;
651}
773}
652
774
653VAL idris_b32S64(VM *vm, VAL a) {
775VAL idris_b32S64(VM *vm, VAL a) {
776+ uint32_t A = a->info.bits32;
654 VAL cl = allocate(vm, sizeof(Closure), 0);
777 VAL cl = allocate(vm, sizeof(Closure), 0);
655 SETTY(cl, BITS64);
778 SETTY(cl, BITS64);
656− cl->info.bits64 = (uint64_t) (int64_t) (int32_t) a->info.bits32;
779+ cl->info.bits64 = (uint64_t) (int64_t) (int32_t) A;
657 return cl;
780 return cl;
658}
781}
659
782
660VAL idris_b32T8(VM *vm, VAL a) {
783VAL idris_b32T8(VM *vm, VAL a) {
784+ uint32_t A = a->info.bits32;
661 VAL cl = allocate(vm, sizeof(Closure), 0);
785 VAL cl = allocate(vm, sizeof(Closure), 0);
662 SETTY(cl, BITS8);
786 SETTY(cl, BITS8);
663− cl->info.bits8 = (uint8_t) a->info.bits32;
787+ cl->info.bits8 = (uint8_t) A;
664 return cl;
788 return cl;
665}
789}
666
790
667VAL idris_b32T16(VM *vm, VAL a) {
791VAL idris_b32T16(VM *vm, VAL a) {
792+ uint32_t A = a->info.bits32;
668 VAL cl = allocate(vm, sizeof(Closure), 0);
793 VAL cl = allocate(vm, sizeof(Closure), 0);
669 SETTY(cl, BITS16);
794 SETTY(cl, BITS16);
670− cl->info.bits16 = (uint16_t) a->info.bits32;
795+ cl->info.bits16 = (uint16_t) A;
671 return cl;
796 return cl;
672}
797}
673
798
674VAL idris_b64T8(VM *vm, VAL a) {
799VAL idris_b64T8(VM *vm, VAL a) {
800+ uint64_t A = a->info.bits64;
675 VAL cl = allocate(vm, sizeof(Closure), 0);
801 VAL cl = allocate(vm, sizeof(Closure), 0);
676 SETTY(cl, BITS8);
802 SETTY(cl, BITS8);
677− cl->info.bits8 = (uint8_t) a->info.bits64;
803+ cl->info.bits8 = (uint8_t) A;
678 return cl;
804 return cl;
679}
805}
680
806
681VAL idris_b64T16(VM *vm, VAL a) {
807VAL idris_b64T16(VM *vm, VAL a) {
808+ uint64_t A = a->info.bits64;
682 VAL cl = allocate(vm, sizeof(Closure), 0);
809 VAL cl = allocate(vm, sizeof(Closure), 0);
683 SETTY(cl, BITS16);
810 SETTY(cl, BITS16);
684− cl->info.bits16 = (uint16_t) a->info.bits64;
811+ cl->info.bits16 = (uint16_t) A;
685 return cl;
812 return cl;
686}
813}
687
814
688VAL idris_b64T32(VM *vm, VAL a) {
815VAL idris_b64T32(VM *vm, VAL a) {
816+ uint64_t A = a->info.bits64;
689 VAL cl = allocate(vm, sizeof(Closure), 0);
817 VAL cl = allocate(vm, sizeof(Closure), 0);
690 SETTY(cl, BITS32);
818 SETTY(cl, BITS32);
691− cl->info.bits32 = (uint32_t) a->info.bits64;
819+ cl->info.bits32 = (uint32_t) A;
692 return cl;
820 return cl;
693}
821}
694
822