6502/erc-c
1
0
Fork 0
mirror of https://github.com/pevans/erc-c.git synced 2024-12-21 08:30:55 +00:00
Code Issues Projects Releases Wiki Activity

Rename status flags to MOS_

Browse Source
This commit is contained in:
Peter Evans 2018-01-05 14:18:39 -06:00
parent 2da613f7aa
commit 1de1e7788a
17 changed files with 166 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
include/mos6502.enums.h
View File

@ -17,13 +17,13 @@
* 6th bit. * 6th bit.
*/ */
enum status_flags { enum status_flags {
CARRY = 1, MOS_CARRY = 1,
ZERO = 2, MOS_ZERO = 2,
INTERRUPT = 4, MOS_INTERRUPT = 4,
DECIMAL = 8, MOS_DECIMAL = 8,
BREAK = 16, MOS_BREAK = 16,
OVERFLOW = 64, MOS_OVERFLOW = 64,
NEGATIVE = 128, MOS_NEGATIVE = 128,
}; };
/* /*

4
include/mos6502.h
View File

@ -32,9 +32,9 @@
* therefore, the literal value we are adding, rather than a boolean * therefore, the literal value we are adding, rather than a boolean
* signifier. * signifier.
*/ */
#define CARRY_BIT() \ #define MOS_CARRY_BIT() \
vm_8bit carry = 0; \ vm_8bit carry = 0; \
if (cpu->P & CARRY) carry = 1 if (cpu->P & MOS_CARRY) carry = 1
/* /*
* A uniform way of declaring resolve functions for address modes, which * A uniform way of declaring resolve functions for address modes, which

6
src/mos6502.addr.c
View File

@ -141,7 +141,7 @@ DEFINE_ADDR(abs)
DEFINE_ADDR(abx) DEFINE_ADDR(abx)
{ {
ADDR_HILO(cpu); ADDR_HILO(cpu);
CARRY_BIT(); MOS_CARRY_BIT();
EFF_ADDR(addr + cpu->X + carry); EFF_ADDR(addr + cpu->X + carry);
return vm_segment_get(cpu->memory, eff_addr); return vm_segment_get(cpu->memory, eff_addr);
@ -154,7 +154,7 @@ DEFINE_ADDR(abx)
DEFINE_ADDR(aby) DEFINE_ADDR(aby)
{ {
ADDR_HILO(cpu); ADDR_HILO(cpu);
CARRY_BIT(); MOS_CARRY_BIT();
EFF_ADDR(addr + cpu->Y + carry); EFF_ADDR(addr + cpu->Y + carry);
return vm_segment_get(cpu->memory, eff_addr); return vm_segment_get(cpu->memory, eff_addr);
@ -217,7 +217,7 @@ DEFINE_ADDR(idx)
DEFINE_ADDR(idy) DEFINE_ADDR(idy)
{ {
ADDR_LO(cpu); ADDR_LO(cpu);
CARRY_BIT(); MOS_CARRY_BIT();
EFF_ADDR(vm_segment_get(cpu->memory, addr) + cpu->Y + carry); EFF_ADDR(vm_segment_get(cpu->memory, addr) + cpu->Y + carry);
return vm_segment_get(cpu->memory, eff_addr); return vm_segment_get(cpu->memory, eff_addr);

26
src/mos6502.arith.c
View File

@ -15,10 +15,10 @@
*/ */
DEFINE_INST(adc) DEFINE_INST(adc)
{ {
CARRY_BIT(); MOS_CARRY_BIT();
cpu->A += oper + carry; cpu->A += oper + carry;
mos6502_modify_status(cpu, NEGATIVE | OVERFLOW | CARRY | ZERO, cpu->A); mos6502_modify_status(cpu, MOS_NEGATIVE | MOS_OVERFLOW | MOS_CARRY | MOS_ZERO, cpu->A);
} }
/* /*
@ -30,7 +30,7 @@ DEFINE_INST(adc)
*/ */
DEFINE_INST(cmp) DEFINE_INST(cmp)
{ {
mos6502_modify_status(cpu, ZERO | NEGATIVE | CARRY, cpu->A - oper); mos6502_modify_status(cpu, MOS_ZERO | MOS_NEGATIVE | MOS_CARRY, cpu->A - oper);
} }
/* /*
@ -39,7 +39,7 @@ DEFINE_INST(cmp)
*/ */
DEFINE_INST(cpx) DEFINE_INST(cpx)
{ {
mos6502_modify_status(cpu, ZERO | NEGATIVE | CARRY, cpu->X - oper); mos6502_modify_status(cpu, MOS_ZERO | MOS_NEGATIVE | MOS_CARRY, cpu->X - oper);
} }
/* /*
@ -48,7 +48,7 @@ DEFINE_INST(cpx)
*/ */
DEFINE_INST(cpy) DEFINE_INST(cpy)
{ {
mos6502_modify_status(cpu, ZERO | NEGATIVE | CARRY, cpu->Y - oper); mos6502_modify_status(cpu, MOS_ZERO | MOS_NEGATIVE | MOS_CARRY, cpu->Y - oper);
} }
/* /*
@ -61,7 +61,7 @@ DEFINE_INST(dec)
{ {
if (cpu->last_addr) { if (cpu->last_addr) {
vm_segment_set(cpu->memory, cpu->last_addr, oper - 1); vm_segment_set(cpu->memory, cpu->last_addr, oper - 1);
mos6502_modify_status(cpu, NEGATIVE | ZERO, oper - 1); mos6502_modify_status(cpu, MOS_NEGATIVE | MOS_ZERO, oper - 1);
} }
} }
@ -71,7 +71,7 @@ DEFINE_INST(dec)
DEFINE_INST(dex) DEFINE_INST(dex)
{ {
cpu->X--; cpu->X--;
mos6502_modify_status(cpu, NEGATIVE | ZERO, cpu->X); mos6502_modify_status(cpu, MOS_NEGATIVE | MOS_ZERO, cpu->X);
} }
/* /*
@ -80,7 +80,7 @@ DEFINE_INST(dex)
DEFINE_INST(dey) DEFINE_INST(dey)
{ {
cpu->Y--; cpu->Y--;
mos6502_modify_status(cpu, NEGATIVE | ZERO, cpu->Y); mos6502_modify_status(cpu, MOS_NEGATIVE | MOS_ZERO, cpu->Y);
} }
/* /*
@ -92,7 +92,7 @@ DEFINE_INST(inc)
{ {
if (cpu->last_addr) { if (cpu->last_addr) {
vm_segment_set(cpu->memory, cpu->last_addr, oper + 1); vm_segment_set(cpu->memory, cpu->last_addr, oper + 1);
mos6502_modify_status(cpu, NEGATIVE | ZERO, oper + 1); mos6502_modify_status(cpu, MOS_NEGATIVE | MOS_ZERO, oper + 1);
} }
} }
@ -102,7 +102,7 @@ DEFINE_INST(inc)
DEFINE_INST(inx) DEFINE_INST(inx)
{ {
cpu->X++; cpu->X++;
mos6502_modify_status(cpu, NEGATIVE | ZERO, cpu->X); mos6502_modify_status(cpu, MOS_NEGATIVE | MOS_ZERO, cpu->X);
} }
/* /*
@ -111,7 +111,7 @@ DEFINE_INST(inx)
DEFINE_INST(iny) DEFINE_INST(iny)
{ {
cpu->Y++; cpu->Y++;
mos6502_modify_status(cpu, NEGATIVE | ZERO, cpu->Y); mos6502_modify_status(cpu, MOS_NEGATIVE | MOS_ZERO, cpu->Y);
} }
/* /*
@ -122,8 +122,8 @@ DEFINE_INST(iny)
*/ */
DEFINE_INST(sbc) DEFINE_INST(sbc)
{ {
CARRY_BIT(); MOS_CARRY_BIT();
cpu->A = cpu->A - oper - carry; cpu->A = cpu->A - oper - carry;
mos6502_modify_status(cpu, NEGATIVE | OVERFLOW | CARRY | ZERO, cpu->A); mos6502_modify_status(cpu, MOS_NEGATIVE | MOS_OVERFLOW | MOS_CARRY | MOS_ZERO, cpu->A);
} }

