rts/idris_bitstring.c · Idris-dev

git.iko.soy/Idris-dev

on 7afa310 help sign in

Idris-dev/rts/idris_bitstring.c

822 lines 21 kB history raw

1#include "idris_rts.h"

3VAL idris_b8CopyForGC(VM *vm, VAL a) {

4 uint8_t A = a->info.bits8;

5 VAL cl = allocate(vm, sizeof(Closure), 1);

6 SETTY(cl, BITS8);

7 cl->info.bits8 = A;

8 return cl;

11VAL idris_b16CopyForGC(VM *vm, VAL a) {

12 uint16_t A = a->info.bits16;

13 VAL cl = allocate(vm, sizeof(Closure), 1);

14 SETTY(cl, BITS16);

15 cl->info.bits16 = A;

16 return cl;

17}

19VAL idris_b32CopyForGC(VM *vm, VAL a) {

20 uint32_t A = a->info.bits32;

21 VAL cl = allocate(vm, sizeof(Closure), 1);

22 SETTY(cl, BITS32);

23 cl->info.bits32 = A;

24 return cl;

25}

27VAL idris_b64CopyForGC(VM *vm, VAL a) {

28 uint64_t A = a->info.bits64;

29 VAL cl = allocate(vm, sizeof(Closure), 1);

30 SETTY(cl, BITS64);

31 cl->info.bits64 = A;

32 return cl;

33}

35VAL idris_b8(VM *vm, VAL a) {

36 uint8_t A = GETINT(a);

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

38 SETTY(cl, BITS8);

39 cl->info.bits8 = (uint8_t) A;

40 return cl;

41}

43VAL idris_b16(VM *vm, VAL a) {

44 uint16_t A = GETINT(a);

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

46 SETTY(cl, BITS16);

47 cl->info.bits16 = (uint16_t) A;

48 return cl;

49}

51VAL idris_b32(VM *vm, VAL a) {

52 uint32_t A = GETINT(a);

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

54 SETTY(cl, BITS32);

55 cl->info.bits32 = (uint32_t) A;

56 return cl;

57}

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

60 uint64_t A = GETINT(a);

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

62 SETTY(cl, BITS64);

63 cl->info.bits64 = (uint64_t) A;

64 return cl;

65}

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

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

69}

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

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

73 SETTY(cl, BITS8);

74 cl->info.bits8 = a;

75 return cl;

76}

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

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

80 SETTY(cl, BITS16);

81 cl->info.bits16 = a;

82 return cl;

83}

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

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

87 SETTY(cl, BITS32);

88 cl->info.bits32 = a;

89 return cl;

90}

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

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

94 SETTY(cl, BITS64);

95 cl->info.bits64 = a;

96 return cl;

97}

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

100 uint8_t A = a->info.bits8;

101 uint8_t B = b->info.bits8;

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

103 SETTY(cl, BITS8);

104 cl->info.bits8 = A + B;

105 return cl;

106}

107

108VAL idris_b8Minus(VM *vm, VAL a, VAL b) {

109 uint8_t A = a->info.bits8;

110 uint8_t B = b->info.bits8;

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

112 SETTY(cl, BITS8);

113 cl->info.bits8 = A - B;

114 return cl;

115}

116

117VAL idris_b8Times(VM *vm, VAL a, VAL b) {

118 uint8_t A = a->info.bits8;

119 uint8_t B = b->info.bits8;

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

121 SETTY(cl, BITS8);

122 cl->info.bits8 = A * B;

123 return cl;

124}

125

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

127 uint8_t A = a->info.bits8;

128 uint8_t B = b->info.bits8;

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

130 SETTY(cl, BITS8);

131 cl->info.bits8 = A / B;

132 return cl;

133}

134

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

136 uint8_t A = a->info.bits8;

137 uint8_t B = b->info.bits8;

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

139 SETTY(cl, BITS8);

140 cl->info.bits8 = (uint8_t) (((int8_t) A) / ((int8_t) B));

