rts/idris_bitstring.c · Idris-dev

git.iko.soy/Idris-dev

on 91043cc help sign in

Idris-dev/rts/idris_bitstring.c

694 lines 18 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((i_int)a->info.bits32);

61}

63VAL idris_b8const(VM *vm, uint8_t a) {

64 VAL cl = allocate(vm, sizeof(Closure), 0);

65 SETTY(cl, BITS8);

66 cl->info.bits8 = a;

67 return cl;

68}

70VAL idris_b16const(VM *vm, uint16_t a) {

71 VAL cl = allocate(vm, sizeof(Closure), 0);

72 SETTY(cl, BITS16);

73 cl->info.bits16 = a;

74 return cl;

75}

77VAL idris_b32const(VM *vm, uint32_t a) {

78 VAL cl = allocate(vm, sizeof(Closure), 0);

79 SETTY(cl, BITS32);

80 cl->info.bits32 = a;

81 return cl;

82}

84VAL idris_b64const(VM *vm, uint64_t a) {

85 VAL cl = allocate(vm, sizeof(Closure), 0);

86 SETTY(cl, BITS64);

87 cl->info.bits64 = a;

88 return cl;

89}

91VAL idris_b8Plus(VM *vm, VAL a, VAL b) {

92 VAL cl = allocate(vm, sizeof(Closure), 0);

93 SETTY(cl, BITS8);

94 cl->info.bits8 = a->info.bits8 + b->info.bits8;

95 return cl;

96}

98VAL idris_b8Minus(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_b8Times(VM *vm, VAL a, VAL b) {

106 VAL cl = allocate(vm, sizeof(Closure), 0);

107 SETTY(cl, BITS8);

108 cl->info.bits8 = a->info.bits8 * b->info.bits8;

109 return cl;

110}

111

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

113 VAL cl = allocate(vm, sizeof(Closure), 0);

114 SETTY(cl, BITS8);

115 cl->info.bits8 = a->info.bits8 / b->info.bits8;

116 return cl;

117}

118

119VAL idris_b8SDiv(VM *vm, VAL a, VAL b) {

120 VAL cl = allocate(vm, sizeof(Closure), 0);

121 SETTY(cl, BITS8);

122 cl->info.bits8 = (uint8_t) (((int8_t) a->info.bits8) / ((int8_t) b->info.bits8));

123 return cl;

124}

125

126VAL idris_b8URem(VM *vm, VAL a, VAL b) {

127 VAL cl = allocate(vm, sizeof(Closure), 0);

128 SETTY(cl, BITS8);

129 cl->info.bits8 = a->info.bits8 % b->info.bits8;

130 return cl;

131}

132

133VAL idris_b8SRem(VM *vm, VAL a, VAL b) {

134 VAL cl = allocate(vm, sizeof(Closure), 0);

135 SETTY(cl, BITS8);

136 cl->info.bits8 = (uint8_t) (((int8_t) a->info.bits8) % ((int8_t) b->info.bits8));

137 return cl;

138}

139

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

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

142}

143

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

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

146}

147

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

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

150}

151

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

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

154}

155

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

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

158}

159

160VAL idris_b8Compl(VM *vm, VAL a) {

161 VAL cl = allocate(vm, sizeof(Closure), 0);

162 SETTY(cl, BITS8);

163 cl->info.bits8 = ~ a->info.bits8;

164 return cl;

165}

166