44
src/mos6502.bits.c
View File

@ -15,7 +15,7 @@
DEFINE_INST(and) DEFINE_INST(and)
{ {
cpu->A &= oper; cpu->A &= oper;
mos6502_modify_status(cpu, NEGATIVE | ZERO, cpu->A); mos6502_modify_status(cpu, MOS_NEGATIVE | MOS_ZERO, cpu->A);
} }
/* /*
@ -31,9 +31,9 @@ DEFINE_INST(and)
*/ */
DEFINE_INST(asl) DEFINE_INST(asl)
{ {
cpu->P &= ~CARRY; cpu->P &= ~MOS_CARRY;
if (oper & 0x80) { if (oper & 0x80) {
cpu->P |= CARRY; cpu->P |= MOS_CARRY;
} }
oper <<= 1; oper <<= 1;
@ -44,7 +44,7 @@ DEFINE_INST(asl)
cpu->A = oper; cpu->A = oper;
} }
mos6502_modify_status(cpu, NEGATIVE | CARRY | ZERO, oper); mos6502_modify_status(cpu, MOS_NEGATIVE | MOS_CARRY | MOS_ZERO, oper);
} }
/* /*
@ -54,20 +54,20 @@ DEFINE_INST(asl)
*/ */
DEFINE_INST(bit) DEFINE_INST(bit)
{ {
cpu->P &= ~NEGATIVE; cpu->P &= ~MOS_NEGATIVE;
if (oper & NEGATIVE) { if (oper & MOS_NEGATIVE) {
cpu->P |= NEGATIVE; cpu->P |= MOS_NEGATIVE;
} }
cpu->P &= ~OVERFLOW; cpu->P &= ~MOS_OVERFLOW;
if (oper & OVERFLOW) { if (oper & MOS_OVERFLOW) {
cpu->P |= OVERFLOW; cpu->P |= MOS_OVERFLOW;
} }
if (oper & cpu->A) { if (oper & cpu->A) {
cpu->P &= ~ZERO; cpu->P &= ~MOS_ZERO;
} else { } else {
cpu->P |= ZERO; cpu->P |= MOS_ZERO;
} }
} }
@ -78,7 +78,7 @@ DEFINE_INST(bit)
DEFINE_INST(eor) DEFINE_INST(eor)
{ {
cpu->A ^= oper; cpu->A ^= oper;
mos6502_modify_status(cpu, NEGATIVE | ZERO, cpu->A); mos6502_modify_status(cpu, MOS_NEGATIVE | MOS_ZERO, cpu->A);
} }
/* /*
@ -90,9 +90,9 @@ DEFINE_INST(eor)
*/ */
DEFINE_INST(lsr) DEFINE_INST(lsr)
{ {
cpu->P &= ~CARRY; cpu->P &= ~MOS_CARRY;
if (oper & 0x01) { if (oper & 0x01) {
cpu->P |= CARRY; cpu->P |= MOS_CARRY;
} }
oper >>= 1; oper >>= 1;
@ -103,8 +103,8 @@ DEFINE_INST(lsr)
cpu->A = oper; cpu->A = oper;
} }
// NEGATIVE is intentionally not included here. // MOS_NEGATIVE is intentionally not included here.
mos6502_modify_status(cpu, CARRY | ZERO, oper); mos6502_modify_status(cpu, MOS_CARRY | MOS_ZERO, oper);
} }
/* /*
@ -114,7 +114,7 @@ DEFINE_INST(lsr)
DEFINE_INST(ora) DEFINE_INST(ora)
{ {
cpu->A |= oper; cpu->A |= oper;
mos6502_modify_status(cpu, NEGATIVE | ZERO, cpu->A); mos6502_modify_status(cpu, MOS_NEGATIVE | MOS_ZERO, cpu->A);
} }
/* /*
@ -124,7 +124,7 @@ DEFINE_INST(ora)
*/ */
DEFINE_INST(rol) DEFINE_INST(rol)
{ {
CARRY_BIT(); MOS_CARRY_BIT();
if (oper & 0x80) { if (oper & 0x80) {
carry = 1; carry = 1;
@ -142,7 +142,7 @@ DEFINE_INST(rol)
cpu->A = oper; cpu->A = oper;
} }
mos6502_modify_status(cpu, NEGATIVE | CARRY | ZERO, oper); mos6502_modify_status(cpu, MOS_NEGATIVE | MOS_CARRY | MOS_ZERO, oper);
} }
/* /*
@ -151,7 +151,7 @@ DEFINE_INST(rol)
*/ */
DEFINE_INST(ror) DEFINE_INST(ror)
{ {
CARRY_BIT(); MOS_CARRY_BIT();
if (oper & 0x01) { if (oper & 0x01) {
carry = 1; carry = 1;
@ -169,5 +169,5 @@ DEFINE_INST(ror)
cpu->A = oper; cpu->A = oper;
} }
mos6502_modify_status(cpu, NEGATIVE | CARRY | ZERO, oper); mos6502_modify_status(cpu, MOS_NEGATIVE | MOS_CARRY | MOS_ZERO, oper);
} }

