Coverage for MC6809/components/cpu_utils/instruction_call.py: 80%

1""" 

2 This file was generated with: "Instruction_generator.py" 

3 Please don't change it directly ;) 

4 

5 

6 :copyleft: 2013-2015 by the MC6809 team, see AUTHORS for more details. 

7 :license: GNU GPL v3 or above, see LICENSE for more details. 

8 

9""" 

10 

11 

12from MC6809.components.cpu_utils.instruction_base import InstructionBase 

13 

14 

15class PrepagedInstructions(InstructionBase): 

16 def __init__(self, *args, **kwargs): 

17 super().__init__(*args, **kwargs) 

18 

19 self.write_byte = self.cpu.memory.write_byte 

20 self.write_word = self.cpu.memory.write_word 

21 

22 self.accu_a = self.cpu.accu_a 

23 self.accu_b = self.cpu.accu_b 

24 self.accu_d = self.cpu.accu_d 

25 self.cc_register = self.cpu.cc_register 

26 self.index_x = self.cpu.index_x 

27 self.index_y = self.cpu.index_y 

28 self.system_stack_pointer = self.cpu.system_stack_pointer 

29 self.user_stack_pointer = self.cpu.user_stack_pointer 

30 

31 self.get_ea_direct = self.cpu.get_ea_direct 

32 self.get_ea_extended = self.cpu.get_ea_extended 

33 self.get_ea_indexed = self.cpu.get_ea_indexed 

34 self.get_ea_m_direct = self.cpu.get_ea_m_direct 

35 self.get_ea_m_extended = self.cpu.get_ea_m_extended 

36 self.get_ea_m_indexed = self.cpu.get_ea_m_indexed 

37 self.get_ea_relative = self.cpu.get_ea_relative 

38 self.get_ea_relative_word = self.cpu.get_ea_relative_word 

39 self.get_m_direct = self.cpu.get_m_direct 

40 self.get_m_direct_word = self.cpu.get_m_direct_word 

41 self.get_m_extended = self.cpu.get_m_extended 

42 self.get_m_extended_word = self.cpu.get_m_extended_word 

43 self.get_m_immediate = self.cpu.get_m_immediate 

44 self.get_m_immediate_word = self.cpu.get_m_immediate_word 

45 self.get_m_indexed = self.cpu.get_m_indexed 

46 self.get_m_indexed_word = self.cpu.get_m_indexed_word 

47 

48 def direct_A_read8(self, opcode): 

49 self.instr_func( 

50 opcode=opcode, 

51 m=self.get_m_direct(), 

52 register=self.accu_a, 

53 ) 

54 

55 def direct_B_read8(self, opcode): 

56 self.instr_func( 

57 opcode=opcode, 

58 m=self.get_m_direct(), 

59 register=self.accu_b, 

60 ) 

61 

62 def direct_read8(self, opcode): 

63 self.instr_func( 

64 opcode=opcode, 

65 m=self.get_m_direct(), 

66 ) 

67 

68 def direct_ea_A_write8(self, opcode): 

69 ea, value = self.instr_func( 

70 opcode=opcode, 

71 ea=self.get_ea_direct(), 

72 register=self.accu_a, 

73 ) 

74 self.write_byte(ea, value) 

75 

76 def direct_ea_B_write8(self, opcode): 

77 ea, value = self.instr_func( 

78 opcode=opcode, 

79 ea=self.get_ea_direct(), 

80 register=self.accu_b, 

81 ) 

82 self.write_byte(ea, value) 

83 

84 def direct_ea_D_write16(self, opcode): 

85 ea, value = self.instr_func( 

86 opcode=opcode, 

87 ea=self.get_ea_direct(), 

88 register=self.accu_d, 

89 ) 

90 self.write_word(ea, value) 

91 

92 def direct_ea_read8_write8(self, opcode): 

93 ea, m = self.cpu.get_ea_m_direct() 

94 ea, value = self.instr_func( 

95 opcode=opcode, 

96 ea=ea, 

97 m=m, 

98 ) 

99 self.write_byte(ea, value) 

100 

101 def direct_ea_write8(self, opcode): 

102 ea, value = self.instr_func( 

103 opcode=opcode, 

104 ea=self.get_ea_direct(), 

105 ) 

106 self.write_byte(ea, value) 

107 

108 def direct_ea(self, opcode): 

109 self.instr_func( 

110 opcode=opcode, 

111 ea=self.get_ea_direct(), 

112 ) 

113 

114 def direct_ea_S_write16(self, opcode): 

115 ea, value = self.instr_func( 

116 opcode=opcode, 

117 ea=self.get_ea_direct(), 

118 register=self.system_stack_pointer, 

119 ) 

120 self.write_word(ea, value) 

121 

122 def direct_ea_U_write16(self, opcode): 

