rts/idris_bitstring.c · Idris-dev

git.iko.soy/Idris-dev

on bee324c help sign in

Idris-dev/rts/idris_bitstring.c

666 lines 17 kB history raw

1#include "idris_rts.h"

3VAL 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;

10VAL 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}

17VAL 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}

24VAL 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}

31VAL 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}

38VAL 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}

45VAL 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}

52VAL 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}

59VAL idris_castB32Int(VM *vm, VAL a) {

60 return MKINT(a->info.bits32);

61}

63VAL 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}

70VAL 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}

77VAL 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}

84VAL 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}

91VAL 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}

98VAL 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

105VAL 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

112VAL idris_b8Lt(VM *vm, VAL a, VAL b) {

113 return MKINT(a->info.bits8 < b->info.bits8);

114}

115

116VAL idris_b8Gt(VM *vm, VAL a, VAL b) {

117 return MKINT(a->info.bits8 > b->info.bits8);

118}

119

120VAL idris_b8Eq(VM *vm, VAL a, VAL b) {

121 return MKINT(a->info.bits8 == b->info.bits8);

122}

123

124VAL idris_b8Lte(VM *vm, VAL a, VAL b) {

125 return MKINT(a->info.bits8 <= b->info.bits8);

126}

127

128VAL idris_b8Gte(VM *vm, VAL a, VAL b) {

129 return MKINT(a->info.bits8 >= b->info.bits8);

130}

131

132VAL 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

139VAL 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

146VAL 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

153VAL 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

160VAL 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

167VAL 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

174VAL 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

181VAL 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

188VAL 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

195VAL 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

202VAL 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

209VAL 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

217VAL 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

224VAL 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

232VAL idris_b16Lt(VM *vm, VAL a, VAL b) {

233 return MKINT(a->info.bits16 < b->info.bits16);

234}

235

236VAL idris_b16Gt(VM *vm, VAL a, VAL b) {

237 return MKINT(a->info.bits16 > b->info.bits16);

238}

239

240VAL idris_b16Eq(VM *vm, VAL a, VAL b) {

241 return MKINT(a->info.bits16 == b->info.bits16);

242}

243

244VAL idris_b16Lte(VM *vm, VAL a, VAL b) {

245 return MKINT(a->info.bits16 <= b->info.bits16);

246}

247

248VAL idris_b16Gte(VM *vm, VAL a, VAL b) {

249 return MKINT(a->info.bits16 >= b->info.bits16);

250}

251

252VAL 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

259VAL 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

266VAL 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

273VAL 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

280VAL 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

287VAL 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

294VAL 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

301VAL 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

308VAL 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

315VAL 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

322VAL 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

329VAL 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

337VAL 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

344VAL 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

352VAL idris_b32Lt(VM *vm, VAL a, VAL b) {

353 return MKINT(a->info.bits32 < b->info.bits32);

354}

355

356VAL idris_b32Gt(VM *vm, VAL a, VAL b) {

357 return MKINT(a->info.bits32 > b->info.bits32);

358}

359

360VAL idris_b32Eq(VM *vm, VAL a, VAL b) {

361 return MKINT(a->info.bits32 == b->info.bits32);

362}

363

364VAL idris_b32Lte(VM *vm, VAL a, VAL b) {

365 return MKINT(a->info.bits32 <= b->info.bits32);

366}

367

368VAL idris_b32Gte(VM *vm, VAL a, VAL b) {

369 return MKINT(a->info.bits32 >= b->info.bits32);

370}

371

372VAL 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

379VAL 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

386VAL 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

393VAL 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

400VAL 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

407VAL 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

414VAL 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

421VAL 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

428VAL 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

435VAL 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

442VAL 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

449VAL 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

457VAL 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

464VAL 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

472VAL idris_b64Lt(VM *vm, VAL a, VAL b) {

473 return MKINT(a->info.bits64 < b->info.bits64);

474}

475

476VAL idris_b64Gt(VM *vm, VAL a, VAL b) {

477 return MKINT(a->info.bits64 > b->info.bits64);

478}

479

480VAL idris_b64Eq(VM *vm, VAL a, VAL b) {

481 return MKINT(a->info.bits64 == b->info.bits64);

482}

483

484VAL idris_b64Lte(VM *vm, VAL a, VAL b) {

485 return MKINT(a->info.bits64 <= b->info.bits64);

486}

487

488VAL idris_b64Gte(VM *vm, VAL a, VAL b) {

489 return MKINT(a->info.bits64 >= b->info.bits64);

490}

491

492VAL 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

499VAL 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

506VAL 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

513VAL 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

520VAL 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

527VAL 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

534VAL 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

541VAL 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

548VAL 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

555VAL 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

562VAL 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

569VAL 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

576VAL 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

583VAL 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

590VAL 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

597VAL 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

604VAL 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

611VAL 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

618VAL 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

625VAL 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

632VAL 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

639VAL 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

646VAL 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

653VAL 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

660VAL 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