16
src/mos6502.branch.c
View File

@ -21,7 +21,7 @@
*/ */
DEFINE_INST(bcc) DEFINE_INST(bcc)
{ {
JUMP_IF(~cpu->P & CARRY); JUMP_IF(~cpu->P & MOS_CARRY);
} }
/* /*
@ -29,7 +29,7 @@ DEFINE_INST(bcc)
*/ */
DEFINE_INST(bcs) DEFINE_INST(bcs)
{ {
JUMP_IF(cpu->P & CARRY); JUMP_IF(cpu->P & MOS_CARRY);
} }
/* /*
@ -38,7 +38,7 @@ DEFINE_INST(bcs)
*/ */
DEFINE_INST(beq) DEFINE_INST(beq)
{ {
JUMP_IF(cpu->P & ZERO); JUMP_IF(cpu->P & MOS_ZERO);
} }
/* /*
@ -46,7 +46,7 @@ DEFINE_INST(beq)
*/ */
DEFINE_INST(bmi) DEFINE_INST(bmi)
{ {
JUMP_IF(cpu->P & NEGATIVE); JUMP_IF(cpu->P & MOS_NEGATIVE);
} }
/* /*
@ -55,7 +55,7 @@ DEFINE_INST(bmi)
*/ */
DEFINE_INST(bne) DEFINE_INST(bne)
{ {
JUMP_IF(~cpu->P & ZERO); JUMP_IF(~cpu->P & MOS_ZERO);
} }
/* /*
@ -64,7 +64,7 @@ DEFINE_INST(bne)
*/ */
DEFINE_INST(bpl) DEFINE_INST(bpl)
{ {
JUMP_IF(~cpu->P & NEGATIVE); JUMP_IF(~cpu->P & MOS_NEGATIVE);
} }
/* /*
@ -72,7 +72,7 @@ DEFINE_INST(bpl)
*/ */
DEFINE_INST(bvc) DEFINE_INST(bvc)
{ {
JUMP_IF(~cpu->P & OVERFLOW); JUMP_IF(~cpu->P & MOS_OVERFLOW);
} }
/* /*
@ -80,5 +80,5 @@ DEFINE_INST(bvc)
*/ */
DEFINE_INST(bvs) DEFINE_INST(bvs)
{ {
JUMP_IF(cpu->P & OVERFLOW); JUMP_IF(cpu->P & MOS_OVERFLOW);
} }

35
src/mos6502.c
View File

