From 7d6886a3a8f86f1980b6cde25379372711aaf2f1 Mon Sep 17 00:00:00 2001
From: Peter Evans <pevans@activecampaign.com>
Date: Fri, 12 Jan 2018 13:57:48 -0600
Subject: [PATCH] Change last_addr field to eff_addr

---
 include/apple2.mem.h     |  1 -
 include/mos6502.h        |  2 +-
 src/mos6502.addr.c       |  4 ++--
 src/mos6502.arith.c      |  8 ++++----
 src/mos6502.bits.c       | 16 ++++++++--------
 src/mos6502.branch.c     |  2 +-
 src/mos6502.c            |  6 +++---
 src/mos6502.exec.c       |  4 ++--
 src/mos6502.loadstor.c   |  6 +++---
 tests/mos6502.addr.c     |  4 ++--
 tests/mos6502.arith.c    |  4 ++--
 tests/mos6502.bits.c     |  8 ++++----
 tests/mos6502.branch.c   | 32 ++++++++++++++++----------------
 tests/mos6502.c          |  2 +-
 tests/mos6502.exec.c     |  4 ++--
 tests/mos6502.loadstor.c | 12 ++++++------
 16 files changed, 57 insertions(+), 58 deletions(-)

diff --git a/include/apple2.mem.h b/include/apple2.mem.h
index 7722421..7a80015 100644
--- a/include/apple2.mem.h
+++ b/include/apple2.mem.h
@@ -56,7 +56,6 @@
  */
 #define APPLE2_BANK_OFFSET 0xD000
 
-
 extern SEGMENT_READER(apple2_mem_read_bank);
 extern SEGMENT_WRITER(apple2_mem_write_bank);
 extern int apple2_mem_init_peripheral_rom(apple2 *);