141 return cl;

142}

143

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

145 uint8_t A = a->info.bits8;

146 uint8_t B = b->info.bits8;

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

148 SETTY(cl, BITS8);

149 cl->info.bits8 = A % B;

150 return cl;

151}

152

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

154 uint8_t A = a->info.bits8;

155 uint8_t B = b->info.bits8;

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

157 SETTY(cl, BITS8);

158 cl->info.bits8 = (uint8_t) (((int8_t) A) % ((int8_t) B));

159 return cl;

160}

161

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

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

164}

165

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

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

168}

169

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

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

172}

173

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

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

176}

177

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

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

180}

181

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

183 uint8_t A = a->info.bits8;

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

185 SETTY(cl, BITS8);

186 cl->info.bits8 = ~ A;

187 return cl;

188}

189

190VAL idris_b8And(VM *vm, VAL a, VAL b) {

191 uint8_t A = a->info.bits8;

192 uint8_t B = b->info.bits8;

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

194 SETTY(cl, BITS8);

195 cl->info.bits8 = A & B;

196 return cl;

197}

198

199VAL idris_b8Or(VM *vm, VAL a, VAL b) {

200 uint8_t A = a->info.bits8;

201 uint8_t B = b->info.bits8;

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

203 SETTY(cl, BITS8);

204 cl->info.bits8 = A | B;

205 return cl;

206}

207

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

209 uint8_t A = a->info.bits8;

210 uint8_t B = b->info.bits8;

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

212 SETTY(cl, BITS8);

213 cl->info.bits8 = A ^ B;

214 return cl;

215}

216

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

218 uint8_t A = a->info.bits8;

219 uint8_t B = b->info.bits8;

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

221 SETTY(cl, BITS8);

222 cl->info.bits8 = A << B;

223 return cl;

224}

225

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

227 uint8_t A = a->info.bits8;

228 uint8_t B = b->info.bits8;

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

230 SETTY(cl, BITS8);

231 cl->info.bits8 = A >> B;

232 return cl;

233}

234

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

236 uint8_t A = a->info.bits8;

237 uint8_t B = b->info.bits8;

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

239 SETTY(cl, BITS8);

240 cl->info.bits8 = (uint8_t) (((int8_t) A) >> ((int8_t) B));

241 return cl;

242}

243

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

245 uint16_t A = a->info.bits16;

246 uint16_t B = b->info.bits16;

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

248 SETTY(cl, BITS16);

249 cl->info.bits16 = A + B;

250 return cl;

251}

252

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

254 uint16_t A = a->info.bits16;

255 uint16_t B = b->info.bits16;

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

257 SETTY(cl, BITS16);

258 cl->info.bits16 = A - B;

259 return cl;

260}

261

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

263 uint16_t A = a->info.bits16;

264 uint16_t B = b->info.bits16;

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

266 SETTY(cl, BITS16);

267 cl->info.bits16 = A * B;

268 return cl;

269}

270

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

272 uint16_t A = a->info.bits16;

273 uint16_t B = b->info.bits16;

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

275 SETTY(cl, BITS16);

276 cl->info.bits16 = A / B;

277 return cl;

278}

279

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

281 uint16_t A = a->info.bits16;

282 uint16_t B = b->info.bits16;

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

284 SETTY(cl, BITS16);

285 cl->info.bits16 = (uint16_t) (((int16_t) A) / ((int16_t) B));

286 return cl;

287}

288

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

290 uint16_t A = a->info.bits16;

291 uint16_t B = b->info.bits16;

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

293 SETTY(cl, BITS16);

294 cl->info.bits16 = A % B;

295 return cl;

296}

297

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

299 uint16_t A = a->info.bits16;

300 uint16_t B = b->info.bits16;

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

302 SETTY(cl, BITS16);

303 cl->info.bits16 = (uint16_t) (((int16_t) A) % ((int16_t) B));

304 return cl;

305}

306

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

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

309}

310

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

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