@ -9,6 +9,7 @@
#include <stdbool.h> #include <stdbool.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
#include "log.h" #include "log.h"
#include "mos6502.h" #include "mos6502.h"
@ -252,31 +253,31 @@ mos6502_set_status(mos6502 *cpu, vm_8bit status)
void void
mos6502_modify_status(mos6502 *cpu, vm_8bit status, vm_8bit oper) mos6502_modify_status(mos6502 *cpu, vm_8bit status, vm_8bit oper)
{ {
if (status & NEGATIVE) { if (status & MOS_NEGATIVE) {
cpu->P &= ~NEGATIVE; cpu->P &= ~MOS_NEGATIVE;
if (oper & 0x80) { if (oper & 0x80) {
cpu->P |= NEGATIVE; cpu->P |= MOS_NEGATIVE;
} }
} }
if (status & OVERFLOW) { if (status & MOS_OVERFLOW) {
cpu->P &= ~OVERFLOW; cpu->P &= ~MOS_OVERFLOW;
if (oper & OVERFLOW) { if (oper & MOS_OVERFLOW) {
cpu->P |= OVERFLOW; cpu->P |= MOS_OVERFLOW;
} }
} }
if (status & CARRY) { if (status & MOS_CARRY) {
cpu->P &= ~CARRY; cpu->P &= ~MOS_CARRY;
if (oper > 0) { if (oper > 0) {
cpu->P |= CARRY; cpu->P |= MOS_CARRY;
} }
} }
if (status & ZERO) { if (status & MOS_ZERO) {
cpu->P &= ~ZERO; cpu->P &= ~MOS_ZERO;
if (oper == 0) { if (oper == 0) {
cpu->P |= ZERO; cpu->P |= MOS_ZERO;
} }
} }
} }
@ -352,7 +353,7 @@ void
mos6502_execute(mos6502 *cpu, vm_8bit opcode) mos6502_execute(mos6502 *cpu, vm_8bit opcode)
{ {
vm_8bit operand; vm_8bit operand;
//int cycles; int cycles;
mos6502_address_resolver resolver; mos6502_address_resolver resolver;
mos6502_instruction_handler handler; mos6502_instruction_handler handler;
@ -380,9 +381,11 @@ mos6502_execute(mos6502 *cpu, vm_8bit opcode)
// with the idea that certain instructions -- in certain address // with the idea that certain instructions -- in certain address
// modes -- were more expensive than others, and you want those // modes -- were more expensive than others, and you want those
// programs to feel faster or slower in relation to that. // programs to feel faster or slower in relation to that.
//cycles = mos6502_cycles(cpu, opcode); cycles = mos6502_cycles(cpu, opcode);
// FIXME: actually emulate the cycles // FIXME: uh this probably isn't right, but I wanted to do
// something.
usleep(cycles * 100000);
// Ok -- we're done! This wasn't so hard, was it? // Ok -- we're done! This wasn't so hard, was it?
return; return;

2
src/mos6502.exec.c
View File

@ -16,7 +16,7 @@ DEFINE_INST(brk)
{ {
mos6502_push_stack(cpu, cpu->PC); mos6502_push_stack(cpu, cpu->PC);
mos6502_push_stack(cpu, cpu->P); mos6502_push_stack(cpu, cpu->P);
cpu->P |= INTERRUPT; cpu->P |= MOS_INTERRUPT;
cpu->PC += 2; cpu->PC += 2;
} }

20
src/mos6502.loadstor.c
View File

@ -14,7 +14,7 @@
*/ */
DEFINE_INST(lda) DEFINE_INST(lda)
{ {
mos6502_modify_status(cpu, ZERO | NEGATIVE, oper); mos6502_modify_status(cpu, MOS_ZERO | MOS_NEGATIVE, oper);
cpu->A = oper; cpu->A = oper;
} }
@ -23,7 +23,7 @@ DEFINE_INST(lda)
*/ */
DEFINE_INST(ldx) DEFINE_INST(ldx)
{ {
mos6502_modify_status(cpu, ZERO | NEGATIVE, oper); mos6502_modify_status(cpu, MOS_ZERO | MOS_NEGATIVE, oper);
cpu->X = oper; cpu->X = oper;
} }
@ -32,7 +32,7 @@ DEFINE_INST(ldx)
*/ */
DEFINE_INST(ldy) DEFINE_INST(ldy)
{ {
mos6502_modify_status(cpu, ZERO | NEGATIVE, oper); mos6502_modify_status(cpu, MOS_ZERO | MOS_NEGATIVE, oper);
cpu->Y = oper; cpu->Y = oper;
} }
@ -58,7 +58,7 @@ DEFINE_INST(php)
DEFINE_INST(pla) DEFINE_INST(pla)
{ {
cpu->A = mos6502_pop_stack(cpu); cpu->A = mos6502_pop_stack(cpu);
mos6502_modify_status(cpu, NEGATIVE | ZERO, cpu->A); mos6502_modify_status(cpu, MOS_NEGATIVE | MOS_ZERO, cpu->A);
} }
/* /*
@ -100,7 +100,7 @@ DEFINE_INST(sty)
*/ */
DEFINE_INST(tax) DEFINE_INST(tax)
{ {
mos6502_modify_status(cpu, ZERO | NEGATIVE, cpu->A); mos6502_modify_status(cpu, MOS_ZERO | MOS_NEGATIVE, cpu->A);
cpu->X = cpu->A; cpu->X = cpu->A;
} }
@ -109,7 +109,7 @@ DEFINE_INST(tax)
*/ */
DEFINE_INST(tay) DEFINE_INST(tay)
{ {
mos6502_modify_status(cpu, ZERO | NEGATIVE, cpu->A); mos6502_modify_status(cpu, MOS_ZERO | MOS_NEGATIVE, cpu->A);
cpu->Y = cpu->A; cpu->Y = cpu->A;
} }
@ -118,7 +118,7 @@ DEFINE_INST(tay)
*/ */
DEFINE_INST(tsx) DEFINE_INST(tsx)
{ {
mos6502_modify_status(cpu, ZERO | NEGATIVE, cpu->S); mos6502_modify_status(cpu, MOS_ZERO | MOS_NEGATIVE, cpu->S);
cpu->X = cpu->S; cpu->X = cpu->S;
} }
@ -127,7 +127,7 @@ DEFINE_INST(tsx)
*/ */
DEFINE_INST(txa) DEFINE_INST(txa)
{ {
mos6502_modify_status(cpu, ZERO | NEGATIVE, cpu->X); mos6502_modify_status(cpu, MOS_ZERO | MOS_NEGATIVE, cpu->X);
cpu->A = cpu->X; cpu->A = cpu->X;
} }
@ -136,7 +136,7 @@ DEFINE_INST(txa)
*/ */
DEFINE_INST(txs) DEFINE_INST(txs)
{ {
mos6502_modify_status(cpu, ZERO | NEGATIVE, cpu->X); mos6502_modify_status(cpu, MOS_ZERO | MOS_NEGATIVE, cpu->X);
cpu->S = cpu->X; cpu->S = cpu->X;
} }
@ -145,6 +145,6 @@ DEFINE_INST(txs)
*/ */
DEFINE_INST(tya) DEFINE_INST(tya)
{ {
mos6502_modify_status(cpu, ZERO | NEGATIVE, cpu->Y); mos6502_modify_status(cpu, MOS_ZERO | MOS_NEGATIVE, cpu->Y);
cpu->A = cpu->Y; cpu->A = cpu->Y;
} }

14
src/mos6502.stat.c
View File

@ -13,7 +13,7 @@
*/ */
DEFINE_INST(clc) DEFINE_INST(clc)
{ {
cpu->P &= ~CARRY; cpu->P &= ~MOS_CARRY;
} }
/* /*
@ -21,7 +21,7 @@ DEFINE_INST(clc)
*/ */
DEFINE_INST(cld) DEFINE_INST(cld)
{ {
cpu->P &= ~DECIMAL; cpu->P &= ~MOS_DECIMAL;
} }
/* /*
@ -29,7 +29,7 @@ DEFINE_INST(cld)
*/ */
DEFINE_INST(cli) DEFINE_INST(cli)
{ {
cpu->P &= ~INTERRUPT; cpu->P &= ~MOS_INTERRUPT;
} }
/* /*
@ -37,7 +37,7 @@ DEFINE_INST(cli)
*/ */
DEFINE_INST(clv) DEFINE_INST(clv)
{ {
cpu->P &= ~OVERFLOW; cpu->P &= ~MOS_OVERFLOW;
} }
/* /*
@ -45,7 +45,7 @@ DEFINE_INST(clv)
*/ */
DEFINE_INST(sec) DEFINE_INST(sec)
{ {
cpu->P |= CARRY; cpu->P |= MOS_CARRY;
} }
/* /*
@ -53,7 +53,7 @@ DEFINE_INST(sec)
*/ */
DEFINE_INST(sed) DEFINE_INST(sed)
{ {
cpu->P |= DECIMAL; cpu->P |= MOS_DECIMAL;
} }
/* /*
@ -61,5 +61,5 @@ DEFINE_INST(sed)
*/ */
DEFINE_INST(sei) DEFINE_INST(sei)
{ {
cpu->P |= INTERRUPT; cpu->P |= MOS_INTERRUPT;
} }

4
tests/mos6502.addr.c
View File

@ -58,7 +58,7 @@ Test(mos6502_addr, addr_mode_abx_carry1)
SET_PC_BYTE(cpu, 0, 0x12); SET_PC_BYTE(cpu, 0, 0x12);
SET_PC_BYTE(cpu, 1, 0x30); SET_PC_BYTE(cpu, 1, 0x30);
cpu->X = 3; cpu->X = 3;
cpu->P = cpu->P | CARRY; cpu->P = cpu->P | MOS_CARRY;
cr_assert_eq(mos6502_resolve_abx(cpu), 111); cr_assert_eq(mos6502_resolve_abx(cpu), 111);
} }
@ -77,7 +77,7 @@ Test(mos6502_addr, addr_mode_aby_carry1)
SET_PC_BYTE(cpu, 0, 0x12); SET_PC_BYTE(cpu, 0, 0x12);
SET_PC_BYTE(cpu, 1, 0x30); SET_PC_BYTE(cpu, 1, 0x30);
cpu->Y = 3; cpu->Y = 3;
cpu->P = cpu->P | CARRY; cpu->P = cpu->P | MOS_CARRY;
cr_assert_eq(mos6502_resolve_aby(cpu), 111); cr_assert_eq(mos6502_resolve_aby(cpu), 111);
} }