diff --git a/include/mos6502.h b/include/mos6502.h
index 17eaeef..18918fa 100644
--- a/include/mos6502.h
+++ b/include/mos6502.h
@@ -68,7 +68,7 @@ typedef struct {
      * memory. Another way of thinking of this is, this address is where
      * we found the value we care about.
      */
-    vm_16bit last_addr;
+    vm_16bit eff_addr;
 
     /*
      * Our program counter register; this is what we'll use to determine
diff --git a/src/mos6502.addr.c b/src/mos6502.addr.c
index eeb369e..bf59931 100644
--- a/src/mos6502.addr.c
+++ b/src/mos6502.addr.c
@@ -58,11 +58,11 @@ static int addr_modes[] = {
 
 /*
  * This will both define the `eff_addr` variable (which is the effective
- * address) and assign that value to the `last_addr` field of the cpu.
+ * address) and assign that value to the `eff_addr` field of the cpu.
  */
 #define EFF_ADDR(addr) \
     vm_16bit eff_addr = addr; \
-    cpu->last_addr = eff_addr
+    cpu->eff_addr = eff_addr
 
 /*
  * A tiny convenience macro to help us define address resolver
diff --git a/src/mos6502.arith.c b/src/mos6502.arith.c
index de23207..da12a65 100644
--- a/src/mos6502.arith.c
+++ b/src/mos6502.arith.c
@@ -59,8 +59,8 @@ DEFINE_INST(cpy)
  */
 DEFINE_INST(dec) 
 {
-    if (cpu->last_addr) {
-        mos6502_set(cpu, cpu->last_addr, oper - 1);
+    if (cpu->eff_addr) {
+        mos6502_set(cpu, cpu->eff_addr, oper - 1);
         mos6502_modify_status(cpu, MOS_NEGATIVE | MOS_ZERO, oper - 1);
     }
 }
@@ -90,8 +90,8 @@ DEFINE_INST(dey)
  */
 DEFINE_INST(inc)
 {
-    if (cpu->last_addr) {
-        mos6502_set(cpu, cpu->last_addr, oper + 1);
+    if (cpu->eff_addr) {
+        mos6502_set(cpu, cpu->eff_addr, oper + 1);
         mos6502_modify_status(cpu, MOS_NEGATIVE | MOS_ZERO, oper + 1);
     }
 }
diff --git a/src/mos6502.bits.c b/src/mos6502.bits.c
index b60e788..d0f29d7 100644
--- a/src/mos6502.bits.c
+++ b/src/mos6502.bits.c
@@ -38,8 +38,8 @@ DEFINE_INST(asl)
 
     oper <<= 1;
 
-    if (cpu->last_addr) {
-        mos6502_set(cpu, cpu->last_addr, oper);
+    if (cpu->eff_addr) {
+        mos6502_set(cpu, cpu->eff_addr, oper);
     } else {
         cpu->A = oper;
     }
@@ -97,8 +97,8 @@ DEFINE_INST(lsr)
 
     oper >>= 1;
 
-    if (cpu->last_addr) {
-        mos6502_set(cpu, cpu->last_addr, oper);
+    if (cpu->eff_addr) {
+        mos6502_set(cpu, cpu->eff_addr, oper);
     } else {
         cpu->A = oper;
     }
@@ -136,8 +136,8 @@ DEFINE_INST(rol)
         oper |= 0x01;
     }
 
-    if (cpu->last_addr) {
-        mos6502_set(cpu, cpu->last_addr, oper);
+    if (cpu->eff_addr) {
+        mos6502_set(cpu, cpu->eff_addr, oper);
     } else {
         cpu->A = oper;
     }
@@ -163,8 +163,8 @@ DEFINE_INST(ror)
         oper |= 0x80;
     }
 
-    if (cpu->last_addr) {
-        mos6502_set(cpu, cpu->last_addr, oper);
+    if (cpu->eff_addr) {
+        mos6502_set(cpu, cpu->eff_addr, oper);
     } else {
         cpu->A = oper;
     }
diff --git a/src/mos6502.branch.c b/src/mos6502.branch.c
index 5e59aa4..59e6e1f 100644
--- a/src/mos6502.branch.c
+++ b/src/mos6502.branch.c
@@ -14,7 +14,7 @@
  * program counter to the last effective address.
  */
 #define JUMP_IF(cond) \
-    if (cond) cpu->PC = cpu->last_addr; else cpu->PC += 2
+    if (cond) cpu->PC = cpu->eff_addr; else cpu->PC += 2
 
 /*
  * Branch if the carry flag is clear.
diff --git a/src/mos6502.c b/src/mos6502.c
index dd6903f..d03d00c 100644
--- a/src/mos6502.c
+++ b/src/mos6502.c
@@ -157,7 +157,7 @@ mos6502_create(vm_segment *rmem, vm_segment *wmem)
 
     mos6502_set_memory(cpu, rmem, wmem);
 
-    cpu->last_addr = 0;
+    cpu->eff_addr = 0;
     cpu->PC = 0;
     cpu->A = 0;
     cpu->X = 0;
@@ -293,7 +293,7 @@ mos6502_cycles(mos6502 *cpu, vm_8bit opcode)
     addr_mode = mos6502_addr_mode(opcode);
 
     // Mainly we care about the lo byte of the last effective address
-    lo_addr = cpu->last_addr & 0xFF;
+    lo_addr = cpu->eff_addr & 0xFF;
 
     // Ok, here's the deal: if you are using an address mode that uses
     // any of the index registers, you need to return an additional
@@ -359,7 +359,7 @@ mos6502_execute(mos6502 *cpu)
     // instruction handler cares about (if it cares about any such
     // value). For example, the operand could be the literal value that
     // you pass into an instruction via immediate mode. As a
-    // side-effect, resolver will set the last_addr field in cpu to the
+    // side-effect, resolver will set the eff_addr field in cpu to the
     // effective address where the operand can be found in memory, or
     // zero if that does not apply (such as in immediate mode).
     //
diff --git a/src/mos6502.exec.c b/src/mos6502.exec.c
index 637ce6c..545542a 100644
--- a/src/mos6502.exec.c
+++ b/src/mos6502.exec.c
@@ -26,7 +26,7 @@ DEFINE_INST(brk)
  */
 DEFINE_INST(jmp)
 {
-    cpu->PC = cpu->last_addr;
+    cpu->PC = cpu->eff_addr;
 }
 
 /*
@@ -37,7 +37,7 @@ DEFINE_INST(jmp)
 DEFINE_INST(jsr)
 {
     mos6502_push_stack(cpu, cpu->PC + 3);
-    cpu->PC = cpu->last_addr;
+    cpu->PC = cpu->eff_addr;
 }
 
 /*
diff --git a/src/mos6502.loadstor.c b/src/mos6502.loadstor.c
index 7aab89d..248fb59 100644
--- a/src/mos6502.loadstor.c
+++ b/src/mos6502.loadstor.c
@@ -75,7 +75,7 @@ DEFINE_INST(plp)
  */
 DEFINE_INST(sta)
 {
-    mos6502_set(cpu, cpu->last_addr, cpu->A);
+    mos6502_set(cpu, cpu->eff_addr, cpu->A);
 }
 
 /*
@@ -83,7 +83,7 @@ DEFINE_INST(sta)
  */
 DEFINE_INST(stx)
 {
-    mos6502_set(cpu, cpu->last_addr, cpu->X);
+    mos6502_set(cpu, cpu->eff_addr, cpu->X);
 }
 
 /*
@@ -91,7 +91,7 @@ DEFINE_INST(stx)
  */
 DEFINE_INST(sty)
 {
-    mos6502_set(cpu, cpu->last_addr, cpu->Y);
+    mos6502_set(cpu, cpu->eff_addr, cpu->Y);
 }
 
 /*
diff --git a/tests/mos6502.addr.c b/tests/mos6502.addr.c
index 8f84b7c..855f6ac 100644
--- a/tests/mos6502.addr.c
+++ b/tests/mos6502.addr.c
@@ -107,7 +107,7 @@ Test(mos6502_addr, addr_mode_rel_positive)
     cpu->PC = 123;
     SET_PC_BYTE(cpu, 1, 88);
     cr_assert_eq(mos6502_resolve_rel(cpu), 0);
-    cr_assert_eq(cpu->last_addr, 213);
+    cr_assert_eq(cpu->eff_addr, 213);
 }
 
 Test(mos6502_addr, addr_mode_rel_negative)
@@ -115,7 +115,7 @@ Test(mos6502_addr, addr_mode_rel_negative)
     cpu->PC = 123;
     SET_PC_BYTE(cpu, 1, 216);
     cr_assert_eq(mos6502_resolve_rel(cpu), 0);
-    cr_assert_eq(cpu->last_addr, 85);
+    cr_assert_eq(cpu->eff_addr, 85);
 }
 
 Test(mos6502_addr, addr_mode_zpg)
diff --git a/tests/mos6502.arith.c b/tests/mos6502.arith.c
index 1f13e68..d7a6228 100644
--- a/tests/mos6502.arith.c
+++ b/tests/mos6502.arith.c
@@ -64,7 +64,7 @@ Test(mos6502_arith, dec)
     mos6502_handle_dec(cpu, 0);
     cr_assert_neq(cpu->A, 4);
 
-    cpu->last_addr = 123;
+    cpu->eff_addr = 123;
     mos6502_set(cpu, 123, 44);
 
     // Note _also_ that DEC expects the number to be decremented will be
@@ -90,7 +90,7 @@ Test(mos6502_arith, dey)
 
 Test(mos6502_arith, inc)
 {
-    cpu->last_addr = 123;
+    cpu->eff_addr = 123;
     mos6502_handle_inc(cpu, 55);
     cr_assert_eq(mos6502_get(cpu, 123), 56);
 }
diff --git a/tests/mos6502.bits.c b/tests/mos6502.bits.c
index 1a883e9..81d9b04 100644
--- a/tests/mos6502.bits.c
+++ b/tests/mos6502.bits.c
@@ -22,7 +22,7 @@ Test(mos6502_bits, asl)
     mos6502_handle_asl(cpu, 5);
     cr_assert_eq(cpu->A, 10);
 
-    cpu->last_addr = 123;
+    cpu->eff_addr = 123;
     mos6502_handle_asl(cpu, 22);
     cr_assert_eq(mos6502_get(cpu, 123), 44);
 }
@@ -73,7 +73,7 @@ Test(mos6502_bits, lsr)
     cr_assert_eq(cpu->A, 2);
     cr_assert_eq(cpu->P & MOS_CARRY, MOS_CARRY);
 
-    cpu->last_addr = 123;
+    cpu->eff_addr = 123;
     mos6502_handle_lsr(cpu, 22);
     cr_assert_eq(mos6502_get(cpu, 123), 11);
     cr_assert_eq(cpu->P & MOS_CARRY, MOS_CARRY);
@@ -95,7 +95,7 @@ Test(mos6502_bits, rol)
     mos6502_handle_rol(cpu, 8);
     cr_assert_eq(cpu->A, 16);
 
-    cpu->last_addr = 234;
+    cpu->eff_addr = 234;
     mos6502_handle_rol(cpu, 128);
     cr_assert_eq(mos6502_get(cpu, 234), 1);
 }
@@ -105,7 +105,7 @@ Test(mos6502_bits, ror)
     mos6502_handle_ror(cpu, 64);
     cr_assert_eq(cpu->A, 32);
 
-    cpu->last_addr = 123;
+    cpu->eff_addr = 123;
     mos6502_handle_ror(cpu, 1);
     cr_assert_eq(mos6502_get(cpu, 123), 128);
 }
diff --git a/tests/mos6502.branch.c b/tests/mos6502.branch.c
index 76009cc..62dd955 100644
--- a/tests/mos6502.branch.c
+++ b/tests/mos6502.branch.c
@@ -8,96 +8,96 @@ TestSuite(mos6502_branch, .init = setup, .fini = teardown);
 
 Test(mos6502_branch, bcc)
 {
-    cpu->last_addr = 123;
+    cpu->eff_addr = 123;
     mos6502_handle_bcc(cpu, 0);
     cr_assert_eq(cpu->PC, 123);
 
     cpu->P |= MOS_CARRY;
-    cpu->last_addr = 125;
+    cpu->eff_addr = 125;
     mos6502_handle_bcc(cpu, 0);
     cr_assert_neq(cpu->PC, 127);
 }
 
 Test(mos6502_branch, bcs)
 {
-    cpu->last_addr = 123;
+    cpu->eff_addr = 123;
     mos6502_handle_bcs(cpu, 0);
     cr_assert_neq(cpu->PC, 123);
 
     cpu->P |= MOS_CARRY;
-    cpu->last_addr = 125;
+    cpu->eff_addr = 125;
     mos6502_handle_bcs(cpu, 0);
     cr_assert_eq(cpu->PC, 125);
 }
 
 Test(mos6502_branch, beq)
 {
-    cpu->last_addr = 123;
+    cpu->eff_addr = 123;
     mos6502_handle_beq(cpu, 0);
     cr_assert_neq(cpu->PC, 123);
 
     cpu->P |= MOS_ZERO;
-    cpu->last_addr = 125;
+    cpu->eff_addr = 125;
     mos6502_handle_beq(cpu, 0);
     cr_assert_eq(cpu->PC, 125);
 }
 
 Test(mos6502_branch, bmi)
 {
-    cpu->last_addr = 123;
+    cpu->eff_addr = 123;
     mos6502_handle_bmi(cpu, 0);
     cr_assert_neq(cpu->PC, 123);
 
     cpu->P |= MOS_NEGATIVE;
-    cpu->last_addr = 125;
+    cpu->eff_addr = 125;
     mos6502_handle_bmi(cpu, 0);
     cr_assert_eq(cpu->PC, 125);
 }
 
 Test(mos6502_branch, bne)
 {
-    cpu->last_addr = 123;
+    cpu->eff_addr = 123;
     mos6502_handle_bne(cpu, 0);
     cr_assert_eq(cpu->PC, 123);
 
     cpu->P |= MOS_ZERO;
-    cpu->last_addr = 125;
+    cpu->eff_addr = 125;
     mos6502_handle_bne(cpu, 0);
     cr_assert_neq(cpu->PC, 127);
 }
 
 Test(mos6502_branch, bpl)
 {
-    cpu->last_addr = 123;
+    cpu->eff_addr = 123;
     mos6502_handle_bpl(cpu, 0);
     cr_assert_eq(cpu->PC, 123);
 
     cpu->P |= MOS_NEGATIVE;
-    cpu->last_addr = 125;
+    cpu->eff_addr = 125;
     mos6502_handle_bpl(cpu, 0);
     cr_assert_neq(cpu->PC, 127);
 }
 
 Test(mos6502_branch, bvc)
 {
-    cpu->last_addr = 123;
+    cpu->eff_addr = 123;
     mos6502_handle_bvc(cpu, 0);
     cr_assert_eq(cpu->PC, 123);
 
     cpu->P |= MOS_OVERFLOW;
-    cpu->last_addr = 125;
+    cpu->eff_addr = 125;
     mos6502_handle_bvc(cpu, 0);
     cr_assert_neq(cpu->PC, 127);
 }
 
 Test(mos6502_branch, bvs)
 {
-    cpu->last_addr = 123;
+    cpu->eff_addr = 123;
     mos6502_handle_bvs(cpu, 0);
     cr_assert_neq(cpu->PC, 123);
 
     cpu->P |= MOS_OVERFLOW;
-    cpu->last_addr = 125;
+    cpu->eff_addr = 125;
     mos6502_handle_bvs(cpu, 0);
     cr_assert_eq(cpu->PC, 125);
 }
diff --git a/tests/mos6502.c b/tests/mos6502.c
index c89d4dd..3c7e19c 100644
--- a/tests/mos6502.c
+++ b/tests/mos6502.c
@@ -79,7 +79,7 @@ Test(mos6502, cycles)
 
     // In this case, we aren't cross a page boundary, and the number of
     // cycles should stay at 4
-    cpu->last_addr = 0x5070;
+    cpu->eff_addr = 0x5070;
     cpu->X = 23;
     cr_assert_eq(mos6502_cycles(cpu, 0x1D), 4);
 
diff --git a/tests/mos6502.exec.c b/tests/mos6502.exec.c
index 88aa23d..bd3bb86 100644
--- a/tests/mos6502.exec.c
+++ b/tests/mos6502.exec.c
@@ -22,7 +22,7 @@ Test(mos6502_exec, brk)
 Test(mos6502_exec, jmp)
 {
     cpu->PC = 123;
-    cpu->last_addr = 234;
+    cpu->eff_addr = 234;
     mos6502_handle_jmp(cpu, 0);
 
     cr_assert_eq(cpu->PC, 234);
@@ -31,7 +31,7 @@ Test(mos6502_exec, jmp)
 Test(mos6502_exec, jsr)
 {
     cpu->PC = 123;
-    cpu->last_addr = 235;
+    cpu->eff_addr = 235;
     mos6502_handle_jsr(cpu, 0);
 
     cr_assert_eq(cpu->PC, 235);
diff --git a/tests/mos6502.loadstor.c b/tests/mos6502.loadstor.c
index 9dca110..f664f0e 100644
--- a/tests/mos6502.loadstor.c
+++ b/tests/mos6502.loadstor.c
@@ -61,25 +61,25 @@ Test(mos6502_loadstor, plp)
 Test(mos6502_loadstor, sta)
 {
     cpu->A = 123;
-    cpu->last_addr = 555;
+    cpu->eff_addr = 555;
     mos6502_handle_sta(cpu, 0);
-    cr_assert_eq(mos6502_get(cpu, cpu->last_addr), cpu->A);
+    cr_assert_eq(mos6502_get(cpu, cpu->eff_addr), cpu->A);
 }
 
 Test(mos6502_loadstor, stx)
 {
     cpu->X = 222;
-    cpu->last_addr = 444;
+    cpu->eff_addr = 444;
     mos6502_handle_stx(cpu, 0);
-    cr_assert_eq(mos6502_get(cpu, cpu->last_addr), cpu->X);
+    cr_assert_eq(mos6502_get(cpu, cpu->eff_addr), cpu->X);
 }
 
 Test(mos6502_loadstor, sty)
 {
     cpu->Y = 111;
-    cpu->last_addr = 253;
+    cpu->eff_addr = 253;
     mos6502_handle_sty(cpu, 0);
-    cr_assert_eq(mos6502_get(cpu, cpu->last_addr), cpu->Y);
+    cr_assert_eq(mos6502_get(cpu, cpu->eff_addr), cpu->Y);
 }
 
 Test(mos6502_loadstor, tax)