git.iko.soy/Idris-dev
on master help sign in
fix to some "obvious" bugs in BitsN primops
6184856EvanR
rts/idris_bitstring.c+79−79
compare with master
unifiedsplit
@@ -3,28 +3,28 @@
3VAL idris_b8CopyForGC(VM *vm, VAL a) {
3VAL idris_b8CopyForGC(VM *vm, VAL a) {
4 VAL cl = allocate(vm, sizeof(Closure), 1);
4 VAL cl = allocate(vm, sizeof(Closure), 1);
5 SETTY(cl, BITS8);
5 SETTY(cl, BITS8);
6− cl->info.bits8 = a->info.bits8;
6+ cl->info.bits8 = GETBITS8(a);
7 return cl;
7 return cl;
8}
8}
9
9
10VAL idris_b16CopyForGC(VM *vm, VAL a) {
10VAL idris_b16CopyForGC(VM *vm, VAL a) {
11 VAL cl = allocate(vm, sizeof(Closure), 1);
11 VAL cl = allocate(vm, sizeof(Closure), 1);
12 SETTY(cl, BITS16);
12 SETTY(cl, BITS16);
13− cl->info.bits16 = a->info.bits16;
13+ cl->info.bits16 = GETBITS16(a);
14 return cl;
14 return cl;
15}
15}
16
16
17VAL idris_b32CopyForGC(VM *vm, VAL a) {
17VAL idris_b32CopyForGC(VM *vm, VAL a) {
18 VAL cl = allocate(vm, sizeof(Closure), 1);
18 VAL cl = allocate(vm, sizeof(Closure), 1);
19 SETTY(cl, BITS32);
19 SETTY(cl, BITS32);
20− cl->info.bits32 = a->info.bits32;
20+ cl->info.bits32 = GETBITS32(a);
21 return cl;
21 return cl;
22}
22}
23
23
24VAL idris_b64CopyForGC(VM *vm, VAL a) {
24VAL idris_b64CopyForGC(VM *vm, VAL a) {
25 VAL cl = allocate(vm, sizeof(Closure), 1);
25 VAL cl = allocate(vm, sizeof(Closure), 1);
26 SETTY(cl, BITS64);
26 SETTY(cl, BITS64);
27− cl->info.bits64 = a->info.bits64;
27+ cl->info.bits64 = GETBITS64(a);
28 return cl;
28 return cl;
29}
29}
30
30
@@ -91,49 +91,49 @@ VAL idris_b64const(VM *vm, uint64_t a) {
91VAL idris_b8Plus(VM *vm, VAL a, VAL b) {
91VAL idris_b8Plus(VM *vm, VAL a, VAL b) {
92 VAL cl = allocate(vm, sizeof(Closure), 0);
92 VAL cl = allocate(vm, sizeof(Closure), 0);
93 SETTY(cl, BITS8);
93 SETTY(cl, BITS8);
94− cl->info.bits8 = a->info.bits8 + b->info.bits8;
94+ cl->info.bits8 = GETBITS8(a) + GETBITS8(b);
95 return cl;
95 return cl;
96}
96}
97
97
98VAL idris_b8Minus(VM *vm, VAL a, VAL b) {
98VAL idris_b8Minus(VM *vm, VAL a, VAL b) {
99 VAL cl = allocate(vm, sizeof(Closure), 0);
99 VAL cl = allocate(vm, sizeof(Closure), 0);
100 SETTY(cl, BITS8);
100 SETTY(cl, BITS8);
101− cl->info.bits8 = a->info.bits8 - b->info.bits8;
101+ cl->info.bits8 = GETBITS8(a) - GETBITS8(b);
102 return cl;
102 return cl;
103}
103}
104
104
105VAL idris_b8Times(VM *vm, VAL a, VAL b) {
105VAL idris_b8Times(VM *vm, VAL a, VAL b) {
106 VAL cl = allocate(vm, sizeof(Closure), 0);
106 VAL cl = allocate(vm, sizeof(Closure), 0);
107 SETTY(cl, BITS8);
107 SETTY(cl, BITS8);
108− cl->info.bits8 = a->info.bits8 * b->info.bits8;
108+ cl->info.bits8 = GETBITS8(a) * GETBITS8(b);
109 return cl;
109 return cl;
110}
110}
111
111
112VAL idris_b8UDiv(VM *vm, VAL a, VAL b) {
112VAL idris_b8UDiv(VM *vm, VAL a, VAL b) {
113 VAL cl = allocate(vm, sizeof(Closure), 0);
113 VAL cl = allocate(vm, sizeof(Closure), 0);
114 SETTY(cl, BITS8);
114 SETTY(cl, BITS8);
115− cl->info.bits8 = a->info.bits8 / b->info.bits8;
115+ cl->info.bits8 = GETBITS8(a) / GETBITS8(b);
116 return cl;
116 return cl;
117}
117}
118
118
119VAL idris_b8SDiv(VM *vm, VAL a, VAL b) {
119VAL idris_b8SDiv(VM *vm, VAL a, VAL b) {
120 VAL cl = allocate(vm, sizeof(Closure), 0);
120 VAL cl = allocate(vm, sizeof(Closure), 0);
121 SETTY(cl, BITS8);
121 SETTY(cl, BITS8);
122− cl->info.bits8 = (uint8_t) (((int8_t) a->info.bits8) / ((int8_t) b->info.bits8));
122+ cl->info.bits8 = (uint8_t) (((int8_t) GETBITS8(a)) / ((int8_t) GETBITS8(b)));
123 return cl;
123 return cl;
124}
124}
125
125
126VAL idris_b8URem(VM *vm, VAL a, VAL b) {
126VAL idris_b8URem(VM *vm, VAL a, VAL b) {
127 VAL cl = allocate(vm, sizeof(Closure), 0);
127 VAL cl = allocate(vm, sizeof(Closure), 0);
128 SETTY(cl, BITS8);
128 SETTY(cl, BITS8);
129− cl->info.bits8 = a->info.bits8 % b->info.bits8;
129+ cl->info.bits8 = GETBITS8(a) % GETBITS8(b);
130 return cl;
130 return cl;
131}
131}
132
132
133VAL idris_b8SRem(VM *vm, VAL a, VAL b) {
133VAL idris_b8SRem(VM *vm, VAL a, VAL b) {
134 VAL cl = allocate(vm, sizeof(Closure), 0);
134 VAL cl = allocate(vm, sizeof(Closure), 0);
135 SETTY(cl, BITS8);
135 SETTY(cl, BITS8);
136− cl->info.bits8 = (uint8_t) (((int8_t) a->info.bits8) % ((int8_t) b->info.bits8));
136+ cl->info.bits8 = (uint8_t) (((int8_t) GETBITS8(a)) % ((int8_t) GETBITS8(b)));
137 return cl;
137 return cl;
138}
138}
139
139
@@ -160,77 +160,77 @@ VAL idris_b8Gte(VM *vm, VAL a, VAL b) {
160VAL idris_b8Compl(VM *vm, VAL a) {
160VAL idris_b8Compl(VM *vm, VAL a) {
161 VAL cl = allocate(vm, sizeof(Closure), 0);
161 VAL cl = allocate(vm, sizeof(Closure), 0);
162 SETTY(cl, BITS8);
162 SETTY(cl, BITS8);
163− cl->info.bits8 = ~ a->info.bits8;
163+ cl->info.bits8 = ~ GETBITS8(a);
164 return cl;
164 return cl;
165}
165}
166
166
167VAL idris_b8And(VM *vm, VAL a, VAL b) {
167VAL idris_b8And(VM *vm, VAL a, VAL b) {
168 VAL cl = allocate(vm, sizeof(Closure), 0);
168 VAL cl = allocate(vm, sizeof(Closure), 0);
169 SETTY(cl, BITS8);
169 SETTY(cl, BITS8);
170− cl->info.bits8 = a->info.bits8 & b->info.bits8;
170+ cl->info.bits8 = GETBITS8(a) & GETBITS8(b);
171 return cl;
171 return cl;
172}
172}
173
173
174VAL idris_b8Or(VM *vm, VAL a, VAL b) {
174VAL idris_b8Or(VM *vm, VAL a, VAL b) {
175 VAL cl = allocate(vm, sizeof(Closure), 0);
175 VAL cl = allocate(vm, sizeof(Closure), 0);
176 SETTY(cl, BITS8);
176 SETTY(cl, BITS8);
177− cl->info.bits8 = a->info.bits8 | b->info.bits8;
177+ cl->info.bits8 = GETBITS8(a) | GETBITS8(b);
178 return cl;
178 return cl;
179}
179}
180
180
181VAL idris_b8Xor(VM *vm, VAL a, VAL b) {
181VAL idris_b8Xor(VM *vm, VAL a, VAL b) {
182 VAL cl = allocate(vm, sizeof(Closure), 0);
182 VAL cl = allocate(vm, sizeof(Closure), 0);
183 SETTY(cl, BITS8);
183 SETTY(cl, BITS8);
184− cl->info.bits8 = a->info.bits8 ^ b->info.bits8;
184+ cl->info.bits8 = GETBITS8(a) ^ GETBITS8(b);
185 return cl;
185 return cl;
186}
186}
187
187
188VAL idris_b8Shl(VM *vm, VAL a, VAL b) {
188VAL idris_b8Shl(VM *vm, VAL a, VAL b) {
189 VAL cl = allocate(vm, sizeof(Closure), 0);
189 VAL cl = allocate(vm, sizeof(Closure), 0);
190 SETTY(cl, BITS8);
190 SETTY(cl, BITS8);
191− cl->info.bits8 = a->info.bits8 << b->info.bits8;
191+ cl->info.bits8 = GETBITS8(a) << GETBITS8(b);
192 return cl;
192 return cl;
193}
193}
194
194
195VAL idris_b8LShr(VM *vm, VAL a, VAL b) {
195VAL idris_b8LShr(VM *vm, VAL a, VAL b) {
196 VAL cl = allocate(vm, sizeof(Closure), 0);
196 VAL cl = allocate(vm, sizeof(Closure), 0);
197 SETTY(cl, BITS8);
197 SETTY(cl, BITS8);
198− cl->info.bits8 = a->info.bits8 >> b->info.bits8;
198+ cl->info.bits8 = GETBITS8(a) >> GETBITS8(b);
199 return cl;
199 return cl;
200}
200}
201
201
202VAL idris_b8AShr(VM *vm, VAL a, VAL b) {
202VAL idris_b8AShr(VM *vm, VAL a, VAL b) {
203 VAL cl = allocate(vm, sizeof(Closure), 0);
203 VAL cl = allocate(vm, sizeof(Closure), 0);
204 SETTY(cl, BITS8);
204 SETTY(cl, BITS8);
205− cl->info.bits8 = (uint8_t) (((int8_t)a->info.bits8) >> ((int8_t)b->info.bits8));
205+ cl->info.bits8 = (uint8_t) (((int8_t)GETBITS8(a)) >> ((int8_t)GETBITS8(b)));
206 return cl;
206 return cl;
207}
207}
208
208
209VAL idris_b16Plus(VM *vm, VAL a, VAL b) {
209VAL idris_b16Plus(VM *vm, VAL a, VAL b) {
210 VAL cl = allocate(vm, sizeof(Closure), 0);
210 VAL cl = allocate(vm, sizeof(Closure), 0);
211 SETTY(cl, BITS16);
211 SETTY(cl, BITS16);
212− cl->info.bits16 = a->info.bits16 + b->info.bits16;
212+ cl->info.bits16 = GETBITS16(a) + GETBITS16(b);
213 return cl;
213 return cl;
214}
214}
215
215
216VAL idris_b16Minus(VM *vm, VAL a, VAL b) {
216VAL idris_b16Minus(VM *vm, VAL a, VAL b) {
217 VAL cl = allocate(vm, sizeof(Closure), 0);
217 VAL cl = allocate(vm, sizeof(Closure), 0);
218 SETTY(cl, BITS16);
218 SETTY(cl, BITS16);
219− cl->info.bits16 = a->info.bits16 - b->info.bits16;
219+ cl->info.bits16 = GETBITS16(a) - GETBITS16(b);
220 return cl;
220 return cl;
221}
221}
222
222
223VAL idris_b16Times(VM *vm, VAL a, VAL b) {
223VAL idris_b16Times(VM *vm, VAL a, VAL b) {
224 VAL cl = allocate(vm, sizeof(Closure), 0);
224 VAL cl = allocate(vm, sizeof(Closure), 0);
225 SETTY(cl, BITS16);
225 SETTY(cl, BITS16);
226− cl->info.bits16 = a->info.bits16 * b->info.bits16;
226+ cl->info.bits16 = GETBITS16(a) * GETBITS16(b);
227 return cl;
227 return cl;
228}
228}
229
229
230VAL idris_b16UDiv(VM *vm, VAL a, VAL b) {
230VAL idris_b16UDiv(VM *vm, VAL a, VAL b) {
231 VAL cl = allocate(vm, sizeof(Closure), 0);
231 VAL cl = allocate(vm, sizeof(Closure), 0);
232 SETTY(cl, BITS16);
232 SETTY(cl, BITS16);
233− cl->info.bits16 = a->info.bits16 / b->info.bits16;
233+ cl->info.bits16 = GETBITS16(a) / GETBITS16(b);
234 return cl;
234 return cl;
235}
235}
236
236
@@ -238,14 +238,14 @@ VAL idris_b16SDiv(VM *vm, VAL a, VAL b) {
238 VAL cl = allocate(vm, sizeof(Closure), 0);
238 VAL cl = allocate(vm, sizeof(Closure), 0);
239 SETTY(cl, BITS16);
239 SETTY(cl, BITS16);
240 cl->info.bits16 =
240 cl->info.bits16 =
241− (uint16_t) (((int16_t) a->info.bits16) / ((int16_t) b->info.bits16));
241+ (uint16_t) (((int16_t) GETBITS16(a)) / ((int16_t) GETBITS16(b)));
242 return cl;
242 return cl;
243}
243}
244
244
245VAL idris_b16URem(VM *vm, VAL a, VAL b) {
245VAL idris_b16URem(VM *vm, VAL a, VAL b) {
246 VAL cl = allocate(vm, sizeof(Closure), 0);
246 VAL cl = allocate(vm, sizeof(Closure), 0);
247 SETTY(cl, BITS16);
247 SETTY(cl, BITS16);
248− cl->info.bits16 = a->info.bits16 % b->info.bits16;
248+ cl->info.bits16 = GETBITS16(a) % GETBITS16(b);
249 return cl;
249 return cl;
250}
250}
251
251
@@ -253,7 +253,7 @@ VAL idris_b16SRem(VM *vm, VAL a, VAL b) {
253 VAL cl = allocate(vm, sizeof(Closure), 0);
253 VAL cl = allocate(vm, sizeof(Closure), 0);
254 SETTY(cl, BITS16);
254 SETTY(cl, BITS16);
255 cl->info.bits16 =
255 cl->info.bits16 =
256− (uint16_t) (((int16_t) a->info.bits16) % ((int16_t) b->info.bits16));
256+ (uint16_t) (((int16_t) GETBITS16(a)) % ((int16_t) GETBITS16(b)));
257 return cl;
257 return cl;
258}
258}
259
259
@@ -280,77 +280,77 @@ VAL idris_b16Gte(VM *vm, VAL a, VAL b) {
280VAL idris_b16Compl(VM *vm, VAL a) {
280VAL idris_b16Compl(VM *vm, VAL a) {
281 VAL cl = allocate(vm, sizeof(Closure), 0);
281 VAL cl = allocate(vm, sizeof(Closure), 0);
282 SETTY(cl, BITS16);
282 SETTY(cl, BITS16);
283− cl->info.bits16 = ~ a->info.bits16;
283+ cl->info.bits16 = ~ GETBITS16(a);
284 return cl;
284 return cl;
285}
285}
286
286
287VAL idris_b16And(VM *vm, VAL a, VAL b) {
287VAL idris_b16And(VM *vm, VAL a, VAL b) {
288 VAL cl = allocate(vm, sizeof(Closure), 0);
288 VAL cl = allocate(vm, sizeof(Closure), 0);
289 SETTY(cl, BITS16);
289 SETTY(cl, BITS16);
290− cl->info.bits16 = a->info.bits16 & b->info.bits16;
290+ cl->info.bits16 = GETBITS16(a) & GETBITS16(b);
291 return cl;
291 return cl;
292}
292}
293
293
294VAL idris_b16Or(VM *vm, VAL a, VAL b) {
294VAL idris_b16Or(VM *vm, VAL a, VAL b) {
295 VAL cl = allocate(vm, sizeof(Closure), 0);
295 VAL cl = allocate(vm, sizeof(Closure), 0);
296 SETTY(cl, BITS16);
296 SETTY(cl, BITS16);
297− cl->info.bits16 = a->info.bits16 | b->info.bits16;
297+ cl->info.bits16 = GETBITS16(a) | GETBITS16(b);
298 return cl;
298 return cl;
299}
299}
300
300
301VAL idris_b16Xor(VM *vm, VAL a, VAL b) {
301VAL idris_b16Xor(VM *vm, VAL a, VAL b) {
302 VAL cl = allocate(vm, sizeof(Closure), 0);
302 VAL cl = allocate(vm, sizeof(Closure), 0);
303 SETTY(cl, BITS16);
303 SETTY(cl, BITS16);
304− cl->info.bits16 = a->info.bits16 ^ b->info.bits16;
304+ cl->info.bits16 = GETBITS16(a) ^ GETBITS16(b);
305 return cl;
305 return cl;
306}
306}
307
307
308VAL idris_b16Shl(VM *vm, VAL a, VAL b) {
308VAL idris_b16Shl(VM *vm, VAL a, VAL b) {
309 VAL cl = allocate(vm, sizeof(Closure), 0);
309 VAL cl = allocate(vm, sizeof(Closure), 0);
310 SETTY(cl, BITS16);
310 SETTY(cl, BITS16);
311− cl->info.bits16 = a->info.bits16 << b->info.bits16;
311+ cl->info.bits16 = GETBITS16(a) << GETBITS16(b);
312 return cl;
312 return cl;
313}
313}
314
314
315VAL idris_b16LShr(VM *vm, VAL a, VAL b) {
315VAL idris_b16LShr(VM *vm, VAL a, VAL b) {
316 VAL cl = allocate(vm, sizeof(Closure), 0);
316 VAL cl = allocate(vm, sizeof(Closure), 0);
317 SETTY(cl, BITS16);
317 SETTY(cl, BITS16);
318− cl->info.bits16 = a->info.bits16 >> b->info.bits16;
318+ cl->info.bits16 = GETBITS16(a) >> GETBITS16(b);
319 return cl;
319 return cl;
320}
320}
321
321
322VAL idris_b16AShr(VM *vm, VAL a, VAL b) {
322VAL idris_b16AShr(VM *vm, VAL a, VAL b) {
323 VAL cl = allocate(vm, sizeof(Closure), 0);
323 VAL cl = allocate(vm, sizeof(Closure), 0);
324 SETTY(cl, BITS16);
324 SETTY(cl, BITS16);
325− cl->info.bits16 = (uint16_t) (((int16_t)a->info.bits16) >> ((int16_t)b->info.bits16));
325+ cl->info.bits16 = (uint16_t) (((int16_t)GETBITS16(a)) >> ((int16_t)GETBITS16(b)));
326 return cl;
326 return cl;
327}
327}
328
328
329VAL idris_b32Plus(VM *vm, VAL a, VAL b) {
329VAL idris_b32Plus(VM *vm, VAL a, VAL b) {
330 VAL cl = allocate(vm, sizeof(Closure), 0);
330 VAL cl = allocate(vm, sizeof(Closure), 0);
331 SETTY(cl, BITS32);
331 SETTY(cl, BITS32);
332− cl->info.bits32 = a->info.bits32 + b->info.bits32;
332+ cl->info.bits32 = GETBITS32(a) + GETBITS32(b);
333 return cl;
333 return cl;
334}
334}
335
335
336VAL idris_b32Minus(VM *vm, VAL a, VAL b) {
336VAL idris_b32Minus(VM *vm, VAL a, VAL b) {
337 VAL cl = allocate(vm, sizeof(Closure), 0);
337 VAL cl = allocate(vm, sizeof(Closure), 0);
338 SETTY(cl, BITS32);
338 SETTY(cl, BITS32);
339− cl->info.bits32 = a->info.bits32 - b->info.bits32;
339+ cl->info.bits32 = GETBITS32(a) - GETBITS32(b);
340 return cl;
340 return cl;
341}
341}
342
342
343VAL idris_b32Times(VM *vm, VAL a, VAL b) {
343VAL idris_b32Times(VM *vm, VAL a, VAL b) {
344 VAL cl = allocate(vm, sizeof(Closure), 0);
344 VAL cl = allocate(vm, sizeof(Closure), 0);
345 SETTY(cl, BITS32);
345 SETTY(cl, BITS32);
346− cl->info.bits32 = a->info.bits32 * b->info.bits32;
346+ cl->info.bits32 = GETBITS32(a) * GETBITS32(b);
347 return cl;
347 return cl;
348}
348}
349
349
350VAL idris_b32UDiv(VM *vm, VAL a, VAL b) {
350VAL idris_b32UDiv(VM *vm, VAL a, VAL b) {
351 VAL cl = allocate(vm, sizeof(Closure), 0);
351 VAL cl = allocate(vm, sizeof(Closure), 0);
352 SETTY(cl, BITS32);
352 SETTY(cl, BITS32);
353− cl->info.bits32 = a->info.bits32 / b->info.bits32;
353+ cl->info.bits32 = GETBITS32(a) / GETBITS32(b);
354 return cl;
354 return cl;
355}
355}
356
356
@@ -358,14 +358,14 @@ VAL idris_b32SDiv(VM *vm, VAL a, VAL b) {
358 VAL cl = allocate(vm, sizeof(Closure), 0);
358 VAL cl = allocate(vm, sizeof(Closure), 0);
359 SETTY(cl, BITS32);
359 SETTY(cl, BITS32);
360 cl->info.bits32 =
360 cl->info.bits32 =
361− (uint32_t) (((int32_t) a->info.bits32) / ((int32_t) b->info.bits32));
361+ (uint32_t) (((int32_t) GETBITS32(a)) / ((int32_t) GETBITS32(b)));
362 return cl;
362 return cl;
363}
363}
364
364
365VAL idris_b32URem(VM *vm, VAL a, VAL b) {
365VAL idris_b32URem(VM *vm, VAL a, VAL b) {
366 VAL cl = allocate(vm, sizeof(Closure), 0);
366 VAL cl = allocate(vm, sizeof(Closure), 0);
367 SETTY(cl, BITS32);
367 SETTY(cl, BITS32);
368− cl->info.bits32 = a->info.bits32 % b->info.bits32;
368+ cl->info.bits32 = GETBITS32(a) % GETBITS32(b);
369 return cl;
369 return cl;
370}
370}
371
371
@@ -373,7 +373,7 @@ VAL idris_b32SRem(VM *vm, VAL a, VAL b) {
373 VAL cl = allocate(vm, sizeof(Closure), 0);
373 VAL cl = allocate(vm, sizeof(Closure), 0);
374 SETTY(cl, BITS32);
374 SETTY(cl, BITS32);
375 cl->info.bits32 =
375 cl->info.bits32 =
376− (uint32_t) (((int32_t) a->info.bits32) % ((int32_t) b->info.bits32));
376+ (uint32_t) (((int32_t) GETBITS32(a)) % ((int32_t) GETBITS32(b)));
377 return cl;
377 return cl;
378}
378}
379
379
@@ -400,77 +400,77 @@ VAL idris_b32Gte(VM *vm, VAL a, VAL b) {
400VAL idris_b32Compl(VM *vm, VAL a) {
400VAL idris_b32Compl(VM *vm, VAL a) {
401 VAL cl = allocate(vm, sizeof(Closure), 0);
401 VAL cl = allocate(vm, sizeof(Closure), 0);
402 SETTY(cl, BITS32);
402 SETTY(cl, BITS32);
403− cl->info.bits32 = ~ a->info.bits32;
403+ cl->info.bits32 = ~ GETBITS32(a);
404 return cl;
404 return cl;
405}
405}
406
406
407VAL idris_b32And(VM *vm, VAL a, VAL b) {
407VAL idris_b32And(VM *vm, VAL a, VAL b) {
408 VAL cl = allocate(vm, sizeof(Closure), 0);
408 VAL cl = allocate(vm, sizeof(Closure), 0);
409 SETTY(cl, BITS32);
409 SETTY(cl, BITS32);
410− cl->info.bits32 = a->info.bits32 & b->info.bits32;
410+ cl->info.bits32 = GETBITS32(a) & GETBITS32(b);
411 return cl;
411 return cl;
412}
412}
413
413
414VAL idris_b32Or(VM *vm, VAL a, VAL b) {
414VAL idris_b32Or(VM *vm, VAL a, VAL b) {
415 VAL cl = allocate(vm, sizeof(Closure), 0);
415 VAL cl = allocate(vm, sizeof(Closure), 0);
416 SETTY(cl, BITS32);
416 SETTY(cl, BITS32);
417− cl->info.bits32 = a->info.bits32 | b->info.bits32;
417+ cl->info.bits32 = GETBITS32(a) | GETBITS32(b);
418 return cl;
418 return cl;
419}
419}
420
420
421VAL idris_b32Xor(VM *vm, VAL a, VAL b) {
421VAL idris_b32Xor(VM *vm, VAL a, VAL b) {
422 VAL cl = allocate(vm, sizeof(Closure), 0);
422 VAL cl = allocate(vm, sizeof(Closure), 0);
423 SETTY(cl, BITS32);
423 SETTY(cl, BITS32);
424− cl->info.bits32 = a->info.bits32 ^ b->info.bits32;
424+ cl->info.bits32 = GETBITS32(a) ^ GETBITS32(b);
425 return cl;
425 return cl;
426}
426}
427
427
428VAL idris_b32Shl(VM *vm, VAL a, VAL b) {
428VAL idris_b32Shl(VM *vm, VAL a, VAL b) {
429 VAL cl = allocate(vm, sizeof(Closure), 0);
429 VAL cl = allocate(vm, sizeof(Closure), 0);
430 SETTY(cl, BITS32);
430 SETTY(cl, BITS32);
431− cl->info.bits32 = a->info.bits32 << b->info.bits32;
431+ cl->info.bits32 = GETBITS32(a) << GETBITS32(b);
432 return cl;
432 return cl;
433}
433}
434
434
435VAL idris_b32LShr(VM *vm, VAL a, VAL b) {
435VAL idris_b32LShr(VM *vm, VAL a, VAL b) {
436 VAL cl = allocate(vm, sizeof(Closure), 0);
436 VAL cl = allocate(vm, sizeof(Closure), 0);
437 SETTY(cl, BITS32);
437 SETTY(cl, BITS32);
438− cl->info.bits32 = a->info.bits32 >> b->info.bits32;
438+ cl->info.bits32 = GETBITS32(a) >> GETBITS32(b);
439 return cl;
439 return cl;
440}
440}
441
441
442VAL idris_b32AShr(VM *vm, VAL a, VAL b) {
442VAL idris_b32AShr(VM *vm, VAL a, VAL b) {
443 VAL cl = allocate(vm, sizeof(Closure), 0);
443 VAL cl = allocate(vm, sizeof(Closure), 0);
444 SETTY(cl, BITS32);
444 SETTY(cl, BITS32);
445− cl->info.bits32 = (uint32_t) (((int32_t)a->info.bits32) >> ((int32_t)b->info.bits32));
445+ cl->info.bits32 = (uint32_t) (((int32_t)GETBITS32(a)) >> ((int32_t)GETBITS32(b)));
446 return cl;
446 return cl;
447}
447}
448
448
449VAL idris_b64Plus(VM *vm, VAL a, VAL b) {
449VAL idris_b64Plus(VM *vm, VAL a, VAL b) {
450 VAL cl = allocate(vm, sizeof(Closure), 0);
450 VAL cl = allocate(vm, sizeof(Closure), 0);
451 SETTY(cl, BITS64);
451 SETTY(cl, BITS64);
452− cl->info.bits64 = a->info.bits64 + b->info.bits64;
452+ cl->info.bits64 = GETBITS64(a) + GETBITS64(b);
453 return cl;
453 return cl;
454}
454}
455
455
456VAL idris_b64Minus(VM *vm, VAL a, VAL b) {
456VAL idris_b64Minus(VM *vm, VAL a, VAL b) {
457 VAL cl = allocate(vm, sizeof(Closure), 0);
457 VAL cl = allocate(vm, sizeof(Closure), 0);
458 SETTY(cl, BITS64);
458 SETTY(cl, BITS64);
459− cl->info.bits64 = a->info.bits64 - b->info.bits64;
459+ cl->info.bits64 = GETBITS64(a) - GETBITS64(b);
460 return cl;
460 return cl;
461}
461}
462
462
463VAL idris_b64Times(VM *vm, VAL a, VAL b) {
463VAL idris_b64Times(VM *vm, VAL a, VAL b) {
464 VAL cl = allocate(vm, sizeof(Closure), 0);
464 VAL cl = allocate(vm, sizeof(Closure), 0);
465 SETTY(cl, BITS64);
465 SETTY(cl, BITS64);
466− cl->info.bits64 = a->info.bits64 * b->info.bits64;
466+ cl->info.bits64 = GETBITS64(a) * GETBITS64(b);
467 return cl;
467 return cl;
468}
468}
469
469
470VAL idris_b64UDiv(VM *vm, VAL a, VAL b) {
470VAL idris_b64UDiv(VM *vm, VAL a, VAL b) {
471 VAL cl = allocate(vm, sizeof(Closure), 0);
471 VAL cl = allocate(vm, sizeof(Closure), 0);
472 SETTY(cl, BITS64);
472 SETTY(cl, BITS64);
473− cl->info.bits64 = a->info.bits64 / b->info.bits64;
473+ cl->info.bits64 = GETBITS64(a) / GETBITS64(b);
474 return cl;
474 return cl;
475}
475}
476
476
@@ -478,14 +478,14 @@ VAL idris_b64SDiv(VM *vm, VAL a, VAL b) {
478 VAL cl = allocate(vm, sizeof(Closure), 0);
478 VAL cl = allocate(vm, sizeof(Closure), 0);
479 SETTY(cl, BITS64);
479 SETTY(cl, BITS64);
480 cl->info.bits64 =
480 cl->info.bits64 =
481− (uint64_t) (((int64_t) a->info.bits64) / ((int64_t) b->info.bits64));
481+ (uint64_t) (((int64_t) GETBITS64(a)) / ((int64_t) GETBITS64(b)));
482 return cl;
482 return cl;
483}
483}
484
484
485VAL idris_b64URem(VM *vm, VAL a, VAL b) {
485VAL idris_b64URem(VM *vm, VAL a, VAL b) {
486 VAL cl = allocate(vm, sizeof(Closure), 0);
486 VAL cl = allocate(vm, sizeof(Closure), 0);
487 SETTY(cl, BITS64);
487 SETTY(cl, BITS64);
488− cl->info.bits64 = a->info.bits64 % b->info.bits64;
488+ cl->info.bits64 = GETBITS64(a) % GETBITS64(b);
489 return cl;
489 return cl;
490}
490}
491
491
@@ -493,7 +493,7 @@ VAL idris_b64SRem(VM *vm, VAL a, VAL b) {
493 VAL cl = allocate(vm, sizeof(Closure), 0);
493 VAL cl = allocate(vm, sizeof(Closure), 0);
494 SETTY(cl, BITS64);
494 SETTY(cl, BITS64);
495 cl->info.bits64 =
495 cl->info.bits64 =
496− (uint64_t) (((int64_t) a->info.bits64) % ((int64_t) b->info.bits64));
496+ (uint64_t) (((int64_t) GETBITS64(a)) % ((int64_t) GETBITS64(b)));
497 return cl;
497 return cl;
498}
498}
499
499
@@ -520,175 +520,175 @@ VAL idris_b64Gte(VM *vm, VAL a, VAL b) {
520VAL idris_b64Compl(VM *vm, VAL a) {
520VAL idris_b64Compl(VM *vm, VAL a) {
521 VAL cl = allocate(vm, sizeof(Closure), 0);
521 VAL cl = allocate(vm, sizeof(Closure), 0);
522 SETTY(cl, BITS64);
522 SETTY(cl, BITS64);
523− cl->info.bits64 = ~ a->info.bits64;
523+ cl->info.bits64 = ~ GETBITS64(a);
524 return cl;
524 return cl;
525}
525}
526
526
527VAL idris_b64And(VM *vm, VAL a, VAL b) {
527VAL idris_b64And(VM *vm, VAL a, VAL b) {
528 VAL cl = allocate(vm, sizeof(Closure), 0);
528 VAL cl = allocate(vm, sizeof(Closure), 0);
529 SETTY(cl, BITS64);
529 SETTY(cl, BITS64);
530− cl->info.bits64 = a->info.bits64 & b->info.bits64;
530+ cl->info.bits64 = GETBITS64(a) & GETBITS64(b);
531 return cl;
531 return cl;
532}
532}
533
533
534VAL idris_b64Or(VM *vm, VAL a, VAL b) {
534VAL idris_b64Or(VM *vm, VAL a, VAL b) {
535 VAL cl = allocate(vm, sizeof(Closure), 0);
535 VAL cl = allocate(vm, sizeof(Closure), 0);
536 SETTY(cl, BITS64);
536 SETTY(cl, BITS64);
537− cl->info.bits64 = a->info.bits64 | b->info.bits64;
537+ cl->info.bits64 = GETBITS64(a) | GETBITS64(b);
538 return cl;
538 return cl;
539}
539}
540
540
541VAL idris_b64Xor(VM *vm, VAL a, VAL b) {
541VAL idris_b64Xor(VM *vm, VAL a, VAL b) {
542 VAL cl = allocate(vm, sizeof(Closure), 0);
542 VAL cl = allocate(vm, sizeof(Closure), 0);
543 SETTY(cl, BITS64);
543 SETTY(cl, BITS64);
544− cl->info.bits64 = a->info.bits64 ^ b->info.bits64;
544+ cl->info.bits64 = GETBITS64(a) ^ GETBITS64(b);
545 return cl;
545 return cl;
546}
546}
547
547
548VAL idris_b64Shl(VM *vm, VAL a, VAL b) {
548VAL idris_b64Shl(VM *vm, VAL a, VAL b) {
549 VAL cl = allocate(vm, sizeof(Closure), 0);
549 VAL cl = allocate(vm, sizeof(Closure), 0);
550 SETTY(cl, BITS64);
550 SETTY(cl, BITS64);
551− cl->info.bits64 = a->info.bits64 << b->info.bits64;
551+ cl->info.bits64 = GETBITS64(a) << GETBITS64(b);
552 return cl;
552 return cl;
553}
553}
554
554
555VAL idris_b64LShr(VM *vm, VAL a, VAL b) {
555VAL idris_b64LShr(VM *vm, VAL a, VAL b) {
556 VAL cl = allocate(vm, sizeof(Closure), 0);
556 VAL cl = allocate(vm, sizeof(Closure), 0);
557 SETTY(cl, BITS64);
557 SETTY(cl, BITS64);
558− cl->info.bits64 = a->info.bits64 >> b->info.bits64;
558+ cl->info.bits64 = GETBITS64(a) >> GETBITS64(b);
559 return cl;
559 return cl;
560}
560}
561
561
562VAL idris_b64AShr(VM *vm, VAL a, VAL b) {
562VAL idris_b64AShr(VM *vm, VAL a, VAL b) {
563 VAL cl = allocate(vm, sizeof(Closure), 0);
563 VAL cl = allocate(vm, sizeof(Closure), 0);
564 SETTY(cl, BITS64);
564 SETTY(cl, BITS64);
565− cl->info.bits64 = (uint64_t) (((int64_t)a->info.bits64) >> ((int64_t)b->info.bits64));
565+ cl->info.bits64 = (uint64_t) (((int64_t)GETBITS64(a)) >> ((int64_t)GETBITS64(b)));
566 return cl;
566 return cl;
567}
567}
568
568
569VAL idris_b8Z16(VM *vm, VAL a) {
569VAL idris_b8Z16(VM *vm, VAL a) {
570 VAL cl = allocate(vm, sizeof(Closure), 0);
570 VAL cl = allocate(vm, sizeof(Closure), 0);
571 SETTY(cl, BITS16);
571 SETTY(cl, BITS16);
572− cl->info.bits16 = (uint16_t) a->info.bits8;
572+ cl->info.bits16 = (uint16_t) GETBITS8(a);
573 return cl;
573 return cl;
574}
574}
575
575
576VAL idris_b8Z32(VM *vm, VAL a) {
576VAL idris_b8Z32(VM *vm, VAL a) {
577 VAL cl = allocate(vm, sizeof(Closure), 0);
577 VAL cl = allocate(vm, sizeof(Closure), 0);
578 SETTY(cl, BITS32);
578 SETTY(cl, BITS32);
579− cl->info.bits32 = (uint32_t) a->info.bits8;
579+ cl->info.bits32 = (uint32_t) GETBITS8(a);
580 return cl;
580 return cl;
581}
581}
582
582
583VAL idris_b8Z64(VM *vm, VAL a) {
583VAL idris_b8Z64(VM *vm, VAL a) {
584 VAL cl = allocate(vm, sizeof(Closure), 0);
584 VAL cl = allocate(vm, sizeof(Closure), 0);
585− SETTY(cl, BITS16);
585+ SETTY(cl, BITS64);
586− cl->info.bits64 = (uint64_t) a->info.bits8;
586+ cl->info.bits64 = (uint64_t) GETBITS8(a);
587 return cl;
587 return cl;
588}
588}
589
589
590VAL idris_b8S16(VM *vm, VAL a) {
590VAL idris_b8S16(VM *vm, VAL a) {
591 VAL cl = allocate(vm, sizeof(Closure), 0);
591 VAL cl = allocate(vm, sizeof(Closure), 0);
592 SETTY(cl, BITS16);
592 SETTY(cl, BITS16);
593− cl->info.bits16 = (uint16_t) (int16_t) (int8_t) a->info.bits8;
593+ cl->info.bits16 = (uint16_t) (int16_t) (int8_t) GETBITS8(a);
594 return cl;
594 return cl;
595}
595}
596
596
597VAL idris_b8S32(VM *vm, VAL a) {
597VAL idris_b8S32(VM *vm, VAL a) {
598 VAL cl = allocate(vm, sizeof(Closure), 0);
598 VAL cl = allocate(vm, sizeof(Closure), 0);
599 SETTY(cl, BITS32);
599 SETTY(cl, BITS32);
600− cl->info.bits32 = (uint32_t) (int32_t) (int8_t) a->info.bits8;
600+ cl->info.bits32 = (uint32_t) (int32_t) (int8_t) GETBITS8(a);
601 return cl;
601 return cl;
602}
602}
603
603
604VAL idris_b8S64(VM *vm, VAL a) {
604VAL idris_b8S64(VM *vm, VAL a) {
605 VAL cl = allocate(vm, sizeof(Closure), 0);
605 VAL cl = allocate(vm, sizeof(Closure), 0);
606 SETTY(cl, BITS64);
606 SETTY(cl, BITS64);
607− cl->info.bits64 = (uint64_t) (int64_t) (int8_t) a->info.bits8;
607+ cl->info.bits64 = (uint64_t) (int64_t) (int8_t) GETBITS8(a);
608 return cl;
608 return cl;
609}
609}
610
610
611VAL idris_b16Z32(VM *vm, VAL a) {
611VAL idris_b16Z32(VM *vm, VAL a) {
612 VAL cl = allocate(vm, sizeof(Closure), 0);
612 VAL cl = allocate(vm, sizeof(Closure), 0);
613 SETTY(cl, BITS32);
613 SETTY(cl, BITS32);
614− cl->info.bits32 = (uint32_t) a->info.bits16;
614+ cl->info.bits32 = (uint32_t) GETBITS16(a);
615 return cl;
615 return cl;
616}
616}
617
617
618VAL idris_b16Z64(VM *vm, VAL a) {
618VAL idris_b16Z64(VM *vm, VAL a) {
619 VAL cl = allocate(vm, sizeof(Closure), 0);
619 VAL cl = allocate(vm, sizeof(Closure), 0);
620 SETTY(cl, BITS64);
620 SETTY(cl, BITS64);
621− cl->info.bits64 = (uint64_t) a->info.bits16;
621+ cl->info.bits64 = (uint64_t) GETBITS16(a);
622 return cl;
622 return cl;
623}
623}
624
624
625VAL idris_b16S32(VM *vm, VAL a) {
625VAL idris_b16S32(VM *vm, VAL a) {
626 VAL cl = allocate(vm, sizeof(Closure), 0);
626 VAL cl = allocate(vm, sizeof(Closure), 0);
627 SETTY(cl, BITS32);
627 SETTY(cl, BITS32);
628− cl->info.bits32 = (uint32_t) (int32_t) (int16_t) a->info.bits16;
628+ cl->info.bits32 = (uint32_t) (int32_t) (int16_t) GETBITS16(a);
629 return cl;
629 return cl;
630}
630}
631
631
632VAL idris_b16S64(VM *vm, VAL a) {
632VAL idris_b16S64(VM *vm, VAL a) {
633 VAL cl = allocate(vm, sizeof(Closure), 0);
633 VAL cl = allocate(vm, sizeof(Closure), 0);
634 SETTY(cl, BITS64);
634 SETTY(cl, BITS64);
635− cl->info.bits64 = (uint64_t) (int64_t) (int16_t) a->info.bits16;
635+ cl->info.bits64 = (uint64_t) (int64_t) (int16_t) GETBITS16(a);
636 return cl;
636 return cl;
637}
637}
638
638
639VAL idris_b16T8(VM *vm, VAL a) {
639VAL idris_b16T8(VM *vm, VAL a) {
640 VAL cl = allocate(vm, sizeof(Closure), 0);
640 VAL cl = allocate(vm, sizeof(Closure), 0);
641 SETTY(cl, BITS8);
641 SETTY(cl, BITS8);
642− cl->info.bits8 = (uint8_t) a->info.bits16;
642+ cl->info.bits8 = (uint8_t) GETBITS16(a);
643 return cl;
643 return cl;
644}
644}
645
645
646VAL idris_b32Z64(VM *vm, VAL a) {
646VAL idris_b32Z64(VM *vm, VAL a) {
647 VAL cl = allocate(vm, sizeof(Closure), 0);
647 VAL cl = allocate(vm, sizeof(Closure), 0);
648 SETTY(cl, BITS64);
648 SETTY(cl, BITS64);
649− cl->info.bits64 = (uint64_t) a->info.bits32;
649+ cl->info.bits64 = (uint64_t) GETBITS32(a);
650 return cl;
650 return cl;
651}
651}
652
652
653VAL idris_b32S64(VM *vm, VAL a) {
653VAL idris_b32S64(VM *vm, VAL a) {
654 VAL cl = allocate(vm, sizeof(Closure), 0);
654 VAL cl = allocate(vm, sizeof(Closure), 0);
655 SETTY(cl, BITS64);
655 SETTY(cl, BITS64);
656− cl->info.bits64 = (uint64_t) (int64_t) (int32_t) a->info.bits32;
656+ cl->info.bits64 = (uint64_t) (int64_t) (int32_t) GETBITS32(a);
657 return cl;
657 return cl;
658}
658}
659
659
660VAL idris_b32T8(VM *vm, VAL a) {
660VAL idris_b32T8(VM *vm, VAL a) {
661 VAL cl = allocate(vm, sizeof(Closure), 0);
661 VAL cl = allocate(vm, sizeof(Closure), 0);
662 SETTY(cl, BITS8);
662 SETTY(cl, BITS8);
663− cl->info.bits8 = (uint8_t) a->info.bits32;
663+ cl->info.bits8 = (uint8_t) GETBITS32(a);
664 return cl;
664 return cl;
665}
665}
666
666
667VAL idris_b32T16(VM *vm, VAL a) {
667VAL idris_b32T16(VM *vm, VAL a) {
668 VAL cl = allocate(vm, sizeof(Closure), 0);
668 VAL cl = allocate(vm, sizeof(Closure), 0);
669 SETTY(cl, BITS16);
669 SETTY(cl, BITS16);
670− cl->info.bits16 = (uint16_t) a->info.bits32;
670+ cl->info.bits16 = (uint16_t) GETBITS32(a);
671 return cl;
671 return cl;
672}
672}
673
673
674VAL idris_b64T8(VM *vm, VAL a) {
674VAL idris_b64T8(VM *vm, VAL a) {
675 VAL cl = allocate(vm, sizeof(Closure), 0);
675 VAL cl = allocate(vm, sizeof(Closure), 0);
676 SETTY(cl, BITS8);
676 SETTY(cl, BITS8);
677− cl->info.bits8 = (uint8_t) a->info.bits64;
677+ cl->info.bits8 = (uint8_t) GETBITS64(a);
678 return cl;
678 return cl;
679}
679}
680
680
681VAL idris_b64T16(VM *vm, VAL a) {
681VAL idris_b64T16(VM *vm, VAL a) {
682 VAL cl = allocate(vm, sizeof(Closure), 0);
682 VAL cl = allocate(vm, sizeof(Closure), 0);
683 SETTY(cl, BITS16);
683 SETTY(cl, BITS16);
684− cl->info.bits16 = (uint16_t) a->info.bits64;
684+ cl->info.bits16 = (uint16_t) GETBITS64(a);
685 return cl;
685 return cl;
686}
686}
687
687
688VAL idris_b64T32(VM *vm, VAL a) {
688VAL idris_b64T32(VM *vm, VAL a) {
689 VAL cl = allocate(vm, sizeof(Closure), 0);
689 VAL cl = allocate(vm, sizeof(Closure), 0);
690 SETTY(cl, BITS32);
690 SETTY(cl, BITS32);
691− cl->info.bits32 = (uint32_t) a->info.bits64;
691+ cl->info.bits32 = (uint32_t) GETBITS64(a);
692 return cl;
692 return cl;
693}
693}
694
694
rts/idris_rts.h+5
@@ -129,6 +129,11 @@ typedef void(*func)(VM*, VAL*);
129#define GETMPTR(x) (((VAL)(x))->info.mptr->data)
129#define GETMPTR(x) (((VAL)(x))->info.mptr->data)
130#define GETFLOAT(x) (((VAL)(x))->info.f)
130#define GETFLOAT(x) (((VAL)(x))->info.f)
131
131
132+#define GETBITS64(x) ((x)->ty == FWD ? ((VAL)((x)->info.ptr))->info.bits64 : (x)->info.bits64)
133+#define GETBITS32(x) ((x)->ty == FWD ? ((VAL)((x)->info.ptr))->info.bits32 : (x)->info.bits32)
134+#define GETBITS16(x) ((x)->ty == FWD ? ((VAL)((x)->info.ptr))->info.bits16 : (x)->info.bits16)
135+#define GETBITS8(x) ((x)->ty == FWD ? ((VAL)((x)->info.ptr))->info.bits8 : (x)->info.bits8)
136+
132#define TAG(x) (ISINT(x) || x == NULL ? (-1) : ( GETTY(x) == CON ? (x)->info.c.tag_arity >> 8 : (-1)) )
137#define TAG(x) (ISINT(x) || x == NULL ? (-1) : ( GETTY(x) == CON ? (x)->info.c.tag_arity >> 8 : (-1)) )
133#define ARITY(x) (ISINT(x) || x == NULL ? (-1) : ( GETTY(x) == CON ? (x)->info.c.tag_arity & 0x000000ff : (-1)) )
138#define ARITY(x) (ISINT(x) || x == NULL ? (-1) : ( GETTY(x) == CON ? (x)->info.c.tag_arity & 0x000000ff : (-1)) )
134
139