34
tests/mos6502.arith.c
View File

@ -12,7 +12,7 @@ Test(mos6502_arith, adc)
mos6502_handle_adc(cpu, 3); mos6502_handle_adc(cpu, 3);
cr_assert_eq(cpu->A, 8); cr_assert_eq(cpu->A, 8);
cpu->P |= CARRY; cpu->P |= MOS_CARRY;
mos6502_handle_adc(cpu, 64); mos6502_handle_adc(cpu, 64);
cr_assert_eq(cpu->A, 73); cr_assert_eq(cpu->A, 73);
} }
@ -21,39 +21,39 @@ Test(mos6502_arith, cmp)
{ {
cpu->A = 5; cpu->A = 5;
mos6502_handle_cmp(cpu, 3); mos6502_handle_cmp(cpu, 3);
cr_assert_eq(cpu->P & CARRY, CARRY); cr_assert_eq(cpu->P & MOS_CARRY, MOS_CARRY);
cr_assert_eq(cpu->P & NEGATIVE, 0); cr_assert_eq(cpu->P & MOS_NEGATIVE, 0);
cr_assert_eq(cpu->P & ZERO, 0); cr_assert_eq(cpu->P & MOS_ZERO, 0);
cpu->A = 3; cpu->A = 3;
mos6502_handle_cmp(cpu, 3); mos6502_handle_cmp(cpu, 3);
cr_assert_eq(cpu->P & CARRY, 0); cr_assert_eq(cpu->P & MOS_CARRY, 0);
cr_assert_eq(cpu->P & NEGATIVE, 0); cr_assert_eq(cpu->P & MOS_NEGATIVE, 0);
cr_assert_eq(cpu->P & ZERO, ZERO); cr_assert_eq(cpu->P & MOS_ZERO, MOS_ZERO);
cpu->A = 192; cpu->A = 192;
mos6502_handle_cmp(cpu, 3); mos6502_handle_cmp(cpu, 3);
cr_assert_eq(cpu->P & CARRY, CARRY); cr_assert_eq(cpu->P & MOS_CARRY, MOS_CARRY);
cr_assert_eq(cpu->P & NEGATIVE, NEGATIVE); cr_assert_eq(cpu->P & MOS_NEGATIVE, MOS_NEGATIVE);
cr_assert_eq(cpu->P & ZERO, 0); cr_assert_eq(cpu->P & MOS_ZERO, 0);
} }
Test(mos6502_arith, cpx) Test(mos6502_arith, cpx)
{ {
cpu->X = 5; cpu->X = 5;
mos6502_handle_cpx(cpu, 3); mos6502_handle_cpx(cpu, 3);
cr_assert_eq(cpu->P & CARRY, CARRY); cr_assert_eq(cpu->P & MOS_CARRY, MOS_CARRY);
cr_assert_eq(cpu->P & NEGATIVE, 0); cr_assert_eq(cpu->P & MOS_NEGATIVE, 0);
cr_assert_eq(cpu->P & ZERO, 0); cr_assert_eq(cpu->P & MOS_ZERO, 0);
} }
Test(mos6502_arith, cpy) Test(mos6502_arith, cpy)
{ {
cpu->Y = 5; cpu->Y = 5;
mos6502_handle_cpy(cpu, 3); mos6502_handle_cpy(cpu, 3);
cr_assert_eq(cpu->P & CARRY, CARRY); cr_assert_eq(cpu->P & MOS_CARRY, MOS_CARRY);
cr_assert_eq(cpu->P & NEGATIVE, 0); cr_assert_eq(cpu->P & MOS_NEGATIVE, 0);
cr_assert_eq(cpu->P & ZERO, 0); cr_assert_eq(cpu->P & MOS_ZERO, 0);
} }
Test(mos6502_arith, dec) Test(mos6502_arith, dec)
@ -115,7 +115,7 @@ Test(mos6502_arith, sbc)
mos6502_handle_sbc(cpu, 3); mos6502_handle_sbc(cpu, 3);
cr_assert_eq(cpu->A, 2); cr_assert_eq(cpu->A, 2);
cpu->P |= CARRY; cpu->P |= MOS_CARRY;
cpu->A = 16; cpu->A = 16;
mos6502_handle_sbc(cpu, 8); mos6502_handle_sbc(cpu, 8);
cr_assert_eq(cpu->A, 7); cr_assert_eq(cpu->A, 7);