167VAL idris_b8And(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_b8Or(VM *vm, VAL a, VAL b) {

175 VAL cl = allocate(vm, sizeof(Closure), 0);

176 SETTY(cl, BITS8);

177 cl->info.bits8 = a->info.bits8 | b->info.bits8;

178 return cl;

179}

180

181VAL idris_b8Xor(VM *vm, VAL a, VAL b) {

182 VAL cl = allocate(vm, sizeof(Closure), 0);

183 SETTY(cl, BITS8);

184 cl->info.bits8 = a->info.bits8 ^ b->info.bits8;

185 return cl;

186}

187

188VAL idris_b8Shl(VM *vm, VAL a, VAL b) {

189 VAL cl = allocate(vm, sizeof(Closure), 0);

190 SETTY(cl, BITS8);

191 cl->info.bits8 = a->info.bits8 << b->info.bits8;

192 return cl;

193}

194

195VAL idris_b8LShr(VM *vm, VAL a, VAL b) {

196 VAL cl = allocate(vm, sizeof(Closure), 0);

197 SETTY(cl, BITS8);

198 cl->info.bits8 = a->info.bits8 >> b->info.bits8;

199 return cl;

200}

201

202VAL idris_b8AShr(VM *vm, VAL a, VAL b) {

203 VAL cl = allocate(vm, sizeof(Closure), 0);

204 SETTY(cl, BITS8);

205 cl->info.bits8 = (uint8_t) (((int8_t)a->info.bits8) >> ((int8_t)b->info.bits8));

206 return cl;

207}

208

209VAL idris_b16Plus(VM *vm, VAL a, VAL b) {

210 VAL cl = allocate(vm, sizeof(Closure), 0);

211 SETTY(cl, BITS16);

212 cl->info.bits16 = a->info.bits16 + b->info.bits16;

213 return cl;

214}

215

216VAL idris_b16Minus(VM *vm, VAL a, VAL b) {

217 VAL cl = allocate(vm, sizeof(Closure), 0);

218 SETTY(cl, BITS16);

219 cl->info.bits16 = a->info.bits16 - b->info.bits16;

220 return cl;

221}

222

223VAL idris_b16Times(VM *vm, VAL a, VAL b) {

224 VAL cl = allocate(vm, sizeof(Closure), 0);

225 SETTY(cl, BITS16);

226 cl->info.bits16 = a->info.bits16 * b->info.bits16;

227 return cl;

228}

229

230VAL idris_b16UDiv(VM *vm, VAL a, VAL b) {

231 VAL cl = allocate(vm, sizeof(Closure), 0);

232 SETTY(cl, BITS16);

233 cl->info.bits16 = a->info.bits16 / b->info.bits16;

234 return cl;

235}

236

237VAL idris_b16SDiv(VM *vm, VAL a, VAL b) {

238 VAL cl = allocate(vm, sizeof(Closure), 0);

239 SETTY(cl, BITS16);

240 cl->info.bits16 =

241 (uint16_t) (((int16_t) a->info.bits16) / ((int16_t) b->info.bits16));

242 return cl;

243}

244

245VAL idris_b16URem(VM *vm, VAL a, VAL b) {

246 VAL cl = allocate(vm, sizeof(Closure), 0);

247 SETTY(cl, BITS16);

248 cl->info.bits16 = a->info.bits16 % b->info.bits16;

249 return cl;

250}

251

252VAL idris_b16SRem(VM *vm, VAL a, VAL b) {

253 VAL cl = allocate(vm, sizeof(Closure), 0);

254 SETTY(cl, BITS16);

255 cl->info.bits16 =

256 (uint16_t) (((int16_t) a->info.bits16) % ((int16_t) b->info.bits16));

257 return cl;

258}

259

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

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

262}

263

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

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

266}

267

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

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

270}

271

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

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

274}

275

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

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

278}

279

280VAL idris_b16Compl(VM *vm, VAL a) {

281 VAL cl = allocate(vm, sizeof(Closure), 0);

282 SETTY(cl, BITS16);

283 cl->info.bits16 = ~ a->info.bits16;

284 return cl;

285}

286