313}

314

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

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

317}

318

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

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

321}

322

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

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

325}

326

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

328 uint16_t A = a->info.bits16;

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

330 SETTY(cl, BITS16);

331 cl->info.bits16 = ~ A;

332 return cl;

333}

334

335VAL idris_b16And(VM *vm, VAL a, VAL b) {

336 uint16_t A = a->info.bits16;

337 uint16_t B = b->info.bits16;

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

339 SETTY(cl, BITS16);

340 cl->info.bits16 = A & B;

341 return cl;

342}

343

344VAL idris_b16Or(VM *vm, VAL a, VAL b) {

345 uint16_t A = a->info.bits16;

346 uint16_t B = b->info.bits16;

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

348 SETTY(cl, BITS16);

349 cl->info.bits16 = A | B;

350 return cl;

351}

352

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

354 uint16_t A = a->info.bits16;

355 uint16_t B = b->info.bits16;

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

357 SETTY(cl, BITS16);

358 cl->info.bits16 = A ^ B;

359 return cl;

360}

361

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

363 uint16_t A = a->info.bits16;

364 uint16_t B = b->info.bits16;

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

366 SETTY(cl, BITS16);

367 cl->info.bits16 = A << B;

368 return cl;

369}

370

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

372 uint16_t A = a->info.bits16;

373 uint16_t B = b->info.bits16;

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

375 SETTY(cl, BITS16);

376 cl->info.bits16 = A >> B;

377 return cl;

378}

379

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

381 uint16_t A = a->info.bits16;

382 uint16_t B = b->info.bits16;

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

384 SETTY(cl, BITS16);

385 cl->info.bits16 = (uint16_t) (((int16_t) A) >> ((int16_t) B));

386 return cl;

387}

388

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

390 uint32_t A = a->info.bits32;

391 uint32_t B = b->info.bits32;

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

393 SETTY(cl, BITS32);

394 cl->info.bits32 = A + B;

395 return cl;

396}

397

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

399 uint32_t A = a->info.bits32;

400 uint32_t B = b->info.bits32;

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

402 SETTY(cl, BITS32);

403 cl->info.bits32 = A - B;

404 return cl;

405}

406

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

408 uint32_t A = a->info.bits32;

409 uint32_t B = b->info.bits32;

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

411 SETTY(cl, BITS32);

412 cl->info.bits32 = A * B;

413 return cl;

414}

415

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

417 uint32_t A = a->info.bits32;

418 uint32_t B = b->info.bits32;

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

420 SETTY(cl, BITS32);

421 cl->info.bits32 = A / B;

422 return cl;

423}

424

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

426 uint32_t A = a->info.bits32;

427 uint32_t B = b->info.bits32;

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

429 SETTY(cl, BITS32);

430 cl->info.bits32 = (uint32_t) (((int32_t) A) / ((int32_t) B));

431 return cl;

432}

433

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

435 uint32_t A = a->info.bits32;

436 uint32_t B = b->info.bits32;

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

438 SETTY(cl, BITS32);

439 cl->info.bits32 = A % B;

440 return cl;

441}

442

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

444 uint32_t A = a->info.bits32;

445 uint32_t B = b->info.bits32;

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

447 SETTY(cl, BITS32);

448 cl->info.bits32 = (uint32_t) (((int32_t) A) % ((int32_t) B));

449 return cl;

450}

451

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

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

454}

455

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

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

458}

459

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

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

462}

463

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

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

466}

467

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

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

470}

471

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

473 uint32_t A = a->info.bits32;

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

475 SETTY(cl, BITS32);

476 cl->info.bits32 = ~ A;

477 return cl;

478}

479

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

481 uint32_t A = a->info.bits32;

482 uint32_t B = b->info.bits32;

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

484 SETTY(cl, BITS32);

485 cl->info.bits32 = A & B;

486 return cl;

487}

488