34
tests/mos6502.bits.c
View File

@ -31,29 +31,29 @@ Test(mos6502_bits, bit)
{ {
cpu->A = 5; cpu->A = 5;
mos6502_handle_bit(cpu, 129); mos6502_handle_bit(cpu, 129);
cr_assert_eq(cpu->P & NEGATIVE, NEGATIVE); cr_assert_eq(cpu->P & MOS_NEGATIVE, MOS_NEGATIVE);
cr_assert_eq(cpu->P & OVERFLOW, 0); cr_assert_eq(cpu->P & MOS_OVERFLOW, 0);
cr_assert_eq(cpu->P & ZERO, 0); cr_assert_eq(cpu->P & MOS_ZERO, 0);
mos6502_handle_bit(cpu, 193); mos6502_handle_bit(cpu, 193);
cr_assert_eq(cpu->P & NEGATIVE, NEGATIVE); cr_assert_eq(cpu->P & MOS_NEGATIVE, MOS_NEGATIVE);
cr_assert_eq(cpu->P & OVERFLOW, OVERFLOW); cr_assert_eq(cpu->P & MOS_OVERFLOW, MOS_OVERFLOW);
cr_assert_eq(cpu->P & ZERO, 0); cr_assert_eq(cpu->P & MOS_ZERO, 0);
mos6502_handle_bit(cpu, 65); mos6502_handle_bit(cpu, 65);
cr_assert_eq(cpu->P & NEGATIVE, 0); cr_assert_eq(cpu->P & MOS_NEGATIVE, 0);
cr_assert_eq(cpu->P & OVERFLOW, OVERFLOW); cr_assert_eq(cpu->P & MOS_OVERFLOW, MOS_OVERFLOW);
cr_assert_eq(cpu->P & ZERO, 0); cr_assert_eq(cpu->P & MOS_ZERO, 0);
mos6502_handle_bit(cpu, 33); mos6502_handle_bit(cpu, 33);
cr_assert_eq(cpu->P & NEGATIVE, 0); cr_assert_eq(cpu->P & MOS_NEGATIVE, 0);
cr_assert_eq(cpu->P & OVERFLOW, 0); cr_assert_eq(cpu->P & MOS_OVERFLOW, 0);
cr_assert_eq(cpu->P & ZERO, 0); cr_assert_eq(cpu->P & MOS_ZERO, 0);
mos6502_handle_bit(cpu, 0); mos6502_handle_bit(cpu, 0);
cr_assert_eq(cpu->P & NEGATIVE, 0); cr_assert_eq(cpu->P & MOS_NEGATIVE, 0);
cr_assert_eq(cpu->P & OVERFLOW, 0); cr_assert_eq(cpu->P & MOS_OVERFLOW, 0);
cr_assert_eq(cpu->P & ZERO, ZERO); cr_assert_eq(cpu->P & MOS_ZERO, MOS_ZERO);
} }
Test(mos6502_bits, eor) Test(mos6502_bits, eor)
@ -71,12 +71,12 @@ Test(mos6502_bits, lsr)
{ {
mos6502_handle_lsr(cpu, 5); mos6502_handle_lsr(cpu, 5);
cr_assert_eq(cpu->A, 2); cr_assert_eq(cpu->A, 2);
cr_assert_eq(cpu->P & CARRY, CARRY); cr_assert_eq(cpu->P & MOS_CARRY, MOS_CARRY);
cpu->last_addr = 123; cpu->last_addr = 123;
mos6502_handle_lsr(cpu, 22); mos6502_handle_lsr(cpu, 22);
cr_assert_eq(vm_segment_get(cpu->memory, 123), 11); cr_assert_eq(vm_segment_get(cpu->memory, 123), 11);
cr_assert_eq(cpu->P & CARRY, CARRY); cr_assert_eq(cpu->P & MOS_CARRY, MOS_CARRY);
} }
Test(mos6502_bits, ora) Test(mos6502_bits, ora)

16
tests/mos6502.branch.c
View File