123 ea, value = self.instr_func( 

124 opcode=opcode, 

125 ea=self.get_ea_direct(), 

126 register=self.user_stack_pointer, 

127 ) 

128 self.write_word(ea, value) 

129 

130 def direct_ea_X_write16(self, opcode): 

131 ea, value = self.instr_func( 

132 opcode=opcode, 

133 ea=self.get_ea_direct(), 

134 register=self.index_x, 

135 ) 

136 self.write_word(ea, value) 

137 

138 def direct_ea_Y_write16(self, opcode): 

139 ea, value = self.instr_func( 

140 opcode=opcode, 

141 ea=self.get_ea_direct(), 

142 register=self.index_y, 

143 ) 

144 self.write_word(ea, value) 

145 

146 def direct_word_D_read16(self, opcode): 

147 self.instr_func( 

148 opcode=opcode, 

149 m=self.get_m_direct_word(), 

150 register=self.accu_d, 

151 ) 

152 

153 def direct_word_S_read16(self, opcode): 

154 self.instr_func( 

155 opcode=opcode, 

156 m=self.get_m_direct_word(), 

157 register=self.system_stack_pointer, 

158 ) 

159 

160 def direct_word_U_read16(self, opcode): 

161 self.instr_func( 

162 opcode=opcode, 

163 m=self.get_m_direct_word(), 

164 register=self.user_stack_pointer, 

165 ) 

166 

167 def direct_word_X_read16(self, opcode): 

168 self.instr_func( 

169 opcode=opcode, 

170 m=self.get_m_direct_word(), 

171 register=self.index_x, 

172 ) 

173 

174 def direct_word_Y_read16(self, opcode): 

175 self.instr_func( 

176 opcode=opcode, 

177 m=self.get_m_direct_word(), 

178 register=self.index_y, 

179 ) 

180 

181 def extended_A_read8(self, opcode): 

182 self.instr_func( 

183 opcode=opcode, 

184 m=self.get_m_extended(), 

185 register=self.accu_a, 

186 ) 

187 

188 def extended_B_read8(self, opcode): 

189 self.instr_func( 

190 opcode=opcode, 

191 m=self.get_m_extended(), 

192 register=self.accu_b, 

193 ) 

194 

195 def extended_read8(self, opcode): 

196 self.instr_func( 

197 opcode=opcode, 

198 m=self.get_m_extended(), 

199 ) 

200 

201 def extended_ea_A_write8(self, opcode): 

202 ea, value = self.instr_func( 

203 opcode=opcode, 

204 ea=self.get_ea_extended(), 

205 register=self.accu_a, 

206 ) 

207 self.write_byte(ea, value) 

208 

209 def extended_ea_B_write8(self, opcode): 

210 ea, value = self.instr_func( 

211 opcode=opcode, 

212 ea=self.get_ea_extended(), 

213 register=self.accu_b, 

214 ) 

215 self.write_byte(ea, value) 

216 

217 def extended_ea_D_write16(self, opcode): 

218 ea, value = self.instr_func( 

219 opcode=opcode, 

220 ea=self.get_ea_extended(), 

221 register=self.accu_d, 

222 ) 

223 self.write_word(ea, value) 

224 

225 def extended_ea_read8_write8(self, opcode): 

226 ea, m = self.cpu.get_ea_m_extended() 

227 ea, value = self.instr_func( 

228 opcode=opcode, 

229 ea=ea, 

230 m=m, 

231 ) 

232 self.write_byte(ea, value) 

233 

234 def extended_ea_write8(self, opcode): 

235 ea, value = self.instr_func( 

236 opcode=opcode, 

237 ea=self.get_ea_extended(), 

238 ) 

239 self.write_byte(ea, value) 

240 

241 def extended_ea(self, opcode): 

242 self.instr_func( 

243 opcode=opcode, 

244 ea=self.get_ea_extended(), 

245 ) 

246 

247 def extended_ea_S_write16(self, opcode): 

248 ea, value = self.instr_func( 

249 opcode=opcode, 

250 ea=self.get_ea_extended(), 

251 register=self.system_stack_pointer, 

252 ) 

253 self.write_word(ea, value) 

254 

255 def extended_ea_U_write16(self, opcode): 

256 ea, value = self.instr_func( 

257 opcode=opcode, 

258 ea=self.get_ea_extended(), 

259 register=self.user_stack_pointer, 

260 ) 

261 self.write_word(ea, value) 

262 

263 def extended_ea_X_write16(self, opcode): 

264 ea, value = self.instr_func( 

265 opcode=opcode, 

266 ea=self.get_ea_extended(), 

267 register=self.index_x, 

268 ) 

269 self.write_word(ea, value) 

270 

271 def extended_ea_Y_write16(self, opcode): 

