@@ -2,824 +2,558 @@
3#include "idris_rts.h"
3#include "idris_rts.h"
5−VAL idris_b8CopyForGC(VM *vm, VAL a) {
5+VAL idris_b8const(VM *vm, uint8_t a) {
6− uint8_t A = a->info.bits8;
7− VAL cl = allocate(sizeof(Closure), 1);
10− return cl;
6+ return MKINT(a);
13−VAL idris_b16CopyForGC(VM *vm, VAL a) {
9+VAL idris_b16const(VM *vm, uint16_t a) {
14− uint16_t A = a->info.bits16;
15− VAL cl = allocate(sizeof(Closure), 1);
16− SETTY(cl, CT_BITS16);
18− return cl;
10+ return MKINT(a);
21−VAL idris_b32CopyForGC(VM *vm, VAL a) {
13+VAL idris_b32const(VM *vm, uint32_t a) {
22− uint32_t A = a->info.bits32;
14+ Bits32 * cl = iallocate(vm, sizeof(*cl), 0);
23− VAL cl = allocate(sizeof(Closure), 1);
24 SETTY(cl, CT_BITS32);
15 SETTY(cl, CT_BITS32);
25− cl->info.bits32 = A;
16+ cl->bits32 = a;
26− return cl;
17+ return (VAL)cl;
29−VAL idris_b64CopyForGC(VM *vm, VAL a) {
20+VAL idris_b64const(VM *vm, uint64_t a) {
30− uint64_t A = a->info.bits64;
21+ Bits64 * cl = iallocate(vm, sizeof(*cl), 0);
31− VAL cl = allocate(sizeof(Closure), 1);
32 SETTY(cl, CT_BITS64);
22 SETTY(cl, CT_BITS64);
33− cl->info.bits64 = A;
23+ cl->bits64 = a;
34− return cl;
24+ return (VAL)cl;
37VAL idris_b8(VM *vm, VAL a) {
27VAL idris_b8(VM *vm, VAL a) {
38− uint8_t A = GETINT(a);
28+ return idris_b8const(vm, GETINT(a));
39− VAL cl = allocate(sizeof(Closure), 0);
41− cl->info.bits8 = (uint8_t) A;
45VAL idris_b16(VM *vm, VAL a) {
31VAL idris_b16(VM *vm, VAL a) {
46− uint16_t A = GETINT(a);
32+ return idris_b16const(vm, GETINT(a));
47− VAL cl = allocate(sizeof(Closure), 0);
48− SETTY(cl, CT_BITS16);
49− cl->info.bits16 = (uint16_t) A;
53VAL idris_b32(VM *vm, VAL a) {
35VAL idris_b32(VM *vm, VAL a) {
54− uint32_t A = GETINT(a);
36+ return idris_b32const(vm, GETINT(a));
55− VAL cl = allocate(sizeof(Closure), 0);
56− SETTY(cl, CT_BITS32);
57− cl->info.bits32 = (uint32_t) A;
61VAL idris_b64(VM *vm, VAL a) {
39VAL idris_b64(VM *vm, VAL a) {
62− uint64_t A = GETINT(a);
40+ return idris_b64const(vm, GETINT(a));
63− VAL cl = allocate(sizeof(Closure), 0);
64− SETTY(cl, CT_BITS64);
65− cl->info.bits64 = (uint64_t) A;
69VAL idris_castB32Int(VM *vm, VAL a) {
43VAL idris_castB32Int(VM *vm, VAL a) {
70− return MKINT((i_int)a->info.bits32);
44+ return MKINT(GETBITS32(a));
73−VAL idris_b8const(VM *vm, uint8_t a) {
74− VAL cl = allocate(sizeof(Closure), 0);
80−VAL idris_b16const(VM *vm, uint16_t a) {
81− VAL cl = allocate(sizeof(Closure), 0);
82− SETTY(cl, CT_BITS16);
87−VAL idris_b32const(VM *vm, uint32_t a) {
88− VAL cl = allocate(sizeof(Closure), 0);
89− SETTY(cl, CT_BITS32);
94−VAL idris_b64const(VM *vm, uint64_t a) {
95− VAL cl = allocate(sizeof(Closure), 0);
96− SETTY(cl, CT_BITS64);
101VAL idris_b8Plus(VM *vm, VAL a, VAL b) {
47VAL idris_b8Plus(VM *vm, VAL a, VAL b) {
102− uint8_t A = a->info.bits8;
48+ uint8_t A = GETBITS8(a);
103− uint8_t B = b->info.bits8;
49+ uint8_t B = GETBITS8(b);
104− VAL cl = allocate(sizeof(Closure), 0);
50+ return idris_b8const(vm, A + B);
105− SETTY(cl, CT_BITS8);
106− cl->info.bits8 = A + B;
110VAL idris_b8Minus(VM *vm, VAL a, VAL b) {
53VAL idris_b8Minus(VM *vm, VAL a, VAL b) {
111− uint8_t A = a->info.bits8;
54+ uint8_t A = GETBITS8(a);
112− uint8_t B = b->info.bits8;
55+ uint8_t B = GETBITS8(b);
113− VAL cl = allocate(sizeof(Closure), 0);
56+ return idris_b8const(vm, A - B);
114− SETTY(cl, CT_BITS8);
115− cl->info.bits8 = A - B;
119VAL idris_b8Times(VM *vm, VAL a, VAL b) {
59VAL idris_b8Times(VM *vm, VAL a, VAL b) {
120− uint8_t A = a->info.bits8;
60+ uint8_t A = GETBITS8(a);
121− uint8_t B = b->info.bits8;
61+ uint8_t B = GETBITS8(b);
122− VAL cl = allocate(sizeof(Closure), 0);
62+ return idris_b8const(vm, A * B);
123− SETTY(cl, CT_BITS8);
124− cl->info.bits8 = A * B;
128VAL idris_b8UDiv(VM *vm, VAL a, VAL b) {
65VAL idris_b8UDiv(VM *vm, VAL a, VAL b) {
129− uint8_t A = a->info.bits8;
66+ uint8_t A = GETBITS8(a);
130− uint8_t B = b->info.bits8;
67+ uint8_t B = GETBITS8(b);
131− VAL cl = allocate(sizeof(Closure), 0);
68+ return idris_b8const(vm, A / B);
132− SETTY(cl, CT_BITS8);
133− cl->info.bits8 = A / B;
137VAL idris_b8SDiv(VM *vm, VAL a, VAL b) {
71VAL idris_b8SDiv(VM *vm, VAL a, VAL b) {
138− uint8_t A = a->info.bits8;
72+ int8_t A = GETBITS8(a);
139− uint8_t B = b->info.bits8;
73+ int8_t B = GETBITS8(b);
140− VAL cl = allocate(sizeof(Closure), 0);
74+ return idris_b8const(vm, A / B);
141− SETTY(cl, CT_BITS8);
142− cl->info.bits8 = (uint8_t) (((int8_t) A) / ((int8_t) B));
146VAL idris_b8URem(VM *vm, VAL a, VAL b) {
77VAL idris_b8URem(VM *vm, VAL a, VAL b) {
147− uint8_t A = a->info.bits8;
78+ uint8_t A = GETBITS8(a);
148− uint8_t B = b->info.bits8;
79+ uint8_t B = GETBITS8(b);
149− VAL cl = allocate(sizeof(Closure), 0);
80+ return idris_b8const(vm, A % B);
150− SETTY(cl, CT_BITS8);
151− cl->info.bits8 = A % B;
155VAL idris_b8SRem(VM *vm, VAL a, VAL b) {
83VAL idris_b8SRem(VM *vm, VAL a, VAL b) {
156− uint8_t A = a->info.bits8;
84+ int8_t A = GETBITS8(a);
157− uint8_t B = b->info.bits8;
85+ int8_t B = GETBITS8(b);
158− VAL cl = allocate(sizeof(Closure), 0);
86+ return idris_b8const(vm, A % B);
159− SETTY(cl, CT_BITS8);
160− cl->info.bits8 = (uint8_t) (((int8_t) A) % ((int8_t) B));
164VAL idris_b8Lt(VM *vm, VAL a, VAL b) {
89VAL idris_b8Lt(VM *vm, VAL a, VAL b) {
165− return MKINT((i_int) (a->info.bits8 < b->info.bits8));
90+ return MKINT((i_int) (GETBITS8(a) < GETBITS8(b)));
168VAL idris_b8Gt(VM *vm, VAL a, VAL b) {
93VAL idris_b8Gt(VM *vm, VAL a, VAL b) {
169− return MKINT((i_int) (a->info.bits8 > b->info.bits8));
94+ return MKINT((i_int) (GETBITS8(a) > GETBITS8(b)));
172VAL idris_b8Eq(VM *vm, VAL a, VAL b) {
97VAL idris_b8Eq(VM *vm, VAL a, VAL b) {
173− return MKINT((i_int) (a->info.bits8 == b->info.bits8));
98+ return MKINT((i_int) (GETBITS8(a) == GETBITS8(b)));
176VAL idris_b8Lte(VM *vm, VAL a, VAL b) {
101VAL idris_b8Lte(VM *vm, VAL a, VAL b) {
177− return MKINT((i_int) (a->info.bits8 <= b->info.bits8));
102+ return MKINT((i_int) (GETBITS8(a) <= GETBITS8(b)));
180VAL idris_b8Gte(VM *vm, VAL a, VAL b) {
105VAL idris_b8Gte(VM *vm, VAL a, VAL b) {
181− return MKINT((i_int) (a->info.bits8 >= b->info.bits8));
106+ return MKINT((i_int) (GETBITS8(a) >= GETBITS8(b)));
184VAL idris_b8Compl(VM *vm, VAL a) {
109VAL idris_b8Compl(VM *vm, VAL a) {
185− uint8_t A = a->info.bits8;
110+ uint8_t A = GETBITS8(a);
186− VAL cl = allocate(sizeof(Closure), 0);
187− SETTY(cl, CT_BITS8);
188− cl->info.bits8 = ~ A;
189− return cl;
111+ return idris_b8const(vm, ~ A);
192VAL idris_b8And(VM *vm, VAL a, VAL b) {
114VAL idris_b8And(VM *vm, VAL a, VAL b) {
193− uint8_t A = a->info.bits8;
115+ uint8_t A = GETBITS8(a);
194− uint8_t B = b->info.bits8;
116+ uint8_t B = GETBITS8(b);
195− VAL cl = allocate(sizeof(Closure), 0);
117+ return idris_b8const(vm, A & B);
196− SETTY(cl, CT_BITS8);
197− cl->info.bits8 = A & B;
201VAL idris_b8Or(VM *vm, VAL a, VAL b) {
120VAL idris_b8Or(VM *vm, VAL a, VAL b) {
202− uint8_t A = a->info.bits8;
121+ uint8_t A = GETBITS8(a);
203− uint8_t B = b->info.bits8;
122+ uint8_t B = GETBITS8(b);
204− VAL cl = allocate(sizeof(Closure), 0);
123+ return idris_b8const(vm, A | B);
205− SETTY(cl, CT_BITS8);
206− cl->info.bits8 = A | B;
210VAL idris_b8Xor(VM *vm, VAL a, VAL b) {
126VAL idris_b8Xor(VM *vm, VAL a, VAL b) {
211− uint8_t A = a->info.bits8;
127+ uint8_t A = GETBITS8(a);
212− uint8_t B = b->info.bits8;
128+ uint8_t B = GETBITS8(b);
213− VAL cl = allocate(sizeof(Closure), 0);
129+ return idris_b8const(vm, A ^ B);
214− SETTY(cl, CT_BITS8);
215− cl->info.bits8 = A ^ B;
219VAL idris_b8Shl(VM *vm, VAL a, VAL b) {
132VAL idris_b8Shl(VM *vm, VAL a, VAL b) {
220− uint8_t A = a->info.bits8;
133+ uint8_t A = GETBITS8(a);
221− uint8_t B = b->info.bits8;
134+ uint8_t B = GETBITS8(b);
222− VAL cl = allocate(sizeof(Closure), 0);
135+ return idris_b8const(vm, A << B);
223− SETTY(cl, CT_BITS8);
224− cl->info.bits8 = A << B;
228VAL idris_b8LShr(VM *vm, VAL a, VAL b) {
138VAL idris_b8LShr(VM *vm, VAL a, VAL b) {
229− uint8_t A = a->info.bits8;
139+ uint8_t A = GETBITS8(a);
230− uint8_t B = b->info.bits8;
140+ uint8_t B = GETBITS8(b);
231− VAL cl = allocate(sizeof(Closure), 0);
141+ return idris_b8const(vm, A >> B);
232− SETTY(cl, CT_BITS8);
233− cl->info.bits8 = A >> B;
237VAL idris_b8AShr(VM *vm, VAL a, VAL b) {
144VAL idris_b8AShr(VM *vm, VAL a, VAL b) {
238− uint8_t A = a->info.bits8;
145+ int8_t A = GETBITS8(a);
239− uint8_t B = b->info.bits8;
146+ int8_t B = GETBITS8(b);
240− VAL cl = allocate(sizeof(Closure), 0);
147+ return idris_b8const(vm, A >> B);
241− SETTY(cl, CT_BITS8);
242− cl->info.bits8 = (uint8_t) (((int8_t) A) >> ((int8_t) B));
246VAL idris_b16Plus(VM *vm, VAL a, VAL b) {
150VAL idris_b16Plus(VM *vm, VAL a, VAL b) {
247− uint16_t A = a->info.bits16;
151+ uint16_t A = GETBITS16(a);
248− uint16_t B = b->info.bits16;
152+ uint16_t B = GETBITS16(b);
249− VAL cl = allocate(sizeof(Closure), 0);
153+ return idris_b16const(vm, A + B);
250− SETTY(cl, CT_BITS16);
251− cl->info.bits16 = A + B;
255VAL idris_b16Minus(VM *vm, VAL a, VAL b) {
156VAL idris_b16Minus(VM *vm, VAL a, VAL b) {
256− uint16_t A = a->info.bits16;
157+ uint16_t A = GETBITS16(a);
257− uint16_t B = b->info.bits16;
158+ uint16_t B = GETBITS16(b);
258− VAL cl = allocate(sizeof(Closure), 0);
159+ return idris_b16const(vm, A - B);
259− SETTY(cl, CT_BITS16);
260− cl->info.bits16 = A - B;
264VAL idris_b16Times(VM *vm, VAL a, VAL b) {
162VAL idris_b16Times(VM *vm, VAL a, VAL b) {
265− uint16_t A = a->info.bits16;
163+ uint16_t A = GETBITS16(a);
266− uint16_t B = b->info.bits16;
164+ uint16_t B = GETBITS16(b);
267− VAL cl = allocate(sizeof(Closure), 0);
165+ return idris_b16const(vm, A * B);
268− SETTY(cl, CT_BITS16);
269− cl->info.bits16 = A * B;
273VAL idris_b16UDiv(VM *vm, VAL a, VAL b) {
168VAL idris_b16UDiv(VM *vm, VAL a, VAL b) {
274− uint16_t A = a->info.bits16;
169+ uint16_t A = GETBITS16(a);
275− uint16_t B = b->info.bits16;
170+ uint16_t B = GETBITS16(b);
276− VAL cl = allocate(sizeof(Closure), 0);
171+ return idris_b16const(vm, A / B);
277− SETTY(cl, CT_BITS16);
278− cl->info.bits16 = A / B;
282VAL idris_b16SDiv(VM *vm, VAL a, VAL b) {
174VAL idris_b16SDiv(VM *vm, VAL a, VAL b) {
283− uint16_t A = a->info.bits16;
175+ int16_t A = GETBITS16(a);
284− uint16_t B = b->info.bits16;
176+ int16_t B = GETBITS16(b);
285− VAL cl = allocate(sizeof(Closure), 0);
177+ return idris_b16const(vm, A / B);
286− SETTY(cl, CT_BITS16);
287− cl->info.bits16 = (uint16_t) (((int16_t) A) / ((int16_t) B));
291VAL idris_b16URem(VM *vm, VAL a, VAL b) {
180VAL idris_b16URem(VM *vm, VAL a, VAL b) {
292− uint16_t A = a->info.bits16;
181+ uint16_t A = GETBITS16(a);
293− uint16_t B = b->info.bits16;
182+ uint16_t B = GETBITS16(b);
294− VAL cl = allocate(sizeof(Closure), 0);
183+ return idris_b16const(vm, A % B);
295− SETTY(cl, CT_BITS16);
296− cl->info.bits16 = A % B;
300VAL idris_b16SRem(VM *vm, VAL a, VAL b) {
186VAL idris_b16SRem(VM *vm, VAL a, VAL b) {
301− uint16_t A = a->info.bits16;
187+ int16_t A = GETBITS16(a);
302− uint16_t B = b->info.bits16;
188+ int16_t B = GETBITS16(b);
303− VAL cl = allocate(sizeof(Closure), 0);
189+ return idris_b16const(vm, A % B);
304− SETTY(cl, CT_BITS16);
305− cl->info.bits16 = (uint16_t) (((int16_t) A) % ((int16_t) B));
309VAL idris_b16Lt(VM *vm, VAL a, VAL b) {
192VAL idris_b16Lt(VM *vm, VAL a, VAL b) {
310− return MKINT((i_int) (a->info.bits16 < b->info.bits16));
193+ return MKINT((i_int) (GETBITS16(a) < GETBITS16(b)));
313VAL idris_b16Gt(VM *vm, VAL a, VAL b) {
196VAL idris_b16Gt(VM *vm, VAL a, VAL b) {
314− return MKINT((i_int) (a->info.bits16 > b->info.bits16));
197+ return MKINT((i_int) (GETBITS16(a) > GETBITS16(b)));
317VAL idris_b16Eq(VM *vm, VAL a, VAL b) {
200VAL idris_b16Eq(VM *vm, VAL a, VAL b) {
318− return MKINT((i_int) (a->info.bits16 == b->info.bits16));
201+ return MKINT((i_int) (GETBITS16(a) == GETBITS16(b)));
321VAL idris_b16Lte(VM *vm, VAL a, VAL b) {
204VAL idris_b16Lte(VM *vm, VAL a, VAL b) {
322− return MKINT((i_int) (a->info.bits16 <= b->info.bits16));
205+ return MKINT((i_int) (GETBITS16(a) <= GETBITS16(b)));
325VAL idris_b16Gte(VM *vm, VAL a, VAL b) {
208VAL idris_b16Gte(VM *vm, VAL a, VAL b) {
326− return MKINT((i_int) (a->info.bits16 >= b->info.bits16));
209+ return MKINT((i_int) (GETBITS16(a) >= GETBITS16(b)));
329VAL idris_b16Compl(VM *vm, VAL a) {
212VAL idris_b16Compl(VM *vm, VAL a) {
330− uint16_t A = a->info.bits16;
213+ uint16_t A = GETBITS16(a);
331− VAL cl = allocate(sizeof(Closure), 0);
214+ return idris_b16const(vm, ~ A);
332− SETTY(cl, CT_BITS16);
333− cl->info.bits16 = ~ A;
337VAL idris_b16And(VM *vm, VAL a, VAL b) {
217VAL idris_b16And(VM *vm, VAL a, VAL b) {
338− uint16_t A = a->info.bits16;
218+ uint16_t A = GETBITS16(a);
339− uint16_t B = b->info.bits16;
219+ uint16_t B = GETBITS16(b);
340− VAL cl = allocate(sizeof(Closure), 0);
220+ return idris_b16const(vm, A & B);
341− SETTY(cl, CT_BITS16);
342− cl->info.bits16 = A & B;
346VAL idris_b16Or(VM *vm, VAL a, VAL b) {
223VAL idris_b16Or(VM *vm, VAL a, VAL b) {
347− uint16_t A = a->info.bits16;
224+ uint16_t A = GETBITS16(a);
348− uint16_t B = b->info.bits16;
225+ uint16_t B = GETBITS16(b);
349− VAL cl = allocate(sizeof(Closure), 0);
226+ return idris_b16const(vm, A | B);
350− SETTY(cl, CT_BITS16);
351− cl->info.bits16 = A | B;
355VAL idris_b16Xor(VM *vm, VAL a, VAL b) {
229VAL idris_b16Xor(VM *vm, VAL a, VAL b) {
356− uint16_t A = a->info.bits16;
230+ uint16_t A = GETBITS16(a);
357− uint16_t B = b->info.bits16;
231+ uint16_t B = GETBITS16(b);
358− VAL cl = allocate(sizeof(Closure), 0);
232+ return idris_b16const(vm, A ^ B);
359− SETTY(cl, CT_BITS16);
360− cl->info.bits16 = A ^ B;
364VAL idris_b16Shl(VM *vm, VAL a, VAL b) {
235VAL idris_b16Shl(VM *vm, VAL a, VAL b) {
365− uint16_t A = a->info.bits16;
236+ uint16_t A = GETBITS16(a);
366− uint16_t B = b->info.bits16;
237+ uint16_t B = GETBITS16(b);
367− VAL cl = allocate(sizeof(Closure), 0);
238+ return idris_b16const(vm, A << B);
368− SETTY(cl, CT_BITS16);
369− cl->info.bits16 = A << B;
373VAL idris_b16LShr(VM *vm, VAL a, VAL b) {
241VAL idris_b16LShr(VM *vm, VAL a, VAL b) {
374− uint16_t A = a->info.bits16;
242+ uint16_t A = GETBITS16(a);
375− uint16_t B = b->info.bits16;
243+ uint16_t B = GETBITS16(b);
376− VAL cl = allocate(sizeof(Closure), 0);
244+ return idris_b16const(vm, A >> B);
377− SETTY(cl, CT_BITS16);
378− cl->info.bits16 = A >> B;
382VAL idris_b16AShr(VM *vm, VAL a, VAL b) {
247VAL idris_b16AShr(VM *vm, VAL a, VAL b) {
383− uint16_t A = a->info.bits16;
248+ int16_t A = GETBITS16(a);
384− uint16_t B = b->info.bits16;
249+ int16_t B = GETBITS16(b);
385− VAL cl = allocate(sizeof(Closure), 0);
250+ return idris_b16const(vm, A >> B);
386− SETTY(cl, CT_BITS16);
387− cl->info.bits16 = (uint16_t) (((int16_t) A) >> ((int16_t) B));
391VAL idris_b32Plus(VM *vm, VAL a, VAL b) {
253VAL idris_b32Plus(VM *vm, VAL a, VAL b) {
392− uint32_t A = a->info.bits32;
254+ uint32_t A = GETBITS32(a);
393− uint32_t B = b->info.bits32;
255+ uint32_t B = GETBITS32(b);
394− VAL cl = allocate(sizeof(Closure), 0);
256+ return idris_b32const(vm, A + B);
395− SETTY(cl, CT_BITS32);
396− cl->info.bits32 = A + B;
400VAL idris_b32Minus(VM *vm, VAL a, VAL b) {
259VAL idris_b32Minus(VM *vm, VAL a, VAL b) {
401− uint32_t A = a->info.bits32;
260+ uint32_t A = GETBITS32(a);
402− uint32_t B = b->info.bits32;
261+ uint32_t B = GETBITS32(b);
403− VAL cl = allocate(sizeof(Closure), 0);
262+ return idris_b32const(vm, A - B);
404− SETTY(cl, CT_BITS32);
405− cl->info.bits32 = A - B;
409VAL idris_b32Times(VM *vm, VAL a, VAL b) {
265VAL idris_b32Times(VM *vm, VAL a, VAL b) {
410− uint32_t A = a->info.bits32;
266+ uint32_t A = GETBITS32(a);
411− uint32_t B = b->info.bits32;
267+ uint32_t B = GETBITS32(b);
412− VAL cl = allocate(sizeof(Closure), 0);
268+ return idris_b32const(vm, A * B);
413− SETTY(cl, CT_BITS32);
414− cl->info.bits32 = A * B;
418VAL idris_b32UDiv(VM *vm, VAL a, VAL b) {
271VAL idris_b32UDiv(VM *vm, VAL a, VAL b) {
419− uint32_t A = a->info.bits32;
272+ uint32_t A = GETBITS32(a);
420− uint32_t B = b->info.bits32;
273+ uint32_t B = GETBITS32(b);
421− VAL cl = allocate(sizeof(Closure), 0);
274+ return idris_b32const(vm, A / B);
422− SETTY(cl, CT_BITS32);
423− cl->info.bits32 = A / B;
427VAL idris_b32SDiv(VM *vm, VAL a, VAL b) {
277VAL idris_b32SDiv(VM *vm, VAL a, VAL b) {
428− uint32_t A = a->info.bits32;
278+ int32_t A = GETBITS32(a);
429− uint32_t B = b->info.bits32;
279+ int32_t B = GETBITS32(b);
430− VAL cl = allocate(sizeof(Closure), 0);
280+ return idris_b32const(vm, A / B);
431− SETTY(cl, CT_BITS32);
432− cl->info.bits32 = (uint32_t) (((int32_t) A) / ((int32_t) B));
436VAL idris_b32URem(VM *vm, VAL a, VAL b) {
283VAL idris_b32URem(VM *vm, VAL a, VAL b) {
437− uint32_t A = a->info.bits32;
284+ uint32_t A = GETBITS32(a);
438− uint32_t B = b->info.bits32;
285+ uint32_t B = GETBITS32(b);
439− VAL cl = allocate(sizeof(Closure), 0);
286+ return idris_b32const(vm, A % B);
440− SETTY(cl, CT_BITS32);
441− cl->info.bits32 = A % B;
445VAL idris_b32SRem(VM *vm, VAL a, VAL b) {
289VAL idris_b32SRem(VM *vm, VAL a, VAL b) {
446− uint32_t A = a->info.bits32;
290+ int32_t A = GETBITS32(a);
447− uint32_t B = b->info.bits32;
291+ int32_t B = GETBITS32(b);
448− VAL cl = allocate(sizeof(Closure), 0);
292+ return idris_b32const(vm, A % B);
449− SETTY(cl, CT_BITS32);
450− cl->info.bits32 = (uint32_t) (((int32_t) A) % ((int32_t) B));
454VAL idris_b32Lt(VM *vm, VAL a, VAL b) {
295VAL idris_b32Lt(VM *vm, VAL a, VAL b) {
455− return MKINT((i_int) (a->info.bits32 < b->info.bits32));
296+ return MKINT((i_int) (GETBITS32(a) < GETBITS32(b)));
458VAL idris_b32Gt(VM *vm, VAL a, VAL b) {
299VAL idris_b32Gt(VM *vm, VAL a, VAL b) {
459− return MKINT((i_int) (a->info.bits32 > b->info.bits32));
300+ return MKINT((i_int) (GETBITS32(a) > GETBITS32(b)));
462VAL idris_b32Eq(VM *vm, VAL a, VAL b) {
303VAL idris_b32Eq(VM *vm, VAL a, VAL b) {
463− return MKINT((i_int) (a->info.bits32 == b->info.bits32));
304+ return MKINT((i_int) (GETBITS32(a) == GETBITS32(b)));
466VAL idris_b32Lte(VM *vm, VAL a, VAL b) {
307VAL idris_b32Lte(VM *vm, VAL a, VAL b) {
467− return MKINT((i_int) (a->info.bits32 <= b->info.bits32));
308+ return MKINT((i_int) (GETBITS32(a) <= GETBITS32(b)));
470VAL idris_b32Gte(VM *vm, VAL a, VAL b) {
311VAL idris_b32Gte(VM *vm, VAL a, VAL b) {
471− return MKINT((i_int) (a->info.bits32 >= b->info.bits32));
312+ return MKINT((i_int) (GETBITS32(a) >= GETBITS32(b)));
474VAL idris_b32Compl(VM *vm, VAL a) {
315VAL idris_b32Compl(VM *vm, VAL a) {
475− uint32_t A = a->info.bits32;
316+ uint32_t A = GETBITS32(a);
476− VAL cl = allocate(sizeof(Closure), 0);
317+ return idris_b32const(vm, ~ A);
477− SETTY(cl, CT_BITS32);
478− cl->info.bits32 = ~ A;
482VAL idris_b32And(VM *vm, VAL a, VAL b) {
320VAL idris_b32And(VM *vm, VAL a, VAL b) {
483− uint32_t A = a->info.bits32;
321+ uint32_t A = GETBITS32(a);
484− uint32_t B = b->info.bits32;
322+ uint32_t B = GETBITS32(b);
485− VAL cl = allocate(sizeof(Closure), 0);
323+ return idris_b32const(vm, A & B);
486− SETTY(cl, CT_BITS32);
487− cl->info.bits32 = A & B;
491VAL idris_b32Or(VM *vm, VAL a, VAL b) {
326VAL idris_b32Or(VM *vm, VAL a, VAL b) {
492− uint32_t A = a->info.bits32;
327+ uint32_t A = GETBITS32(a);
493− uint32_t B = b->info.bits32;
328+ uint32_t B = GETBITS32(b);
494− VAL cl = allocate(sizeof(Closure), 0);
329+ return idris_b32const(vm, A | B);
495− SETTY(cl, CT_BITS32);
496− cl->info.bits32 = A | B;
500VAL idris_b32Xor(VM *vm, VAL a, VAL b) {
332VAL idris_b32Xor(VM *vm, VAL a, VAL b) {
501− uint32_t A = a->info.bits32;
333+ uint32_t A = GETBITS32(a);
502− uint32_t B = b->info.bits32;
334+ uint32_t B = GETBITS32(b);
503− VAL cl = allocate(sizeof(Closure), 0);
335+ return idris_b32const(vm, A ^ B);
504− SETTY(cl, CT_BITS32);
505− cl->info.bits32 = A ^ B;
509VAL idris_b32Shl(VM *vm, VAL a, VAL b) {
338VAL idris_b32Shl(VM *vm, VAL a, VAL b) {
510− uint32_t A = a->info.bits32;
339+ uint32_t A = GETBITS32(a);
511− uint32_t B = b->info.bits32;
340+ uint32_t B = GETBITS32(b);
512− VAL cl = allocate(sizeof(Closure), 0);
341+ return idris_b32const(vm, A << B);
513− SETTY(cl, CT_BITS32);
514− cl->info.bits32 = A << B;
518VAL idris_b32LShr(VM *vm, VAL a, VAL b) {
344VAL idris_b32LShr(VM *vm, VAL a, VAL b) {
519− uint32_t A = a->info.bits32;
345+ uint32_t A = GETBITS32(a);
520− uint32_t B = b->info.bits32;
346+ uint32_t B = GETBITS32(b);
521− VAL cl = allocate(sizeof(Closure), 0);
347+ return idris_b32const(vm, A >> B);
522− SETTY(cl, CT_BITS32);
523− cl->info.bits32 = A >> B;
527VAL idris_b32AShr(VM *vm, VAL a, VAL b) {
350VAL idris_b32AShr(VM *vm, VAL a, VAL b) {
528− uint32_t A = a->info.bits32;
351+ int32_t A = GETBITS32(a);
529− uint32_t B = b->info.bits32;
352+ int32_t B = GETBITS32(b);
530− VAL cl = allocate(sizeof(Closure), 0);
353+ return idris_b32const(vm, A >> B);
531− SETTY(cl, CT_BITS32);
532− cl->info.bits32 = (uint32_t) (((int32_t)A) >> ((int32_t)B));
536VAL idris_b64Plus(VM *vm, VAL a, VAL b) {
356VAL idris_b64Plus(VM *vm, VAL a, VAL b) {
537− uint64_t A = a->info.bits64;
357+ uint64_t A = GETBITS64(a);
538− uint64_t B = b->info.bits64;
358+ uint64_t B = GETBITS64(b);
539− VAL cl = allocate(sizeof(Closure), 0);
359+ return idris_b64const(vm, A + B);
540− SETTY(cl, CT_BITS64);
541− cl->info.bits64 = A + B;
545VAL idris_b64Minus(VM *vm, VAL a, VAL b) {
362VAL idris_b64Minus(VM *vm, VAL a, VAL b) {
546− uint64_t A = a->info.bits64;
363+ uint64_t A = GETBITS64(a);
547− uint64_t B = b->info.bits64;
364+ uint64_t B = GETBITS64(b);
548− VAL cl = allocate(sizeof(Closure), 0);
365+ return idris_b64const(vm, A - B);
549− SETTY(cl, CT_BITS64);
550− cl->info.bits64 = A - B;
554VAL idris_b64Times(VM *vm, VAL a, VAL b) {
368VAL idris_b64Times(VM *vm, VAL a, VAL b) {
555− uint64_t A = a->info.bits64;
369+ uint64_t A = GETBITS64(a);
556− uint64_t B = b->info.bits64;
370+ uint64_t B = GETBITS64(b);
557− VAL cl = allocate(sizeof(Closure), 0);
371+ return idris_b64const(vm, A * B);
558− SETTY(cl, CT_BITS64);
559− cl->info.bits64 = A * B;
563VAL idris_b64UDiv(VM *vm, VAL a, VAL b) {
374VAL idris_b64UDiv(VM *vm, VAL a, VAL b) {
564− uint64_t A = a->info.bits64;
375+ uint64_t A = GETBITS64(a);
565− uint64_t B = b->info.bits64;
376+ uint64_t B = GETBITS64(b);
566− VAL cl = allocate(sizeof(Closure), 0);
377+ return idris_b64const(vm, A / B);
567− SETTY(cl, CT_BITS64);
568− cl->info.bits64 = A / B;
572VAL idris_b64SDiv(VM *vm, VAL a, VAL b) {
380VAL idris_b64SDiv(VM *vm, VAL a, VAL b) {
573− uint64_t A = a->info.bits64;
381+ int64_t A = GETBITS64(a);
574− uint64_t B = b->info.bits64;
382+ int64_t B = GETBITS64(b);
575− VAL cl = allocate(sizeof(Closure), 0);
383+ return idris_b64const(vm, A / B);
576− SETTY(cl, CT_BITS64);
577− cl->info.bits64 = (uint64_t) (((int64_t) A) / ((int64_t) B));
581VAL idris_b64URem(VM *vm, VAL a, VAL b) {
386VAL idris_b64URem(VM *vm, VAL a, VAL b) {
582− uint64_t A = a->info.bits64;
387+ uint64_t A = GETBITS64(a);
583− uint64_t B = b->info.bits64;
388+ uint64_t B = GETBITS64(b);
584− VAL cl = allocate(sizeof(Closure), 0);
389+ return idris_b64const(vm, A % B);
585− SETTY(cl, CT_BITS64);
586− cl->info.bits64 = A % B;
590VAL idris_b64SRem(VM *vm, VAL a, VAL b) {
392VAL idris_b64SRem(VM *vm, VAL a, VAL b) {
591− uint64_t A = a->info.bits64;
393+ int64_t A = GETBITS64(a);
592− uint64_t B = b->info.bits64;
394+ int64_t B = GETBITS64(b);
593− VAL cl = allocate(sizeof(Closure), 0);
395+ return idris_b64const(vm, A % B);
594− SETTY(cl, CT_BITS64);
595− cl->info.bits64 = (uint64_t) (((int64_t) A) % ((int64_t) B));
599VAL idris_b64Lt(VM *vm, VAL a, VAL b) {
398VAL idris_b64Lt(VM *vm, VAL a, VAL b) {
399+ uint64_t A = GETBITS64(a);
400+ uint64_t B = GETBITS64(b);
600− return MKINT((i_int) (a->info.bits64 < b->info.bits64));
401+ return MKINT((i_int) (A < B));
603VAL idris_b64Gt(VM *vm, VAL a, VAL b) {
404VAL idris_b64Gt(VM *vm, VAL a, VAL b) {
405+ uint64_t A = GETBITS64(a);
406+ uint64_t B = GETBITS64(b);
604− return MKINT((i_int) (a->info.bits64 > b->info.bits64));
407+ return MKINT((i_int) (A > B));
607VAL idris_b64Eq(VM *vm, VAL a, VAL b) {
410VAL idris_b64Eq(VM *vm, VAL a, VAL b) {
411+ uint64_t A = GETBITS64(a);
412+ uint64_t B = GETBITS64(b);
608− return MKINT((i_int) (a->info.bits64 == b->info.bits64));
413+ return MKINT((i_int) (A == B));
611VAL idris_b64Lte(VM *vm, VAL a, VAL b) {
416VAL idris_b64Lte(VM *vm, VAL a, VAL b) {
417+ uint64_t A = GETBITS64(a);
418+ uint64_t B = GETBITS64(b);
612− return MKINT((i_int) (a->info.bits64 <= b->info.bits64));
419+ return MKINT((i_int) (A <= B));
615VAL idris_b64Gte(VM *vm, VAL a, VAL b) {
422VAL idris_b64Gte(VM *vm, VAL a, VAL b) {
423+ uint64_t A = GETBITS64(a);
424+ uint64_t B = GETBITS64(b);
616− return MKINT((i_int) (a->info.bits64 >= b->info.bits64));
425+ return MKINT((i_int) (A >= B));
619VAL idris_b64Compl(VM *vm, VAL a) {
428VAL idris_b64Compl(VM *vm, VAL a) {
620− uint64_t A = a->info.bits64;
429+ uint64_t A = GETBITS64(a);
621− VAL cl = allocate(sizeof(Closure), 0);
430+ return idris_b64const(vm, ~ A);
622− SETTY(cl, CT_BITS64);
623− cl->info.bits64 = ~ A;
627VAL idris_b64And(VM *vm, VAL a, VAL b) {
433VAL idris_b64And(VM *vm, VAL a, VAL b) {
628− uint64_t A = a->info.bits64;
434+ uint64_t A = GETBITS64(a);
629− uint64_t B = b->info.bits64;
435+ uint64_t B = GETBITS64(b);
630− VAL cl = allocate(sizeof(Closure), 0);
436+ return idris_b64const(vm, A & B);
631− SETTY(cl, CT_BITS64);
632− cl->info.bits64 = A & B;
636VAL idris_b64Or(VM *vm, VAL a, VAL b) {
439VAL idris_b64Or(VM *vm, VAL a, VAL b) {
637− uint64_t A = a->info.bits64;
440+ uint64_t A = GETBITS64(a);
638− uint64_t B = b->info.bits64;
441+ uint64_t B = GETBITS64(b);
639− VAL cl = allocate(sizeof(Closure), 0);
442+ return idris_b64const(vm, A | B);
640− SETTY(cl, CT_BITS64);
641− cl->info.bits64 = A | B;
645VAL idris_b64Xor(VM *vm, VAL a, VAL b) {
445VAL idris_b64Xor(VM *vm, VAL a, VAL b) {
646− uint64_t A = a->info.bits64;
446+ uint64_t A = GETBITS64(a);
647− uint64_t B = b->info.bits64;
447+ uint64_t B = GETBITS64(b);
648− VAL cl = allocate(sizeof(Closure), 0);
448+ return idris_b64const(vm, A ^ B);
649− SETTY(cl, CT_BITS64);
650− cl->info.bits64 = A ^ B;
654VAL idris_b64Shl(VM *vm, VAL a, VAL b) {
451VAL idris_b64Shl(VM *vm, VAL a, VAL b) {
655− uint64_t A = a->info.bits64;
452+ uint64_t A = GETBITS64(a);
656− uint64_t B = b->info.bits64;
453+ uint64_t B = GETBITS64(b);
657− VAL cl = allocate(sizeof(Closure), 0);
454+ return idris_b64const(vm, A << B);
658− SETTY(cl, CT_BITS64);
659− cl->info.bits64 = A << B;
663VAL idris_b64LShr(VM *vm, VAL a, VAL b) {
457VAL idris_b64LShr(VM *vm, VAL a, VAL b) {
664− uint64_t A = a->info.bits64;
458+ uint64_t A = GETBITS64(a);
665− uint64_t B = b->info.bits64;
459+ uint64_t B = GETBITS64(b);
666− VAL cl = allocate(sizeof(Closure), 0);
460+ return idris_b64const(vm, A >> B);
667− SETTY(cl, CT_BITS64);
668− cl->info.bits64 = A >> B;
672VAL idris_b64AShr(VM *vm, VAL a, VAL b) {
463VAL idris_b64AShr(VM *vm, VAL a, VAL b) {
673− uint64_t A = a->info.bits64;
464+ int64_t A = GETBITS64(a);
674− uint64_t B = b->info.bits64;
465+ int64_t B = GETBITS64(b);
675− VAL cl = allocate(sizeof(Closure), 0);
466+ return idris_b64const(vm, A >> B);
676− SETTY(cl, CT_BITS64);
677− cl->info.bits64 = (uint64_t) (((int64_t) A) >> ((int64_t) B));
681VAL idris_b8Z16(VM *vm, VAL a) {
469VAL idris_b8Z16(VM *vm, VAL a) {
682− uint8_t A = a->info.bits8;
470+ uint8_t A = GETBITS8(a);
683− VAL cl = allocate(sizeof(Closure), 0);
471+ return idris_b16const(vm, A);
684− SETTY(cl, CT_BITS16);
685− cl->info.bits16 = (uint16_t) A;
689VAL idris_b8Z32(VM *vm, VAL a) {
474VAL idris_b8Z32(VM *vm, VAL a) {
690− uint8_t A = a->info.bits8;
475+ uint8_t A = GETBITS8(a);
691− VAL cl = allocate(sizeof(Closure), 0);
476+ return idris_b32const(vm, A);
692− SETTY(cl, CT_BITS32);
693− cl->info.bits32 = (uint32_t) A;
697VAL idris_b8Z64(VM *vm, VAL a) {
479VAL idris_b8Z64(VM *vm, VAL a) {
698− uint8_t A = a->info.bits8;
480+ uint8_t A = GETBITS8(a);
699− VAL cl = allocate(sizeof(Closure), 0);
481+ return idris_b64const(vm, A);
700− SETTY(cl, CT_BITS64);
701− cl->info.bits64 = (uint64_t) A;
705VAL idris_b8S16(VM *vm, VAL a) {
484VAL idris_b8S16(VM *vm, VAL a) {
706− uint8_t A = a->info.bits8;
485+ int8_t A = GETBITS8(a);
707− VAL cl = allocate(sizeof(Closure), 0);
486+ return idris_b16const(vm, (int16_t) A);
708− SETTY(cl, CT_BITS16);
709− cl->info.bits16 = (uint16_t) (int16_t) (int8_t) A;
713VAL idris_b8S32(VM *vm, VAL a) {
489VAL idris_b8S32(VM *vm, VAL a) {
714− uint8_t A = a->info.bits8;
490+ int8_t A = GETBITS8(a);
715− VAL cl = allocate(sizeof(Closure), 0);
491+ return idris_b32const(vm, (int32_t) A);
716− SETTY(cl, CT_BITS32);
717− cl->info.bits32 = (uint32_t) (int32_t) (int8_t) A;
721VAL idris_b8S64(VM *vm, VAL a) {
494VAL idris_b8S64(VM *vm, VAL a) {
722− uint8_t A = a->info.bits8;
495+ int8_t A = GETBITS8(a);
723− VAL cl = allocate(sizeof(Closure), 0);
496+ return idris_b64const(vm, (int64_t) A);
724− SETTY(cl, CT_BITS64);
725− cl->info.bits64 = (uint64_t) (int64_t) (int8_t) A;
729VAL idris_b16Z32(VM *vm, VAL a) {
499VAL idris_b16Z32(VM *vm, VAL a) {
730− uint16_t A = a->info.bits16;
500+ uint16_t A = GETBITS16(a);
731− VAL cl = allocate(sizeof(Closure), 0);
501+ return idris_b32const(vm, (uint32_t) A);
732− SETTY(cl, CT_BITS32);
733− cl->info.bits32 = (uint32_t) A;
737VAL idris_b16Z64(VM *vm, VAL a) {
504VAL idris_b16Z64(VM *vm, VAL a) {
738− uint16_t A = a->info.bits16;
505+ uint16_t A = GETBITS16(a);
739− VAL cl = allocate(sizeof(Closure), 0);
506+ return idris_b64const(vm, (uint64_t) A);
740− SETTY(cl, CT_BITS64);
741− cl->info.bits64 = (uint64_t) A;
745VAL idris_b16S32(VM *vm, VAL a) {
509VAL idris_b16S32(VM *vm, VAL a) {
746− uint16_t A = a->info.bits16;
510+ int16_t A = GETBITS16(a);
747− VAL cl = allocate(sizeof(Closure), 0);
511+ return idris_b32const(vm, (int32_t) A);
748− SETTY(cl, CT_BITS32);
749− cl->info.bits32 = (uint32_t) (int32_t) (int16_t) A;
753VAL idris_b16S64(VM *vm, VAL a) {
514VAL idris_b16S64(VM *vm, VAL a) {
754− uint16_t A = a->info.bits16;
515+ int16_t A = GETBITS16(a);
755− VAL cl = allocate(sizeof(Closure), 0);
516+ return idris_b64const(vm, (int64_t) A);
756− SETTY(cl, CT_BITS64);
757− cl->info.bits64 = (uint64_t) (int64_t) (int16_t) A;
761VAL idris_b16T8(VM *vm, VAL a) {
519VAL idris_b16T8(VM *vm, VAL a) {
762− uint16_t A = a->info.bits16;
520+ uint16_t A = GETBITS16(a);
763− VAL cl = allocate(sizeof(Closure), 0);
521+ return idris_b8const(vm, (uint8_t) A);
764− SETTY(cl, CT_BITS8);
765− cl->info.bits8 = (uint8_t) A;
769VAL idris_b32Z64(VM *vm, VAL a) {
524VAL idris_b32Z64(VM *vm, VAL a) {
770− uint32_t A = a->info.bits32;
525+ uint32_t A = GETBITS32(a);
771− VAL cl = allocate(sizeof(Closure), 0);
526+ return idris_b64const(vm, (uint64_t) A);
772− SETTY(cl, CT_BITS64);
773− cl->info.bits64 = (uint64_t) A;
777VAL idris_b32S64(VM *vm, VAL a) {
529VAL idris_b32S64(VM *vm, VAL a) {
778− uint32_t A = a->info.bits32;
530+ int32_t A = GETBITS32(a);
779− VAL cl = allocate(sizeof(Closure), 0);
531+ return idris_b64const(vm, (int64_t) A);
780− SETTY(cl, CT_BITS64);
781− cl->info.bits64 = (uint64_t) (int64_t) (int32_t) A;
785VAL idris_b32T8(VM *vm, VAL a) {
534VAL idris_b32T8(VM *vm, VAL a) {
786− uint32_t A = a->info.bits32;
535+ uint32_t A = GETBITS32(a);
787− VAL cl = allocate(sizeof(Closure), 0);
536+ return idris_b8const(vm, (uint8_t) A);
788− SETTY(cl, CT_BITS8);
789− cl->info.bits8 = (uint8_t) A;
793VAL idris_b32T16(VM *vm, VAL a) {
539VAL idris_b32T16(VM *vm, VAL a) {
794− uint32_t A = a->info.bits32;
540+ uint32_t A = GETBITS32(a);
795− VAL cl = allocate(sizeof(Closure), 0);
541+ return idris_b16const(vm, (uint16_t) A);
796− SETTY(cl, CT_BITS16);
797− cl->info.bits16 = (uint16_t) A;
801VAL idris_b64T8(VM *vm, VAL a) {
544VAL idris_b64T8(VM *vm, VAL a) {
802− uint64_t A = a->info.bits64;
545+ uint64_t A = GETBITS64(a);
803− VAL cl = allocate(sizeof(Closure), 0);
546+ return idris_b8const(vm, (uint8_t) A);
804− SETTY(cl, CT_BITS8);
805− cl->info.bits8 = (uint8_t) A;
809VAL idris_b64T16(VM *vm, VAL a) {
549VAL idris_b64T16(VM *vm, VAL a) {
810− uint64_t A = a->info.bits64;
550+ uint64_t A = GETBITS64(a);
811− VAL cl = allocate(sizeof(Closure), 0);
551+ return idris_b16const(vm, (uint16_t) A);
812− SETTY(cl, CT_BITS16);
813− cl->info.bits16 = (uint16_t) A;
817VAL idris_b64T32(VM *vm, VAL a) {
554VAL idris_b64T32(VM *vm, VAL a) {
818− uint64_t A = a->info.bits64;
555+ uint64_t A = GETBITS64(a);
819− VAL cl = allocate(sizeof(Closure), 0);
556+ return idris_b32const(vm, (uint32_t) A);
820− SETTY(cl, CT_BITS32);
821− cl->info.bits32 = (uint32_t) A;
825VAL idris_peekB8(VM* vm, VAL ptr, VAL offset) {
559VAL idris_peekB8(VM* vm, VAL ptr, VAL offset) {