287VAL idris_b16And(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_b16Or(VM *vm, VAL a, VAL b) {

295 VAL cl = allocate(vm, sizeof(Closure), 0);

296 SETTY(cl, BITS16);

297 cl->info.bits16 = a->info.bits16 | b->info.bits16;

298 return cl;

299}

300

301VAL idris_b16Xor(VM *vm, VAL a, VAL b) {

302 VAL cl = allocate(vm, sizeof(Closure), 0);

303 SETTY(cl, BITS16);

304 cl->info.bits16 = a->info.bits16 ^ b->info.bits16;

305 return cl;

306}

307

308VAL idris_b16Shl(VM *vm, VAL a, VAL b) {

309 VAL cl = allocate(vm, sizeof(Closure), 0);

310 SETTY(cl, BITS16);

311 cl->info.bits16 = a->info.bits16 << b->info.bits16;

312 return cl;

313}

314

315VAL idris_b16LShr(VM *vm, VAL a, VAL b) {

316 VAL cl = allocate(vm, sizeof(Closure), 0);

317 SETTY(cl, BITS16);

318 cl->info.bits16 = a->info.bits16 >> b->info.bits16;

319 return cl;

320}

321

322VAL idris_b16AShr(VM *vm, VAL a, VAL b) {

323 VAL cl = allocate(vm, sizeof(Closure), 0);

324 SETTY(cl, BITS16);

325 cl->info.bits16 = (uint16_t) (((int16_t)a->info.bits16) >> ((int16_t)b->info.bits16));

326 return cl;

327}

328

329VAL idris_b32Plus(VM *vm, VAL a, VAL b) {

330 VAL cl = allocate(vm, sizeof(Closure), 0);

331 SETTY(cl, BITS32);

332 cl->info.bits32 = a->info.bits32 + b->info.bits32;

333 return cl;

334}

335

336VAL idris_b32Minus(VM *vm, VAL a, VAL b) {

337 VAL cl = allocate(vm, sizeof(Closure), 0);

338 SETTY(cl, BITS32);

339 cl->info.bits32 = a->info.bits32 - b->info.bits32;

340 return cl;

341}

342

343VAL idris_b32Times(VM *vm, VAL a, VAL b) {

344 VAL cl = allocate(vm, sizeof(Closure), 0);

345 SETTY(cl, BITS32);

346 cl->info.bits32 = a->info.bits32 * b->info.bits32;

347 return cl;

348}

349

350VAL idris_b32UDiv(VM *vm, VAL a, VAL b) {

351 VAL cl = allocate(vm, sizeof(Closure), 0);

352 SETTY(cl, BITS32);

353 cl->info.bits32 = a->info.bits32 / b->info.bits32;

354 return cl;

355}

356

357VAL idris_b32SDiv(VM *vm, VAL a, VAL b) {

358 VAL cl = allocate(vm, sizeof(Closure), 0);

359 SETTY(cl, BITS32);

360 cl->info.bits32 =

361 (uint32_t) (((int32_t) a->info.bits32) / ((int32_t) b->info.bits32));

362 return cl;

363}

364

365VAL idris_b32URem(VM *vm, VAL a, VAL b) {

366 VAL cl = allocate(vm, sizeof(Closure), 0);

367 SETTY(cl, BITS32);

368 cl->info.bits32 = a->info.bits32 % b->info.bits32;

369 return cl;

370}

371

372VAL idris_b32SRem(VM *vm, VAL a, VAL b) {

373 VAL cl = allocate(vm, sizeof(Closure), 0);

374 SETTY(cl, BITS32);

375 cl->info.bits32 =

376 (uint32_t) (((int32_t) a->info.bits32) % ((int32_t) b->info.bits32));

377 return cl;

378}

379

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

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

382}

383

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

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

386}

387

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

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

390}

391

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

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

394}

395

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

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

398}

399

400VAL idris_b32Compl(VM *vm, VAL a) {

401 VAL cl = allocate(vm, sizeof(Closure), 0);

402 SETTY(cl, BITS32);

403 cl->info.bits32 = ~ a->info.bits32;

404 return cl;

405}

406