489VAL idris_b32Or(VM *vm, VAL a, VAL b) {

490 uint32_t A = a->info.bits32;

491 uint32_t B = b->info.bits32;

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

493 SETTY(cl, BITS32);

494 cl->info.bits32 = A | B;

495 return cl;

496}

497

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

499 uint32_t A = a->info.bits32;

500 uint32_t B = b->info.bits32;

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

502 SETTY(cl, BITS32);

503 cl->info.bits32 = A ^ B;

504 return cl;

505}

506

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

508 uint32_t A = a->info.bits32;

509 uint32_t B = b->info.bits32;

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

511 SETTY(cl, BITS32);

512 cl->info.bits32 = A << B;

513 return cl;

514}

515

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

517 uint32_t A = a->info.bits32;

518 uint32_t B = b->info.bits32;

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

520 SETTY(cl, BITS32);

521 cl->info.bits32 = A >> B;

522 return cl;

523}

524

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

526 uint32_t A = a->info.bits32;

527 uint32_t B = b->info.bits32;

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

529 SETTY(cl, BITS32);

530 cl->info.bits32 = (uint32_t) (((int32_t)A) >> ((int32_t)B));

531 return cl;

532}

533

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

535 uint64_t A = a->info.bits64;

536 uint64_t B = b->info.bits64;

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

538 SETTY(cl, BITS64);

539 cl->info.bits64 = A + B;

540 return cl;

541}

542

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

544 uint64_t A = a->info.bits64;

545 uint64_t B = b->info.bits64;

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

547 SETTY(cl, BITS64);

548 cl->info.bits64 = A - B;

549 return cl;

550}

551

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

553 uint64_t A = a->info.bits64;

554 uint64_t B = b->info.bits64;

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

556 SETTY(cl, BITS64);

557 cl->info.bits64 = A * B;

558 return cl;

559}

560

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

562 uint64_t A = a->info.bits64;

563 uint64_t B = b->info.bits64;

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

565 SETTY(cl, BITS64);

566 cl->info.bits64 = A / B;

567 return cl;

568}

569

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

571 uint64_t A = a->info.bits64;

572 uint64_t B = b->info.bits64;

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

574 SETTY(cl, BITS64);

575 cl->info.bits64 = (uint64_t) (((int64_t) A) / ((int64_t) B));

576 return cl;

577}

578

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

580 uint64_t A = a->info.bits64;

581 uint64_t B = b->info.bits64;

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

583 SETTY(cl, BITS64);

584 cl->info.bits64 = A % B;

585 return cl;

586}

587

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

589 uint64_t A = a->info.bits64;

590 uint64_t B = b->info.bits64;

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

592 SETTY(cl, BITS64);

593 cl->info.bits64 = (uint64_t) (((int64_t) A) % ((int64_t) B));

594 return cl;

595}

596

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

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

599}

600

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

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

603}

604

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

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

607}

608

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

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

611}

612

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

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

615}

616

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

618 uint64_t A = a->info.bits64;

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

620 SETTY(cl, BITS64);

621 cl->info.bits64 = ~ A;

622 return cl;

623}

624

625VAL idris_b64And(VM *vm, VAL a, VAL b) {

626 uint64_t A = a->info.bits64;

627 uint64_t B = b->info.bits64;

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

629 SETTY(cl, BITS64);

630 cl->info.bits64 = A & B;

631 return cl;

632}

633

634VAL idris_b64Or(VM *vm, VAL a, VAL b) {

635 uint64_t A = a->info.bits64;

636 uint64_t B = b->info.bits64;

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

638 SETTY(cl, BITS64);

639 cl->info.bits64 = A | B;

640 return cl;

641}

642

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

644 uint64_t A = a->info.bits64;

645 uint64_t B = b->info.bits64;

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

647 SETTY(cl, BITS64);

648 cl->info.bits64 = A ^ B;

649 return cl;

650}

651

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

653 uint64_t A = a->info.bits64;

654 uint64_t B = b->info.bits64;

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

656 SETTY(cl, BITS64);