272 ea, value = self.instr_func( 

273 opcode=opcode, 

274 ea=self.get_ea_extended(), 

275 register=self.index_y, 

276 ) 

277 self.write_word(ea, value) 

278 

279 def extended_word_D_read16(self, opcode): 

280 self.instr_func( 

281 opcode=opcode, 

282 m=self.get_m_extended_word(), 

283 register=self.accu_d, 

284 ) 

285 

286 def extended_word_S_read16(self, opcode): 

287 self.instr_func( 

288 opcode=opcode, 

289 m=self.get_m_extended_word(), 

290 register=self.system_stack_pointer, 

291 ) 

292 

293 def extended_word_U_read16(self, opcode): 

294 self.instr_func( 

295 opcode=opcode, 

296 m=self.get_m_extended_word(), 

297 register=self.user_stack_pointer, 

298 ) 

299 

300 def extended_word_X_read16(self, opcode): 

301 self.instr_func( 

302 opcode=opcode, 

303 m=self.get_m_extended_word(), 

304 register=self.index_x, 

305 ) 

306 

307 def extended_word_Y_read16(self, opcode): 

308 self.instr_func( 

309 opcode=opcode, 

310 m=self.get_m_extended_word(), 

311 register=self.index_y, 

312 ) 

313 

314 def immediate_A_read8(self, opcode): 

315 self.instr_func( 

316 opcode=opcode, 

317 m=self.get_m_immediate(), 

318 register=self.accu_a, 

319 ) 

320 

321 def immediate_B_read8(self, opcode): 

322 self.instr_func( 

323 opcode=opcode, 

324 m=self.get_m_immediate(), 

325 register=self.accu_b, 

326 ) 

327 

328 def immediate_CC_read8(self, opcode): 

329 self.instr_func( 

330 opcode=opcode, 

331 m=self.get_m_immediate(), 

332 register=self.cc_register, 

333 ) 

334 

335 def immediate_read8(self, opcode): 

336 self.instr_func( 

337 opcode=opcode, 

338 m=self.get_m_immediate(), 

339 ) 

340 

341 def immediate_S_read8(self, opcode): 

342 self.instr_func( 

343 opcode=opcode, 

344 m=self.get_m_immediate(), 

345 register=self.system_stack_pointer, 

346 ) 

347 

348 def immediate_U_read8(self, opcode): 

349 self.instr_func( 

350 opcode=opcode, 

351 m=self.get_m_immediate(), 

352 register=self.user_stack_pointer, 

353 ) 

354 

355 def immediate_word_D_read16(self, opcode): 

356 self.instr_func( 

357 opcode=opcode, 

358 m=self.get_m_immediate_word(), 

359 register=self.accu_d, 

360 ) 

361 

362 def immediate_word_S_read16(self, opcode): 

363 self.instr_func( 

364 opcode=opcode, 

365 m=self.get_m_immediate_word(), 

366 register=self.system_stack_pointer, 

367 ) 

368 

369 def immediate_word_U_read16(self, opcode): 

370 self.instr_func( 

371 opcode=opcode, 

372 m=self.get_m_immediate_word(), 

373 register=self.user_stack_pointer, 

374 ) 

375 

376 def immediate_word_X_read16(self, opcode): 

377 self.instr_func( 

378 opcode=opcode, 

379 m=self.get_m_immediate_word(), 

380 register=self.index_x, 

381 ) 

382 

383 def immediate_word_Y_read16(self, opcode): 

384 self.instr_func( 

385 opcode=opcode, 

386 m=self.get_m_immediate_word(), 

387 register=self.index_y, 

388 ) 

389 

390 def indexed_A_read8(self, opcode): 

391 self.instr_func( 

392 opcode=opcode, 

393 m=self.get_m_indexed(), 

394 register=self.accu_a, 

395 ) 

396 

397 def indexed_B_read8(self, opcode): 

398 self.instr_func( 

399 opcode=opcode, 

400 m=self.get_m_indexed(), 

401 register=self.accu_b, 

402 ) 

403 

404 def indexed_read8(self, opcode): 

405 self.instr_func( 

406 opcode=opcode, 

407 m=self.get_m_indexed(), 

408 ) 

409 

410 def indexed_ea_A_write8(self, opcode): 

411 ea, value = self.instr_func( 

412 opcode=opcode, 

413 ea=self.get_ea_indexed(), 

414 register=self.accu_a, 

415 ) 

416 self.write_byte(ea, value) 

417 

418 def indexed_ea_B_write8(self, opcode): 

419 ea, value = self.instr_func( 

420 opcode=opcode, 

421 ea=self.get_ea_indexed(), 

422 register=self.accu_b, 

423 ) 

424 self.write_byte(ea, value) 

425 

426 def indexed_ea_D_write16(self, opcode): 