407VAL idris_b32And(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_b32Or(VM *vm, VAL a, VAL b) {

415 VAL cl = allocate(vm, sizeof(Closure), 0);

416 SETTY(cl, BITS32);

417 cl->info.bits32 = a->info.bits32 | b->info.bits32;

418 return cl;

419}

420

421VAL idris_b32Xor(VM *vm, VAL a, VAL b) {

422 VAL cl = allocate(vm, sizeof(Closure), 0);

423 SETTY(cl, BITS32);

424 cl->info.bits32 = a->info.bits32 ^ b->info.bits32;

425 return cl;

426}

427

428VAL idris_b32Shl(VM *vm, VAL a, VAL b) {

429 VAL cl = allocate(vm, sizeof(Closure), 0);

430 SETTY(cl, BITS32);

431 cl->info.bits32 = a->info.bits32 << b->info.bits32;

432 return cl;

433}

434

435VAL idris_b32LShr(VM *vm, VAL a, VAL b) {

436 VAL cl = allocate(vm, sizeof(Closure), 0);

437 SETTY(cl, BITS32);

438 cl->info.bits32 = a->info.bits32 >> b->info.bits32;

439 return cl;

440}

441

442VAL idris_b32AShr(VM *vm, VAL a, VAL b) {

443 VAL cl = allocate(vm, sizeof(Closure), 0);

444 SETTY(cl, BITS32);

445 cl->info.bits32 = (uint32_t) (((int32_t)a->info.bits32) >> ((int32_t)b->info.bits32));

446 return cl;

447}

448

449VAL idris_b64Plus(VM *vm, VAL a, VAL b) {

450 VAL cl = allocate(vm, sizeof(Closure), 0);

451 SETTY(cl, BITS64);

452 cl->info.bits64 = a->info.bits64 + b->info.bits64;

453 return cl;

454}

455

456VAL idris_b64Minus(VM *vm, VAL a, VAL b) {

457 VAL cl = allocate(vm, sizeof(Closure), 0);

458 SETTY(cl, BITS64);

459 cl->info.bits64 = a->info.bits64 - b->info.bits64;

460 return cl;

461}

462

463VAL idris_b64Times(VM *vm, VAL a, VAL b) {

464 VAL cl = allocate(vm, sizeof(Closure), 0);

465 SETTY(cl, BITS64);

466 cl->info.bits64 = a->info.bits64 * b->info.bits64;

467 return cl;

468}

469

470VAL idris_b64UDiv(VM *vm, VAL a, VAL b) {

471 VAL cl = allocate(vm, sizeof(Closure), 0);

472 SETTY(cl, BITS64);

473 cl->info.bits64 = a->info.bits64 / b->info.bits64;

474 return cl;

475}

476

477VAL idris_b64SDiv(VM *vm, VAL a, VAL b) {

478 VAL cl = allocate(vm, sizeof(Closure), 0);

479 SETTY(cl, BITS64);

480 cl->info.bits64 =

481 (uint64_t) (((int64_t) a->info.bits64) / ((int64_t) b->info.bits64));

482 return cl;

483}

484

485VAL idris_b64URem(VM *vm, VAL a, VAL b) {

486 VAL cl = allocate(vm, sizeof(Closure), 0);

487 SETTY(cl, BITS64);

488 cl->info.bits64 = a->info.bits64 % b->info.bits64;

489 return cl;

490}

491

492VAL idris_b64SRem(VM *vm, VAL a, VAL b) {

493 VAL cl = allocate(vm, sizeof(Closure), 0);

494 SETTY(cl, BITS64);

495 cl->info.bits64 =

496 (uint64_t) (((int64_t) a->info.bits64) % ((int64_t) b->info.bits64));

497 return cl;

498}

499

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

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

502}

503

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

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

506}

507

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

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

510}

511

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

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

514}

515

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

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

518}

519

520VAL idris_b64Compl(VM *vm, VAL a) {

521 VAL cl = allocate(vm, sizeof(Closure), 0);

522 SETTY(cl, BITS64);

523 cl->info.bits64 = ~ a->info.bits64;

524 return cl;

525}

526