657 cl->info.bits64 = A << B;

658 return cl;

659}

660

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

662 uint64_t A = a->info.bits64;

663 uint64_t B = b->info.bits64;

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

665 SETTY(cl, BITS64);

666 cl->info.bits64 = A >> B;

667 return cl;

668}

669

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

671 uint64_t A = a->info.bits64;

672 uint64_t B = b->info.bits64;

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

674 SETTY(cl, BITS64);

675 cl->info.bits64 = (uint64_t) (((int64_t) A) >> ((int64_t) B));

676 return cl;

677}

678

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

680 uint8_t A = a->info.bits8;

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

682 SETTY(cl, BITS16);

683 cl->info.bits16 = (uint16_t) A;

684 return cl;

685}

686

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

688 uint8_t A = a->info.bits8;

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

690 SETTY(cl, BITS32);

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

692 return cl;

693}

694

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

696 uint8_t A = a->info.bits8;

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

698 SETTY(cl, BITS64);

699 cl->info.bits64 = (uint64_t) A;

700 return cl;

701}

702

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

704 uint8_t A = a->info.bits8;

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

706 SETTY(cl, BITS16);

707 cl->info.bits16 = (uint16_t) (int16_t) (int8_t) A;

708 return cl;

709}

710

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

712 uint8_t A = a->info.bits8;

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

714 SETTY(cl, BITS32);

715 cl->info.bits32 = (uint32_t) (int32_t) (int8_t) A;

716 return cl;

717}

718

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

720 uint8_t A = a->info.bits8;

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

722 SETTY(cl, BITS64);

723 cl->info.bits64 = (uint64_t) (int64_t) (int8_t) A;

724 return cl;

725}

726

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

728 uint16_t A = a->info.bits16;

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

730 SETTY(cl, BITS32);

731 cl->info.bits32 = (uint32_t) A;

732 return cl;

733}

734

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

736 uint16_t A = a->info.bits16;

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

738 SETTY(cl, BITS64);

739 cl->info.bits64 = (uint64_t) A;

740 return cl;

741}

742

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

744 uint16_t A = a->info.bits16;

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

746 SETTY(cl, BITS32);

747 cl->info.bits32 = (uint32_t) (int32_t) (int16_t) A;

748 return cl;

749}

750

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

752 uint16_t A = a->info.bits16;

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

754 SETTY(cl, BITS64);

755 cl->info.bits64 = (uint64_t) (int64_t) (int16_t) A;

756 return cl;

757}

758

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

760 uint16_t A = a->info.bits16;

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

762 SETTY(cl, BITS8);

763 cl->info.bits8 = (uint8_t) A;

764 return cl;

765}

766

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

768 uint32_t A = a->info.bits32;

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

770 SETTY(cl, BITS64);

771 cl->info.bits64 = (uint64_t) A;

772 return cl;

773}

774

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

776 uint32_t A = a->info.bits32;

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

778 SETTY(cl, BITS64);

779 cl->info.bits64 = (uint64_t) (int64_t) (int32_t) A;

780 return cl;

781}

782

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

784 uint32_t A = a->info.bits32;

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

786 SETTY(cl, BITS8);

787 cl->info.bits8 = (uint8_t) A;

788 return cl;

789}

790

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

792 uint32_t A = a->info.bits32;

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

794 SETTY(cl, BITS16);

795 cl->info.bits16 = (uint16_t) A;

796 return cl;

797}

798

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

800 uint64_t A = a->info.bits64;

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

802 SETTY(cl, BITS8);

803 cl->info.bits8 = (uint8_t) A;

804 return cl;

805}

806

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

808 uint64_t A = a->info.bits64;

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

810 SETTY(cl, BITS16);

811 cl->info.bits16 = (uint16_t) A;

812 return cl;

813}

814

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

816 uint64_t A = a->info.bits64;

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

818 SETTY(cl, BITS32);

819 cl->info.bits32 = (uint32_t) A;

820 return cl;

821}

822