427 ea, value = self.instr_func( 

428 opcode=opcode, 

429 ea=self.get_ea_indexed(), 

430 register=self.accu_d, 

431 ) 

432 self.write_word(ea, value) 

433 

434 def indexed_ea_read8_write8(self, opcode): 

435 ea, m = self.cpu.get_ea_m_indexed() 

436 ea, value = self.instr_func( 

437 opcode=opcode, 

438 ea=ea, 

439 m=m, 

440 ) 

441 self.write_byte(ea, value) 

442 

443 def indexed_ea_write8(self, opcode): 

444 ea, value = self.instr_func( 

445 opcode=opcode, 

446 ea=self.get_ea_indexed(), 

447 ) 

448 self.write_byte(ea, value) 

449 

450 def indexed_ea(self, opcode): 

451 self.instr_func( 

452 opcode=opcode, 

453 ea=self.get_ea_indexed(), 

454 ) 

455 

456 def indexed_ea_S_write16(self, opcode): 

457 ea, value = self.instr_func( 

458 opcode=opcode, 

459 ea=self.get_ea_indexed(), 

460 register=self.system_stack_pointer, 

461 ) 

462 self.write_word(ea, value) 

463 

464 def indexed_ea_S(self, opcode): 

465 self.instr_func( 

466 opcode=opcode, 

467 ea=self.get_ea_indexed(), 

468 register=self.system_stack_pointer, 

469 ) 

470 

471 def indexed_ea_U_write16(self, opcode): 

472 ea, value = self.instr_func( 

473 opcode=opcode, 

474 ea=self.get_ea_indexed(), 

475 register=self.user_stack_pointer, 

476 ) 

477 self.write_word(ea, value) 

478 

479 def indexed_ea_U(self, opcode): 

480 self.instr_func( 

481 opcode=opcode, 

482 ea=self.get_ea_indexed(), 

483 register=self.user_stack_pointer, 

484 ) 

485 

486 def indexed_ea_X_write16(self, opcode): 

487 ea, value = self.instr_func( 

488 opcode=opcode, 

489 ea=self.get_ea_indexed(), 

490 register=self.index_x, 

491 ) 

492 self.write_word(ea, value) 

493 

494 def indexed_ea_X(self, opcode): 

495 self.instr_func( 

496 opcode=opcode, 

497 ea=self.get_ea_indexed(), 

498 register=self.index_x, 

499 ) 

500 

501 def indexed_ea_Y_write16(self, opcode): 

502 ea, value = self.instr_func( 

503 opcode=opcode, 

504 ea=self.get_ea_indexed(), 

505 register=self.index_y, 

506 ) 

507 self.write_word(ea, value) 

508 

509 def indexed_ea_Y(self, opcode): 

510 self.instr_func( 

511 opcode=opcode, 

512 ea=self.get_ea_indexed(), 

513 register=self.index_y, 

514 ) 

515 

516 def indexed_word_D_read16(self, opcode): 

517 self.instr_func( 

518 opcode=opcode, 

519 m=self.get_m_indexed_word(), 

520 register=self.accu_d, 

521 ) 

522 

523 def indexed_word_S_read16(self, opcode): 

524 self.instr_func( 

525 opcode=opcode, 

526 m=self.get_m_indexed_word(), 

527 register=self.system_stack_pointer, 

528 ) 

529 

530 def indexed_word_U_read16(self, opcode): 

531 self.instr_func( 

532 opcode=opcode, 

533 m=self.get_m_indexed_word(), 

534 register=self.user_stack_pointer, 

535 ) 

536 

537 def indexed_word_X_read16(self, opcode): 

538 self.instr_func( 

539 opcode=opcode, 

540 m=self.get_m_indexed_word(), 

541 register=self.index_x, 

542 ) 

543 

544 def indexed_word_Y_read16(self, opcode): 

545 self.instr_func( 

546 opcode=opcode, 

547 m=self.get_m_indexed_word(), 

548 register=self.index_y, 

549 ) 

550 

551 def inherent_A(self, opcode): 

552 self.instr_func( 

553 opcode=opcode, 

554 register=self.accu_a, 

555 ) 

556 

557 def inherent_B(self, opcode): 

558 self.instr_func( 

559 opcode=opcode, 

560 register=self.accu_b, 

561 ) 

562 

563 def inherent(self, opcode): 

564 self.instr_func( 

565 opcode=opcode, 

566 ) 

567 

568 def relative_ea(self, opcode): 

569 self.instr_func( 

570 opcode=opcode, 

571 ea=self.get_ea_relative(), 

572 ) 

573 

574 def relative_word_ea(self, opcode): 

575 self.instr_func( 

576 opcode=opcode, 

577 ea=self.get_ea_relative_word(), 

578 )