@ -12,7 +12,7 @@ Test(mos6502_branch, bcc)
mos6502_handle_bcc(cpu, 0); mos6502_handle_bcc(cpu, 0);
cr_assert_eq(cpu->PC, 123); cr_assert_eq(cpu->PC, 123);
cpu->P |= CARRY; cpu->P |= MOS_CARRY;
cpu->last_addr = 125; cpu->last_addr = 125;
mos6502_handle_bcc(cpu, 0); mos6502_handle_bcc(cpu, 0);
cr_assert_neq(cpu->PC, 125); cr_assert_neq(cpu->PC, 125);
@ -24,7 +24,7 @@ Test(mos6502_branch, bcs)
mos6502_handle_bcs(cpu, 0); mos6502_handle_bcs(cpu, 0);
cr_assert_neq(cpu->PC, 123); cr_assert_neq(cpu->PC, 123);
cpu->P |= CARRY; cpu->P |= MOS_CARRY;
cpu->last_addr = 125; cpu->last_addr = 125;
mos6502_handle_bcs(cpu, 0); mos6502_handle_bcs(cpu, 0);
cr_assert_eq(cpu->PC, 125); cr_assert_eq(cpu->PC, 125);
@ -36,7 +36,7 @@ Test(mos6502_branch, beq)
mos6502_handle_beq(cpu, 0); mos6502_handle_beq(cpu, 0);
cr_assert_neq(cpu->PC, 123); cr_assert_neq(cpu->PC, 123);
cpu->P |= ZERO; cpu->P |= MOS_ZERO;
cpu->last_addr = 125; cpu->last_addr = 125;
mos6502_handle_beq(cpu, 0); mos6502_handle_beq(cpu, 0);
cr_assert_eq(cpu->PC, 125); cr_assert_eq(cpu->PC, 125);
@ -48,7 +48,7 @@ Test(mos6502_branch, bmi)
mos6502_handle_bmi(cpu, 0); mos6502_handle_bmi(cpu, 0);
cr_assert_neq(cpu->PC, 123); cr_assert_neq(cpu->PC, 123);
cpu->P |= NEGATIVE; cpu->P |= MOS_NEGATIVE;
cpu->last_addr = 125; cpu->last_addr = 125;
mos6502_handle_bmi(cpu, 0); mos6502_handle_bmi(cpu, 0);
cr_assert_eq(cpu->PC, 125); cr_assert_eq(cpu->PC, 125);
@ -60,7 +60,7 @@ Test(mos6502_branch, bne)
mos6502_handle_bne(cpu, 0); mos6502_handle_bne(cpu, 0);
cr_assert_eq(cpu->PC, 123); cr_assert_eq(cpu->PC, 123);
cpu->P |= ZERO; cpu->P |= MOS_ZERO;
cpu->last_addr = 125; cpu->last_addr = 125;
mos6502_handle_bne(cpu, 0); mos6502_handle_bne(cpu, 0);
cr_assert_neq(cpu->PC, 125); cr_assert_neq(cpu->PC, 125);
@ -72,7 +72,7 @@ Test(mos6502_branch, bpl)
mos6502_handle_bpl(cpu, 0); mos6502_handle_bpl(cpu, 0);
cr_assert_eq(cpu->PC, 123); cr_assert_eq(cpu->PC, 123);
cpu->P |= NEGATIVE; cpu->P |= MOS_NEGATIVE;
cpu->last_addr = 125; cpu->last_addr = 125;
mos6502_handle_bpl(cpu, 0); mos6502_handle_bpl(cpu, 0);
cr_assert_neq(cpu->PC, 125); cr_assert_neq(cpu->PC, 125);
@ -84,7 +84,7 @@ Test(mos6502_branch, bvc)
mos6502_handle_bvc(cpu, 0); mos6502_handle_bvc(cpu, 0);
cr_assert_eq(cpu->PC, 123); cr_assert_eq(cpu->PC, 123);
cpu->P |= OVERFLOW; cpu->P |= MOS_OVERFLOW;
cpu->last_addr = 125; cpu->last_addr = 125;
mos6502_handle_bvc(cpu, 0); mos6502_handle_bvc(cpu, 0);
cr_assert_neq(cpu->PC, 125); cr_assert_neq(cpu->PC, 125);
@ -96,7 +96,7 @@ Test(mos6502_branch, bvs)
mos6502_handle_bvs(cpu, 0); mos6502_handle_bvs(cpu, 0);
cr_assert_neq(cpu->PC, 123); cr_assert_neq(cpu->PC, 123);
cpu->P |= OVERFLOW; cpu->P |= MOS_OVERFLOW;
cpu->last_addr = 125; cpu->last_addr = 125;
mos6502_handle_bvs(cpu, 0); mos6502_handle_bvs(cpu, 0);
cr_assert_eq(cpu->PC, 125); cr_assert_eq(cpu->PC, 125);

36
tests/mos6502.c
View File