527VAL idris_b64And(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_b64Or(VM *vm, VAL a, VAL b) {

535 VAL cl = allocate(vm, sizeof(Closure), 0);

536 SETTY(cl, BITS64);

537 cl->info.bits64 = a->info.bits64 | b->info.bits64;

538 return cl;

539}

540

541VAL idris_b64Xor(VM *vm, VAL a, VAL b) {

542 VAL cl = allocate(vm, sizeof(Closure), 0);

543 SETTY(cl, BITS64);

544 cl->info.bits64 = a->info.bits64 ^ b->info.bits64;

545 return cl;

546}

547

548VAL idris_b64Shl(VM *vm, VAL a, VAL b) {

549 VAL cl = allocate(vm, sizeof(Closure), 0);

550 SETTY(cl, BITS64);

551 cl->info.bits64 = a->info.bits64 << b->info.bits64;

552 return cl;

553}

554

555VAL idris_b64LShr(VM *vm, VAL a, VAL b) {

556 VAL cl = allocate(vm, sizeof(Closure), 0);

557 SETTY(cl, BITS64);

558 cl->info.bits64 = a->info.bits64 >> b->info.bits64;

559 return cl;

560}

561

562VAL idris_b64AShr(VM *vm, VAL a, VAL b) {

563 VAL cl = allocate(vm, sizeof(Closure), 0);

564 SETTY(cl, BITS64);

565 cl->info.bits64 = (uint64_t) (((int64_t)a->info.bits64) >> ((int64_t)b->info.bits64));

566 return cl;

567}

568

569VAL idris_b8Z16(VM *vm, VAL a) {

570 VAL cl = allocate(vm, sizeof(Closure), 0);

571 SETTY(cl, BITS16);

572 cl->info.bits16 = (uint16_t) a->info.bits8;

573 return cl;

574}

575

576VAL idris_b8Z32(VM *vm, VAL a) {

577 VAL cl = allocate(vm, sizeof(Closure), 0);

578 SETTY(cl, BITS32);

579 cl->info.bits32 = (uint32_t) a->info.bits8;

580 return cl;

581}

582

583VAL idris_b8Z64(VM *vm, VAL a) {

584 VAL cl = allocate(vm, sizeof(Closure), 0);

585 SETTY(cl, BITS16);

586 cl->info.bits64 = (uint64_t) a->info.bits8;

587 return cl;

588}

589

590VAL idris_b8S16(VM *vm, VAL a) {

591 VAL cl = allocate(vm, sizeof(Closure), 0);

592 SETTY(cl, BITS16);

593 cl->info.bits16 = (uint16_t) (int16_t) (int8_t) a->info.bits8;

594 return cl;

595}

596

597VAL idris_b8S32(VM *vm, VAL a) {

598 VAL cl = allocate(vm, sizeof(Closure), 0);

599 SETTY(cl, BITS32);

600 cl->info.bits32 = (uint32_t) (int32_t) (int8_t) a->info.bits8;

601 return cl;

602}

603

604VAL idris_b8S64(VM *vm, VAL a) {

605 VAL cl = allocate(vm, sizeof(Closure), 0);

606 SETTY(cl, BITS64);

607 cl->info.bits64 = (uint64_t) (int64_t) (int8_t) a->info.bits8;

608 return cl;

609}

610

611VAL idris_b16Z32(VM *vm, VAL a) {

612 VAL cl = allocate(vm, sizeof(Closure), 0);

613 SETTY(cl, BITS32);

614 cl->info.bits32 = (uint32_t) a->info.bits16;

615 return cl;

616}

617

618VAL idris_b16Z64(VM *vm, VAL a) {

619 VAL cl = allocate(vm, sizeof(Closure), 0);

620 SETTY(cl, BITS64);

621 cl->info.bits64 = (uint64_t) a->info.bits16;

622 return cl;

623}

624

625VAL idris_b16S32(VM *vm, VAL a) {

626 VAL cl = allocate(vm, sizeof(Closure), 0);

627 SETTY(cl, BITS32);

628 cl->info.bits32 = (uint32_t) (int32_t) (int16_t) a->info.bits16;

629 return cl;

630}

631

632VAL idris_b16S64(VM *vm, VAL a) {

633 VAL cl = allocate(vm, sizeof(Closure), 0);

634 SETTY(cl, BITS64);

635 cl->info.bits64 = (uint64_t) (int64_t) (int16_t) a->info.bits16;

636 return cl;

637}

638

639VAL idris_b16T8(VM *vm, VAL a) {

640 VAL cl = allocate(vm, sizeof(Closure), 0);

641 SETTY(cl, BITS8);

642 cl->info.bits8 = (uint8_t) a->info.bits16;

643 return cl;

644}

645

646VAL idris_b32Z64(VM *vm, VAL a) {

647 VAL cl = allocate(vm, sizeof(Closure), 0);

648 SETTY(cl, BITS64);

649 cl->info.bits64 = (uint64_t) a->info.bits32;

650 return cl;

651}

652

653VAL idris_b32S64(VM *vm, VAL a) {

654 VAL cl = allocate(vm, sizeof(Closure), 0);

655 SETTY(cl, BITS64);

656 cl->info.bits64 = (uint64_t) (int64_t) (int32_t) a->info.bits32;

657 return cl;

658}

659

660VAL idris_b32T8(VM *vm, VAL a) {

661 VAL cl = allocate(vm, sizeof(Closure), 0);

662 SETTY(cl, BITS8);

663 cl->info.bits8 = (uint8_t) a->info.bits32;

664 return cl;

665}

666

667VAL idris_b32T16(VM *vm, VAL a) {

668 VAL cl = allocate(vm, sizeof(Closure), 0);

669 SETTY(cl, BITS16);

670 cl->info.bits16 = (uint16_t) a->info.bits32;

671 return cl;

672}

673

674VAL idris_b64T8(VM *vm, VAL a) {

675 VAL cl = allocate(vm, sizeof(Closure), 0);

676 SETTY(cl, BITS8);

677 cl->info.bits8 = (uint8_t) a->info.bits64;

678 return cl;

679}

680

681VAL idris_b64T16(VM *vm, VAL a) {

682 VAL cl = allocate(vm, sizeof(Closure), 0);

683 SETTY(cl, BITS16);

684 cl->info.bits16 = (uint16_t) a->info.bits64;

685 return cl;

686}

687

688VAL idris_b64T32(VM *vm, VAL a) {

689 VAL cl = allocate(vm, sizeof(Closure), 0);

690 SETTY(cl, BITS32);

691 cl->info.bits32 = (uint32_t) a->info.bits64;

692 return cl;

693}

694