@@ -0,0 +1,666 @@
1+#include "idris_rts.h"
2+
3+VAL idris_b8CopyForGC(VM *vm, VAL a) {
4+ VAL cl = allocate(vm, sizeof(Closure), 1);
5+ SETTY(cl, BITS8);
6+ cl->info.bits8 = a->info.bits8;
7+ return cl;
8+}
9+
10+VAL idris_b16CopyForGC(VM *vm, VAL a) {
11+ VAL cl = allocate(vm, sizeof(Closure), 1);
12+ SETTY(cl, BITS16);
13+ cl->info.bits16 = a->info.bits16;
14+ return cl;
15+}
16+
17+VAL idris_b32CopyForGC(VM *vm, VAL a) {
18+ VAL cl = allocate(vm, sizeof(Closure), 1);
19+ SETTY(cl, BITS32);
20+ cl->info.bits32 = a->info.bits32;
21+ return cl;
22+}
23+
24+VAL idris_b64CopyForGC(VM *vm, VAL a) {
25+ VAL cl = allocate(vm, sizeof(Closure), 1);
26+ SETTY(cl, BITS64);
27+ cl->info.bits64 = a->info.bits64;
28+ return cl;
29+}
30+
31+VAL idris_b8(VM *vm, VAL a) {
32+ VAL cl = allocate(vm, sizeof(Closure), 0);
33+ SETTY(cl, BITS8);
34+ cl->info.bits8 = (uint8_t) GETINT(a);
35+ return cl;
36+}
37+
38+VAL idris_b16(VM *vm, VAL a) {
39+ VAL cl = allocate(vm, sizeof(Closure), 0);
40+ SETTY(cl, BITS16);
41+ cl->info.bits16 = (uint16_t) GETINT(a);
42+ return cl;
43+}
44+
45+VAL idris_b32(VM *vm, VAL a) {
46+ VAL cl = allocate(vm, sizeof(Closure), 0);
47+ SETTY(cl, BITS32);
48+ cl->info.bits32 = (uint32_t) GETINT(a);
49+ return cl;
50+}
51+
52+VAL idris_b64(VM *vm, VAL a) {
53+ VAL cl = allocate(vm, sizeof(Closure), 0);
54+ SETTY(cl, BITS64);
55+ cl->info.bits64 = (uint64_t) GETINT(a);
56+ return cl;
57+}
58+
59+VAL idris_castB32Int(VM *vm, VAL a) {
60+ return MKINT((i_int)a->info.bits32);
61+}
62+
63+VAL idris_b8Plus(VM *vm, VAL a, VAL b) {
64+ VAL cl = allocate(vm, sizeof(Closure), 0);
65+ SETTY(cl, BITS8);
66+ cl->info.bits8 = a->info.bits8 + b->info.bits8;
67+ return cl;
68+}
69+
70+VAL idris_b8Minus(VM *vm, VAL a, VAL b) {
71+ VAL cl = allocate(vm, sizeof(Closure), 0);
72+ SETTY(cl, BITS8);
73+ cl->info.bits8 = a->info.bits8 - b->info.bits8;
74+ return cl;
75+}
76+
77+VAL idris_b8Times(VM *vm, VAL a, VAL b) {
78+ VAL cl = allocate(vm, sizeof(Closure), 0);
79+ SETTY(cl, BITS8);
80+ cl->info.bits8 = a->info.bits8 * b->info.bits8;
81+ return cl;
82+}
83+
84+VAL idris_b8UDiv(VM *vm, VAL a, VAL b) {
85+ VAL cl = allocate(vm, sizeof(Closure), 0);
86+ SETTY(cl, BITS8);
87+ cl->info.bits8 = a->info.bits8 / b->info.bits8;
88+ return cl;
89+}
90+
91+VAL idris_b8SDiv(VM *vm, VAL a, VAL b) {
92+ VAL cl = allocate(vm, sizeof(Closure), 0);
93+ SETTY(cl, BITS8);
94+ cl->info.bits8 = (uint8_t) (((int8_t) a->info.bits8) / ((int8_t) b->info.bits8));
95+ return cl;
96+}
97+
98+VAL idris_b8URem(VM *vm, VAL a, VAL b) {
99+ VAL cl = allocate(vm, sizeof(Closure), 0);
100+ SETTY(cl, BITS8);
101+ cl->info.bits8 = a->info.bits8 % b->info.bits8;
102+ return cl;
103+}
104+
105+VAL idris_b8SRem(VM *vm, VAL a, VAL b) {
106+ VAL cl = allocate(vm, sizeof(Closure), 0);
107+ SETTY(cl, BITS8);
108+ cl->info.bits8 = (uint8_t) (((int8_t) a->info.bits8) % ((int8_t) b->info.bits8));
109+ return cl;
110+}
111+
112+VAL idris_b8Lt(VM *vm, VAL a, VAL b) {
113+ return MKINT((i_int) (a->info.bits8 < b->info.bits8));
114+}
115+
116+VAL idris_b8Gt(VM *vm, VAL a, VAL b) {
117+ return MKINT((i_int) (a->info.bits8 > b->info.bits8));
118+}
119+
120+VAL idris_b8Eq(VM *vm, VAL a, VAL b) {
121+ return MKINT((i_int) (a->info.bits8 == b->info.bits8));
122+}
123+
124+VAL idris_b8Lte(VM *vm, VAL a, VAL b) {
125+ return MKINT((i_int) (a->info.bits8 <= b->info.bits8));
126+}
127+
128+VAL idris_b8Gte(VM *vm, VAL a, VAL b) {
129+ return MKINT((i_int) (a->info.bits8 >= b->info.bits8));
130+}
131+
132+VAL idris_b8Compl(VM *vm, VAL a) {
133+ VAL cl = allocate(vm, sizeof(Closure), 0);
134+ SETTY(cl, BITS8);
135+ cl->info.bits8 = ~ a->info.bits8;
136+ return cl;
137+}
138+
139+VAL idris_b8And(VM *vm, VAL a, VAL b) {
140+ VAL cl = allocate(vm, sizeof(Closure), 0);
141+ SETTY(cl, BITS8);
142+ cl->info.bits8 = a->info.bits8 & b->info.bits8;
143+ return cl;
144+}
145+
146+VAL idris_b8Or(VM *vm, VAL a, VAL b) {
147+ VAL cl = allocate(vm, sizeof(Closure), 0);
148+ SETTY(cl, BITS8);
149+ cl->info.bits8 = a->info.bits8 | b->info.bits8;
150+ return cl;
151+}
152+
153+VAL idris_b8Xor(VM *vm, VAL a, VAL b) {
154+ VAL cl = allocate(vm, sizeof(Closure), 0);
155+ SETTY(cl, BITS8);
156+ cl->info.bits8 = a->info.bits8 ^ b->info.bits8;
157+ return cl;
158+}
159+
160+VAL idris_b8Shl(VM *vm, VAL a, VAL b) {
161+ VAL cl = allocate(vm, sizeof(Closure), 0);
162+ SETTY(cl, BITS8);
163+ cl->info.bits8 = a->info.bits8 << b->info.bits8;
164+ return cl;
165+}
166+
167+VAL idris_b8LShr(VM *vm, VAL a, VAL b) {
168+ VAL cl = allocate(vm, sizeof(Closure), 0);
169+ SETTY(cl, BITS8);
170+ cl->info.bits8 = a->info.bits8 >> b->info.bits8;
171+ return cl;
172+}
173+
174+VAL idris_b8AShr(VM *vm, VAL a, VAL b) {
175+ VAL cl = allocate(vm, sizeof(Closure), 0);
176+ SETTY(cl, BITS8);
177+ cl->info.bits8 = (uint8_t) (((int8_t)a->info.bits8) >> ((int8_t)b->info.bits8));
178+ return cl;
179+}
180+
181+VAL idris_b16Plus(VM *vm, VAL a, VAL b) {
182+ VAL cl = allocate(vm, sizeof(Closure), 0);
183+ SETTY(cl, BITS16);
184+ cl->info.bits16 = a->info.bits16 + b->info.bits16;
185+ return cl;
186+}
187+
188+VAL idris_b16Minus(VM *vm, VAL a, VAL b) {
189+ VAL cl = allocate(vm, sizeof(Closure), 0);
190+ SETTY(cl, BITS16);
191+ cl->info.bits16 = a->info.bits16 - b->info.bits16;
192+ return cl;
193+}
194+
195+VAL idris_b16Times(VM *vm, VAL a, VAL b) {
196+ VAL cl = allocate(vm, sizeof(Closure), 0);
197+ SETTY(cl, BITS16);
198+ cl->info.bits16 = a->info.bits16 * b->info.bits16;
199+ return cl;
200+}
201+
202+VAL idris_b16UDiv(VM *vm, VAL a, VAL b) {
203+ VAL cl = allocate(vm, sizeof(Closure), 0);
204+ SETTY(cl, BITS16);
205+ cl->info.bits16 = a->info.bits16 / b->info.bits16;
206+ return cl;
207+}
208+
209+VAL idris_b16SDiv(VM *vm, VAL a, VAL b) {
210+ VAL cl = allocate(vm, sizeof(Closure), 0);
211+ SETTY(cl, BITS16);
212+ cl->info.bits16 =
213+ (uint16_t) (((int16_t) a->info.bits16) / ((int16_t) b->info.bits16));
214+ return cl;
215+}
216+
217+VAL idris_b16URem(VM *vm, VAL a, VAL b) {
218+ VAL cl = allocate(vm, sizeof(Closure), 0);
219+ SETTY(cl, BITS16);
220+ cl->info.bits16 = a->info.bits16 % b->info.bits16;
221+ return cl;
222+}
223+
224+VAL idris_b16SRem(VM *vm, VAL a, VAL b) {
225+ VAL cl = allocate(vm, sizeof(Closure), 0);
226+ SETTY(cl, BITS16);
227+ cl->info.bits16 =
228+ (uint16_t) (((int16_t) a->info.bits16) % ((int16_t) b->info.bits16));
229+ return cl;
230+}
231+
232+VAL idris_b16Lt(VM *vm, VAL a, VAL b) {
233+ return MKINT((i_int) (a->info.bits16 < b->info.bits16));
234+}
235+
236+VAL idris_b16Gt(VM *vm, VAL a, VAL b) {
237+ return MKINT((i_int) (a->info.bits16 > b->info.bits16));
238+}
239+
240+VAL idris_b16Eq(VM *vm, VAL a, VAL b) {
241+ return MKINT((i_int) (a->info.bits16 == b->info.bits16));
242+}
243+
244+VAL idris_b16Lte(VM *vm, VAL a, VAL b) {
245+ return MKINT((i_int) (a->info.bits16 <= b->info.bits16));
246+}
247+
248+VAL idris_b16Gte(VM *vm, VAL a, VAL b) {
249+ return MKINT((i_int) (a->info.bits16 >= b->info.bits16));
250+}
251+
252+VAL idris_b16Compl(VM *vm, VAL a) {
253+ VAL cl = allocate(vm, sizeof(Closure), 0);
254+ SETTY(cl, BITS16);
255+ cl->info.bits16 = ~ a->info.bits16;
256+ return cl;
257+}
258+
259+VAL idris_b16And(VM *vm, VAL a, VAL b) {
260+ VAL cl = allocate(vm, sizeof(Closure), 0);
261+ SETTY(cl, BITS16);
262+ cl->info.bits16 = a->info.bits16 & b->info.bits16;
263+ return cl;
264+}
265+
266+VAL idris_b16Or(VM *vm, VAL a, VAL b) {
267+ VAL cl = allocate(vm, sizeof(Closure), 0);
268+ SETTY(cl, BITS16);
269+ cl->info.bits16 = a->info.bits16 | b->info.bits16;
270+ return cl;
271+}
272+
273+VAL idris_b16Xor(VM *vm, VAL a, VAL b) {
274+ VAL cl = allocate(vm, sizeof(Closure), 0);
275+ SETTY(cl, BITS16);
276+ cl->info.bits16 = a->info.bits16 ^ b->info.bits16;
277+ return cl;
278+}
279+
280+VAL idris_b16Shl(VM *vm, VAL a, VAL b) {
281+ VAL cl = allocate(vm, sizeof(Closure), 0);
282+ SETTY(cl, BITS16);
283+ cl->info.bits16 = a->info.bits16 << b->info.bits16;
284+ return cl;
285+}
286+
287+VAL idris_b16LShr(VM *vm, VAL a, VAL b) {
288+ VAL cl = allocate(vm, sizeof(Closure), 0);
289+ SETTY(cl, BITS16);
290+ cl->info.bits16 = a->info.bits16 >> b->info.bits16;
291+ return cl;
292+}
293+
294+VAL idris_b16AShr(VM *vm, VAL a, VAL b) {
295+ VAL cl = allocate(vm, sizeof(Closure), 0);
296+ SETTY(cl, BITS16);
297+ cl->info.bits16 = (uint16_t) (((int16_t)a->info.bits16) >> ((int16_t)b->info.bits16));
298+ return cl;
299+}
300+
301+VAL idris_b32Plus(VM *vm, VAL a, VAL b) {
302+ VAL cl = allocate(vm, sizeof(Closure), 0);
303+ SETTY(cl, BITS32);
304+ cl->info.bits32 = a->info.bits32 + b->info.bits32;
305+ return cl;
306+}
307+
308+VAL idris_b32Minus(VM *vm, VAL a, VAL b) {
309+ VAL cl = allocate(vm, sizeof(Closure), 0);
310+ SETTY(cl, BITS32);
311+ cl->info.bits32 = a->info.bits32 - b->info.bits32;
312+ return cl;
313+}
314+
315+VAL idris_b32Times(VM *vm, VAL a, VAL b) {
316+ VAL cl = allocate(vm, sizeof(Closure), 0);
317+ SETTY(cl, BITS32);
318+ cl->info.bits32 = a->info.bits32 * b->info.bits32;
319+ return cl;
320+}
321+
322+VAL idris_b32UDiv(VM *vm, VAL a, VAL b) {
323+ VAL cl = allocate(vm, sizeof(Closure), 0);
324+ SETTY(cl, BITS32);
325+ cl->info.bits32 = a->info.bits32 / b->info.bits32;
326+ return cl;
327+}
328+
329+VAL idris_b32SDiv(VM *vm, VAL a, VAL b) {
330+ VAL cl = allocate(vm, sizeof(Closure), 0);
331+ SETTY(cl, BITS32);
332+ cl->info.bits32 =
333+ (uint32_t) (((int32_t) a->info.bits32) / ((int32_t) b->info.bits32));
334+ return cl;
335+}
336+
337+VAL idris_b32URem(VM *vm, VAL a, VAL b) {
338+ VAL cl = allocate(vm, sizeof(Closure), 0);
339+ SETTY(cl, BITS32);
340+ cl->info.bits32 = a->info.bits32 % b->info.bits32;
341+ return cl;
342+}
343+
344+VAL idris_b32SRem(VM *vm, VAL a, VAL b) {
345+ VAL cl = allocate(vm, sizeof(Closure), 0);
346+ SETTY(cl, BITS32);
347+ cl->info.bits32 =
348+ (uint32_t) (((int32_t) a->info.bits32) % ((int32_t) b->info.bits32));
349+ return cl;
350+}
351+
352+VAL idris_b32Lt(VM *vm, VAL a, VAL b) {
353+ return MKINT((i_int) (a->info.bits32 < b->info.bits32));
354+}
355+
356+VAL idris_b32Gt(VM *vm, VAL a, VAL b) {
357+ return MKINT((i_int) (a->info.bits32 > b->info.bits32));
358+}
359+
360+VAL idris_b32Eq(VM *vm, VAL a, VAL b) {
361+ return MKINT((i_int) (a->info.bits32 == b->info.bits32));
362+}
363+
364+VAL idris_b32Lte(VM *vm, VAL a, VAL b) {
365+ return MKINT((i_int) (a->info.bits32 <= b->info.bits32));
366+}
367+
368+VAL idris_b32Gte(VM *vm, VAL a, VAL b) {
369+ return MKINT((i_int) (a->info.bits32 >= b->info.bits32));
370+}
371+
372+VAL idris_b32Compl(VM *vm, VAL a) {
373+ VAL cl = allocate(vm, sizeof(Closure), 0);
374+ SETTY(cl, BITS32);
375+ cl->info.bits32 = ~ a->info.bits32;
376+ return cl;
377+}
378+
379+VAL idris_b32And(VM *vm, VAL a, VAL b) {
380+ VAL cl = allocate(vm, sizeof(Closure), 0);
381+ SETTY(cl, BITS32);
382+ cl->info.bits32 = a->info.bits32 & b->info.bits32;
383+ return cl;
384+}
385+
386+VAL idris_b32Or(VM *vm, VAL a, VAL b) {
387+ VAL cl = allocate(vm, sizeof(Closure), 0);
388+ SETTY(cl, BITS32);
389+ cl->info.bits32 = a->info.bits32 | b->info.bits32;
390+ return cl;
391+}
392+
393+VAL idris_b32Xor(VM *vm, VAL a, VAL b) {
394+ VAL cl = allocate(vm, sizeof(Closure), 0);
395+ SETTY(cl, BITS32);
396+ cl->info.bits32 = a->info.bits32 ^ b->info.bits32;
397+ return cl;
398+}
399+
400+VAL idris_b32Shl(VM *vm, VAL a, VAL b) {
401+ VAL cl = allocate(vm, sizeof(Closure), 0);
402+ SETTY(cl, BITS32);
403+ cl->info.bits32 = a->info.bits32 << b->info.bits32;
404+ return cl;
405+}
406+
407+VAL idris_b32LShr(VM *vm, VAL a, VAL b) {
408+ VAL cl = allocate(vm, sizeof(Closure), 0);
409+ SETTY(cl, BITS32);
410+ cl->info.bits32 = a->info.bits32 >> b->info.bits32;
411+ return cl;
412+}
413+
414+VAL idris_b32AShr(VM *vm, VAL a, VAL b) {
415+ VAL cl = allocate(vm, sizeof(Closure), 0);
416+ SETTY(cl, BITS32);
417+ cl->info.bits32 = (uint32_t) (((int32_t)a->info.bits32) >> ((int32_t)b->info.bits32));
418+ return cl;
419+}
420+
421+VAL idris_b64Plus(VM *vm, VAL a, VAL b) {
422+ VAL cl = allocate(vm, sizeof(Closure), 0);
423+ SETTY(cl, BITS64);
424+ cl->info.bits64 = a->info.bits64 + b->info.bits64;
425+ return cl;
426+}
427+
428+VAL idris_b64Minus(VM *vm, VAL a, VAL b) {
429+ VAL cl = allocate(vm, sizeof(Closure), 0);
430+ SETTY(cl, BITS64);
431+ cl->info.bits64 = a->info.bits64 - b->info.bits64;
432+ return cl;
433+}
434+
435+VAL idris_b64Times(VM *vm, VAL a, VAL b) {
436+ VAL cl = allocate(vm, sizeof(Closure), 0);
437+ SETTY(cl, BITS64);
438+ cl->info.bits64 = a->info.bits64 * b->info.bits64;
439+ return cl;
440+}
441+
442+VAL idris_b64UDiv(VM *vm, VAL a, VAL b) {
443+ VAL cl = allocate(vm, sizeof(Closure), 0);
444+ SETTY(cl, BITS64);
445+ cl->info.bits64 = a->info.bits64 / b->info.bits64;
446+ return cl;
447+}
448+
449+VAL idris_b64SDiv(VM *vm, VAL a, VAL b) {
450+ VAL cl = allocate(vm, sizeof(Closure), 0);
451+ SETTY(cl, BITS64);
452+ cl->info.bits64 =
453+ (uint64_t) (((int64_t) a->info.bits64) / ((int64_t) b->info.bits64));
454+ return cl;
455+}
456+
457+VAL idris_b64URem(VM *vm, VAL a, VAL b) {
458+ VAL cl = allocate(vm, sizeof(Closure), 0);
459+ SETTY(cl, BITS64);
460+ cl->info.bits64 = a->info.bits64 % b->info.bits64;
461+ return cl;
462+}
463+
464+VAL idris_b64SRem(VM *vm, VAL a, VAL b) {
465+ VAL cl = allocate(vm, sizeof(Closure), 0);
466+ SETTY(cl, BITS64);
467+ cl->info.bits64 =
468+ (uint64_t) (((int64_t) a->info.bits64) % ((int64_t) b->info.bits64));
469+ return cl;
470+}
471+
472+VAL idris_b64Lt(VM *vm, VAL a, VAL b) {
473+ return MKINT((i_int) (a->info.bits64 < b->info.bits64));
474+}
475+
476+VAL idris_b64Gt(VM *vm, VAL a, VAL b) {
477+ return MKINT((i_int) (a->info.bits64 > b->info.bits64));
478+}
479+
480+VAL idris_b64Eq(VM *vm, VAL a, VAL b) {
481+ return MKINT((i_int) (a->info.bits64 == b->info.bits64));
482+}
483+
484+VAL idris_b64Lte(VM *vm, VAL a, VAL b) {
485+ return MKINT((i_int) (a->info.bits64 <= b->info.bits64));
486+}
487+
488+VAL idris_b64Gte(VM *vm, VAL a, VAL b) {
489+ return MKINT((i_int) (a->info.bits64 >= b->info.bits64));
490+}
491+
492+VAL idris_b64Compl(VM *vm, VAL a) {
493+ VAL cl = allocate(vm, sizeof(Closure), 0);
494+ SETTY(cl, BITS64);
495+ cl->info.bits64 = ~ a->info.bits64;
496+ return cl;
497+}
498+
499+VAL idris_b64And(VM *vm, VAL a, VAL b) {
500+ VAL cl = allocate(vm, sizeof(Closure), 0);
501+ SETTY(cl, BITS64);
502+ cl->info.bits64 = a->info.bits64 & b->info.bits64;
503+ return cl;
504+}
505+
506+VAL idris_b64Or(VM *vm, VAL a, VAL b) {
507+ VAL cl = allocate(vm, sizeof(Closure), 0);
508+ SETTY(cl, BITS64);
509+ cl->info.bits64 = a->info.bits64 | b->info.bits64;
510+ return cl;
511+}
512+
513+VAL idris_b64Xor(VM *vm, VAL a, VAL b) {
514+ VAL cl = allocate(vm, sizeof(Closure), 0);
515+ SETTY(cl, BITS64);
516+ cl->info.bits64 = a->info.bits64 ^ b->info.bits64;
517+ return cl;
518+}
519+
520+VAL idris_b64Shl(VM *vm, VAL a, VAL b) {
521+ VAL cl = allocate(vm, sizeof(Closure), 0);
522+ SETTY(cl, BITS64);
523+ cl->info.bits64 = a->info.bits64 << b->info.bits64;
524+ return cl;
525+}
526+
527+VAL idris_b64LShr(VM *vm, VAL a, VAL b) {
528+ VAL cl = allocate(vm, sizeof(Closure), 0);
529+ SETTY(cl, BITS64);
530+ cl->info.bits64 = a->info.bits64 >> b->info.bits64;
531+ return cl;
532+}
533+
534+VAL idris_b64AShr(VM *vm, VAL a, VAL b) {
535+ VAL cl = allocate(vm, sizeof(Closure), 0);
536+ SETTY(cl, BITS64);
537+ cl->info.bits64 = (uint64_t) (((int64_t)a->info.bits64) >> ((int64_t)b->info.bits64));
538+ return cl;
539+}
540+
541+VAL idris_b8Z16(VM *vm, VAL a) {
542+ VAL cl = allocate(vm, sizeof(Closure), 0);
543+ SETTY(cl, BITS16);
544+ cl->info.bits16 = (uint16_t) a->info.bits8;
545+ return cl;
546+}
547+
548+VAL idris_b8Z32(VM *vm, VAL a) {
549+ VAL cl = allocate(vm, sizeof(Closure), 0);
550+ SETTY(cl, BITS32);
551+ cl->info.bits32 = (uint32_t) a->info.bits8;
552+ return cl;
553+}
554+
555+VAL idris_b8Z64(VM *vm, VAL a) {
556+ VAL cl = allocate(vm, sizeof(Closure), 0);
557+ SETTY(cl, BITS16);
558+ cl->info.bits64 = (uint64_t) a->info.bits8;
559+ return cl;
560+}
561+
562+VAL idris_b8S16(VM *vm, VAL a) {
563+ VAL cl = allocate(vm, sizeof(Closure), 0);
564+ SETTY(cl, BITS16);
565+ cl->info.bits16 = (uint16_t) (int16_t) (int8_t) a->info.bits8;
566+ return cl;
567+}
568+
569+VAL idris_b8S32(VM *vm, VAL a) {
570+ VAL cl = allocate(vm, sizeof(Closure), 0);
571+ SETTY(cl, BITS32);
572+ cl->info.bits32 = (uint32_t) (int32_t) (int8_t) a->info.bits8;
573+ return cl;
574+}
575+
576+VAL idris_b8S64(VM *vm, VAL a) {
577+ VAL cl = allocate(vm, sizeof(Closure), 0);
578+ SETTY(cl, BITS64);
579+ cl->info.bits64 = (uint64_t) (int64_t) (int8_t) a->info.bits8;
580+ return cl;
581+}
582+
583+VAL idris_b16Z32(VM *vm, VAL a) {
584+ VAL cl = allocate(vm, sizeof(Closure), 0);
585+ SETTY(cl, BITS32);
586+ cl->info.bits32 = (uint32_t) a->info.bits16;
587+ return cl;
588+}
589+
590+VAL idris_b16Z64(VM *vm, VAL a) {
591+ VAL cl = allocate(vm, sizeof(Closure), 0);
592+ SETTY(cl, BITS64);
593+ cl->info.bits64 = (uint64_t) a->info.bits16;
594+ return cl;
595+}
596+
597+VAL idris_b16S32(VM *vm, VAL a) {
598+ VAL cl = allocate(vm, sizeof(Closure), 0);
599+ SETTY(cl, BITS32);
600+ cl->info.bits32 = (uint32_t) (int32_t) (int16_t) a->info.bits16;
601+ return cl;
602+}
603+
604+VAL idris_b16S64(VM *vm, VAL a) {
605+ VAL cl = allocate(vm, sizeof(Closure), 0);
606+ SETTY(cl, BITS64);
607+ cl->info.bits64 = (uint64_t) (int64_t) (int16_t) a->info.bits16;
608+ return cl;
609+}
610+
611+VAL idris_b16T8(VM *vm, VAL a) {
612+ VAL cl = allocate(vm, sizeof(Closure), 0);
613+ SETTY(cl, BITS8);
614+ cl->info.bits8 = (uint8_t) a->info.bits16;
615+ return cl;
616+}
617+
618+VAL idris_b32Z64(VM *vm, VAL a) {
619+ VAL cl = allocate(vm, sizeof(Closure), 0);
620+ SETTY(cl, BITS64);
621+ cl->info.bits64 = (uint64_t) a->info.bits32;
622+ return cl;
623+}
624+
625+VAL idris_b32S64(VM *vm, VAL a) {
626+ VAL cl = allocate(vm, sizeof(Closure), 0);
627+ SETTY(cl, BITS64);
628+ cl->info.bits64 = (uint64_t) (int64_t) (int32_t) a->info.bits32;
629+ return cl;
630+}
631+
632+VAL idris_b32T8(VM *vm, VAL a) {
633+ VAL cl = allocate(vm, sizeof(Closure), 0);
634+ SETTY(cl, BITS8);
635+ cl->info.bits8 = (uint8_t) a->info.bits32;
636+ return cl;
637+}
638+
639+VAL idris_b32T16(VM *vm, VAL a) {
640+ VAL cl = allocate(vm, sizeof(Closure), 0);
641+ SETTY(cl, BITS16);
642+ cl->info.bits16 = (uint16_t) a->info.bits32;
643+ return cl;
644+}
645+
646+VAL idris_b64T8(VM *vm, VAL a) {
647+ VAL cl = allocate(vm, sizeof(Closure), 0);
648+ SETTY(cl, BITS8);
649+ cl->info.bits8 = (uint8_t) a->info.bits64;
650+ return cl;
651+}
652+
653+VAL idris_b64T16(VM *vm, VAL a) {
654+ VAL cl = allocate(vm, sizeof(Closure), 0);
655+ SETTY(cl, BITS16);
656+ cl->info.bits16 = (uint16_t) a->info.bits64;
657+ return cl;
658+}
659+
660+VAL idris_b64T32(VM *vm, VAL a) {
661+ VAL cl = allocate(vm, sizeof(Closure), 0);
662+ SETTY(cl, BITS32);
663+ cl->info.bits32 = (uint32_t) a->info.bits64;
664+ return cl;
665+}
666+