@ -47,31 +47,31 @@ Test(mos6502, pop_stack)
Test(mos6502, modify_status) Test(mos6502, modify_status)
{ {
mos6502_modify_status(cpu, NEGATIVE, 130); mos6502_modify_status(cpu, MOS_NEGATIVE, 130);
cr_assert_eq(cpu->P & NEGATIVE, NEGATIVE); cr_assert_eq(cpu->P & MOS_NEGATIVE, MOS_NEGATIVE);
mos6502_modify_status(cpu, NEGATIVE, 123); mos6502_modify_status(cpu, MOS_NEGATIVE, 123);
cr_assert_neq(cpu->P & NEGATIVE, NEGATIVE); cr_assert_neq(cpu->P & MOS_NEGATIVE, MOS_NEGATIVE);
mos6502_modify_status(cpu, OVERFLOW, 123); mos6502_modify_status(cpu, MOS_OVERFLOW, 123);
cr_assert_eq(cpu->P & OVERFLOW, OVERFLOW); cr_assert_eq(cpu->P & MOS_OVERFLOW, MOS_OVERFLOW);
mos6502_modify_status(cpu, OVERFLOW, 44); mos6502_modify_status(cpu, MOS_OVERFLOW, 44);
cr_assert_neq(cpu->P & OVERFLOW, OVERFLOW); cr_assert_neq(cpu->P & MOS_OVERFLOW, MOS_OVERFLOW);
mos6502_modify_status(cpu, CARRY, 23); mos6502_modify_status(cpu, MOS_CARRY, 23);
cr_assert_eq(cpu->P & CARRY, CARRY); cr_assert_eq(cpu->P & MOS_CARRY, MOS_CARRY);
mos6502_modify_status(cpu, CARRY, 0); mos6502_modify_status(cpu, MOS_CARRY, 0);
cr_assert_neq(cpu->P & CARRY, CARRY); cr_assert_neq(cpu->P & MOS_CARRY, MOS_CARRY);
mos6502_modify_status(cpu, ZERO, 0); mos6502_modify_status(cpu, MOS_ZERO, 0);
cr_assert_eq(cpu->P & ZERO, ZERO); cr_assert_eq(cpu->P & MOS_ZERO, MOS_ZERO);
mos6502_modify_status(cpu, ZERO, 1); mos6502_modify_status(cpu, MOS_ZERO, 1);
cr_assert_neq(cpu->P & ZERO, ZERO); cr_assert_neq(cpu->P & MOS_ZERO, MOS_ZERO);
} }
Test(mos6502, set_status) Test(mos6502, set_status)
{ {
mos6502_set_status(cpu, BREAK | INTERRUPT | DECIMAL); mos6502_set_status(cpu, MOS_BREAK | MOS_INTERRUPT | MOS_DECIMAL);
cr_assert_eq(cpu->P & (BREAK | INTERRUPT | DECIMAL), BREAK | INTERRUPT | DECIMAL); cr_assert_eq(cpu->P & (MOS_BREAK | MOS_INTERRUPT | MOS_DECIMAL), MOS_BREAK | MOS_INTERRUPT | MOS_DECIMAL);
} }
Test(mos6502, instruction) Test(mos6502, instruction)

2
tests/mos6502.exec.c
View File

@ -13,7 +13,7 @@ Test(mos6502_exec, brk)
cpu->PC = 123; cpu->PC = 123;
mos6502_handle_brk(cpu, 0); mos6502_handle_brk(cpu, 0);
cr_assert_eq(cpu->PC, 125); cr_assert_eq(cpu->PC, 125);
cr_assert_eq(cpu->P & INTERRUPT, INTERRUPT); cr_assert_eq(cpu->P & MOS_INTERRUPT, MOS_INTERRUPT);
cr_assert_eq(mos6502_pop_stack(cpu), orig_P); cr_assert_eq(mos6502_pop_stack(cpu), orig_P);
cr_assert_eq(mos6502_pop_stack(cpu), 123); cr_assert_eq(mos6502_pop_stack(cpu), 123);

22
tests/mos6502.stat.c
View File

@ -8,49 +8,49 @@ TestSuite(mos6502_stat, .init = setup, .fini = teardown);
Test(mos6502_stat, clc) Test(mos6502_stat, clc)
{ {
cpu->P = CARRY | DECIMAL; cpu->P = MOS_CARRY | MOS_DECIMAL;
mos6502_handle_clc(cpu, 0); mos6502_handle_clc(cpu, 0);
cr_assert_eq(cpu->P & CARRY, 0); cr_assert_eq(cpu->P & MOS_CARRY, 0);
} }
Test(mos6502_stat, cld) Test(mos6502_stat, cld)
{ {
cpu->P = DECIMAL | CARRY; cpu->P = MOS_DECIMAL | MOS_CARRY;
mos6502_handle_cld(cpu, 0); mos6502_handle_cld(cpu, 0);
cr_assert_eq(cpu->P & DECIMAL, 0); cr_assert_eq(cpu->P & MOS_DECIMAL, 0);
} }
Test(mos6502_stat, cli) Test(mos6502_stat, cli)
{ {
cpu->P = CARRY | INTERRUPT; cpu->P = MOS_CARRY | MOS_INTERRUPT;
mos6502_handle_cli(cpu, 0); mos6502_handle_cli(cpu, 0);
cr_assert_eq(cpu->P & INTERRUPT, 0); cr_assert_eq(cpu->P & MOS_INTERRUPT, 0);
} }
Test(mos6502_stat, clv) Test(mos6502_stat, clv)
{ {
cpu->P = CARRY | OVERFLOW; cpu->P = MOS_CARRY | MOS_OVERFLOW;
mos6502_handle_clv(cpu, 0); mos6502_handle_clv(cpu, 0);
cr_assert_eq(cpu->P & OVERFLOW, 0); cr_assert_eq(cpu->P & MOS_OVERFLOW, 0);
} }
Test(mos6502_stat, sec) Test(mos6502_stat, sec)
{ {
cpu->P = 0; cpu->P = 0;
mos6502_handle_sec(cpu, 0); mos6502_handle_sec(cpu, 0);
cr_assert_eq(cpu->P & CARRY, CARRY); cr_assert_eq(cpu->P & MOS_CARRY, MOS_CARRY);
} }
Test(mos6502_stat, sed) Test(mos6502_stat, sed)
{ {
cpu->P = 0; cpu->P = 0;
mos6502_handle_sed(cpu, 0); mos6502_handle_sed(cpu, 0);
cr_assert_eq(cpu->P & DECIMAL, DECIMAL); cr_assert_eq(cpu->P & MOS_DECIMAL, MOS_DECIMAL);
} }
Test(mos6502_stat, sei) Test(mos6502_stat, sei)
{ {
cpu->P = 0; cpu->P = 0;
mos6502_handle_sei(cpu, 0); mos6502_handle_sei(cpu, 0);
cr_assert_eq(cpu->P & INTERRUPT, INTERRUPT); cr_assert_eq(cpu->P & MOS_INTERRUPT, MOS_INTERRUPT);
} }