Dachte, ich würde weitermachen und meine eigene Implementierung posten. Es ist VOLLSTÄNDIG ungolfed, aber es ist eine vollständige Implementierung.
- 668 Zeilen C. (ohne Leerzeilen oder Zeilen mit nur Kommentaren)
- Unterstützt (glaube ich) alle undokumentierten Anweisungen.
- Unterstützt BCD.
- Taktung der CPU. (einschließlich Anpassungen bei bestimmten Seitenumbrüchen)
- Kann Anweisungen entweder in einem Schritt oder durch Angabe der Anzahl der Teilstriche ausführen.
- Unterstützt das Verknüpfen einer externen Funktion, die aufgerufen wird, nachdem jede Anweisung ausgeführt wurde. Das lag daran, dass es ursprünglich für einen NES-Emulator war und ich dies für das Audio-Timing verwendete.
/ * Fake6502 CPU Emulator Core v1.1 ********************
* (c) 2011-2013 Mike Chambers *
*************************************************** *** /
#include <stdio.h>
#include <stdint.h>
// extern bereitgestellte Funktionen
extern uint8_t read6502 (uint16_t address);
extern void write6502 (uint16_t address, uint8_t value);
// 6502 definiert
#define UNDOCUMENTED // Wenn dies definiert ist, werden undokumentierte Opcodes behandelt.
// ansonsten werden sie einfach als NOPs behandelt.
// # definiere NES_CPU // wenn dies definiert ist, die binär codierte Dezimalzahl (BCD)
// Statusflag wird von ADC und SBC nicht beachtet. die 2A03
// CPU im Nintendo Entertainment System nicht
// BCD-Betrieb unterstützen.
#define FLAG_CARRY 0x01
#define FLAG_ZERO 0x02
#define FLAG_INTERRUPT 0x04
#define FLAG_DECIMAL 0x08
#define FLAG_BREAK 0x10
#define FLAG_CONSTANT 0x20
#define FLAG_OVERFLOW 0x40
#define FLAG_SIGN 0x80
#define BASE_STACK 0x100
#define saveaccum (n) a = (uint8_t) ((n) & 0x00FF)
// Flag-Modifikator-Makros
#define setcarry () status | = FLAG_CARRY
#define clearcarry () status & = (~ FLAG_CARRY)
#define setzero () status | = FLAG_ZERO
#define clearzero () status & = (~ FLAG_ZERO)
#define setinterrupt () status | = FLAG_INTERRUPT
#define clearinterrupt () status & = (~ FLAG_INTERRUPT)
#define setdecimal () status | = FLAG_DECIMAL
#define cleardecimal () status & = (~ FLAG_DECIMAL)
#define setoverflow () status | = FLAG_OVERFLOW
#define clearoverflow () status & = (~ FLAG_OVERFLOW)
#define setsign () status | = FLAG_SIGN
#define clearsign () status & = (~ FLAG_SIGN)
// Berechnungsmakros markieren
#define zerocalc (n) {\
if ((n) & 0x00FF) clearzero (); \
sonst setzero (); \
}
#define signcalc (n) {\
if ((n) & 0x0080) setsign (); \
sonst clearsign (); \
}
#define carrycalc (n) {\
if ((n) & 0xFF00) setcarry (); \
sonst clearcarry (); \
}
#define overflowcalc (n, m, o) {/ * n = Ergebnis, m = Akkumulator, o = Speicher * / \
if (((n) ^ (uint16_t) (m)) & ((n) ^ (o)) & 0x0080) setoverflow (); \
sonst clearoverflow (); \
}
// 6502 CPU-Register
uint16_t pc;
uint8_t sp, a, x, y, status = FLAG_CONSTANT;
// Hilfsvariablen
uint64_t Anweisungen = 0; // Verfolge alle ausgeführten Anweisungen
uint32_t clockticks6502 = 0, clockgoal6502 = 0;
uint16_t oldpc, ea, reladdr, value, result;
uint8_t opcode, oldstatus;
// Einige allgemeine Funktionen, die von verschiedenen anderen Funktionen verwendet werden
void push16 (uint16_t pushval) {
write6502 (BASE_STACK + sp, (pushval >> 8) & 0xFF);
write6502 (BASE_STACK + ((sp - 1) & 0xFF), pushval & 0xFF);
sp - = 2;
}
void push8 (uint8_t pushval) {
write6502 (BASE_STACK + sp--, pushval);
}
uint16_t pull16 () {
uint16_t temp16;
temp16 = read6502 (BASE_STACK + ((sp + 1) & 0xFF)) | ((uint16_t) read6502 (BASE_STACK + ((sp + 2) & 0xFF)) << 8);
sp + = 2;
return (temp16);
}
uint8_t pull8 () {
return (read6502 (BASE_STACK + ++ sp));
}
nichtig reset6502 () {
pc = (uint16_t) read6502 (0xFFFC) | ((uint16_t) read6502 (0xFFFD) << 8);
a = 0;
x = 0;
y = 0;
sp = 0xFD;
status | = FLAG_CONSTANT;
}
statische Lücke (* addrtable [256]) ();
statische Lücke (* optable [256]) ();
uint8_t Penaltyop, Penaltyaddr;
// Adressierungsmodus Funktionen, berechnet effektive Adressen
statische Leere imp () {// impliziert
}
statische Leere acc () {// Akku
}
statisch void imm () {// sofort
ea = pc ++;
}
statische Leere zp () {// Zero-Page
ea = (uint16_t) read6502 ((uint16_t) pc ++);
}
statische Leere zpx () {// Zero-Page, X
ea = ((uint16_t) read6502 ((uint16_t) pc ++) + (uint16_t) x) & 0xFF; // Zero-Page-Wraparound
}
statische Leere zpy () {// Nullseite, Y
ea = ((uint16_t) read6502 ((uint16_t) pc ++) + (uint16_t) y) & 0xFF; // Zero-Page-Wraparound
}
statisch void rel () {// relativ für Verzweigungsoperationen (8-Bit-Sofortwert, vorzeichenerweitert)
reladdr = (uint16_t) read6502 (pc ++);
if (reladdr & 0x80) reladdr | = 0xFF00;
}
statische Lücke abso () {// absolut
ea = (uint16_t) read6502 (pc) | ((uint16_t) read6502 (pc + 1) << 8);
pc + = 2;
}
statische Lücke absx () {// absolut, X
uint16_t startpage;
ea = ((uint16_t) read6502 (pc) | ((uint16_t) read6502 (pc + 1) << 8));
startpage = ea & 0xFF00;
ea + = (uint16_t) x;
if (startpage! = (ea & 0xFF00)) {// ein Zyklus für das Überqueren von Seiten bei einigen Opcodes
Penaltyaddr = 1;
}
pc + = 2;
}
statische Lücke absy () {// absolut, Y
uint16_t startpage;
ea = ((uint16_t) read6502 (pc) | ((uint16_t) read6502 (pc + 1) << 8));
startpage = ea & 0xFF00;
ea + = (uint16_t) y;
if (startpage! = (ea & 0xFF00)) {// ein Zyklus für das Überqueren von Seiten bei einigen Opcodes
Penaltyaddr = 1;
}
pc + = 2;
}
statische Leere ind () {// indirekt
uint16_t eahelp, eahelp2;
eahelp = (uint16_t) read6502 (pc) | (uint16_t) ((uint16_t) read6502 (pc + 1) << 8);
eahelp2 = (eahelp & 0xFF00) | ((eahelp + 1) & 0x00FF); // 6502 Seitengrenzen-Umlauffehler replizieren
ea = (uint16_t) read6502 (eahelp) | ((uint16_t) read6502 (eahelp2) << 8);
pc + = 2;
}
statische Lücke indx () {// (indirekt, X)
uint16_t eahelp;
eahelp = (uint16_t) (((uint16_t) read6502 (pc ++) + (uint16_t) x) & 0xFF); // Nullseitenumlauf für Tabellenzeiger
ea = (uint16_t) read6502 (eahelp & 0x00FF) | ((uint16_t) read6502 ((eahelp + 1) & 0x00FF) << 8);
}
statische Lücke indy () {// (indirekt), Y
uint16_t eahelp, eahelp2, startpage;
eahelp = (uint16_t) read6502 (pc ++);
eahelp2 = (eahelp & 0xFF00) | ((eahelp + 1) & 0x00FF); // Zero-Page-Wraparound
ea = (uint16_t) read6502 (eahelp) | ((uint16_t) read6502 (eahelp2) << 8);
startpage = ea & 0xFF00;
ea + = (uint16_t) y;
if (startpage! = (ea & 0xFF00)) {// ein Zyklus für das Überqueren von Seiten bei einigen Opcodes
Penaltyaddr = 1;
}
}
static uint16_t getvalue () {
if (addrtable [opcode] == acc) return ((uint16_t) a);
sonst return ((uint16_t) read6502 (ea));
}
statischer ungültiger Wert (uint16_t saveval) {
if (addrtable [opcode] == acc) a = (uint8_t) (saveval & 0x00FF);
sonst write6502 (ea, (saveval & 0x00FF));
}
// befehlshandler funktionen
statischer Void adc () {
Penaltyop = 1;
value = getvalue ();
Ergebnis = (uint16_t) a + Wert + (uint16_t) (Status & FLAG_CARRY);
carrycalc (Ergebnis);
zerocalc (Ergebnis);
overflowcalc (Ergebnis, a, Wert);
signcalc (Ergebnis);
#ifndef NES_CPU
if (status & FLAG_DECIMAL) {
clearcarry ();
if ((a & 0x0F)> 0x09) {
a + = 0x06;
}
if ((a & 0xF0)> 0x90) {
a + = 0x60;
setcarry ();
}
clockticks6502 ++;
}
#endif
saveaccum (Ergebnis);
}
statische Lücke und () {
Penaltyop = 1;
value = getvalue ();
result = (uint16_t) a & value;
zerocalc (Ergebnis);
signcalc (Ergebnis);
saveaccum (Ergebnis);
}
statische Leere asl () {
value = getvalue ();
Ergebnis = Wert << 1;
carrycalc (Ergebnis);
zerocalc (Ergebnis);
signcalc (Ergebnis);
putvalue (Ergebnis);
}
statische Leere bcc () {
if ((status & FLAG_CARRY) == 0) {
oldpc = pc;
pc + = reladdr;
if ((oldpc & 0xFF00)! = (pc & 0xFF00)) clockticks6502 + = 2; // überprüfe, ob der Sprung eine Seitengrenze überschritten hat
sonst clockticks6502 ++;
}
}
statische void bcs () {
if ((status & FLAG_CARRY) == FLAG_CARRY) {
oldpc = pc;
pc + = reladdr;
if ((oldpc & 0xFF00)! = (pc & 0xFF00)) clockticks6502 + = 2; // überprüfe, ob der Sprung eine Seitengrenze überschritten hat
sonst clockticks6502 ++;
}
}
statische Leere beq () {
if ((status & FLAG_ZERO) == FLAG_ZERO) {
oldpc = pc;
pc + = reladdr;
if ((oldpc & 0xFF00)! = (pc & 0xFF00)) clockticks6502 + = 2; // überprüfe, ob der Sprung eine Seitengrenze überschritten hat
sonst clockticks6502 ++;
}
}
statisches Void-Bit () {
value = getvalue ();
result = (uint16_t) a & value;
zerocalc (Ergebnis);
status = (status & 0x3F) | (uint8_t) (Wert & 0xC0);
}
statische Leere bmi () {
if ((status & FLAG_SIGN) == FLAG_SIGN) {
oldpc = pc;
pc + = reladdr;
if ((oldpc & 0xFF00)! = (pc & 0xFF00)) clockticks6502 + = 2; // überprüfe, ob der Sprung eine Seitengrenze überschritten hat
sonst clockticks6502 ++;
}
}
statische Leere bne () {
if ((status & FLAG_ZERO) == 0) {
oldpc = pc;
pc + = reladdr;
if ((oldpc & 0xFF00)! = (pc & 0xFF00)) clockticks6502 + = 2; // überprüfe, ob der Sprung eine Seitengrenze überschritten hat
sonst clockticks6502 ++;
}
}
statische Leere bpl () {
if ((status & FLAG_SIGN) == 0) {
oldpc = pc;
pc + = reladdr;
if ((oldpc & 0xFF00)! = (pc & 0xFF00)) clockticks6502 + = 2; // überprüfe, ob der Sprung eine Seitengrenze überschritten hat
sonst clockticks6502 ++;
}
}
statische Lücke brk () {
pc ++;
push16 (pc); // nächste Anweisungsadresse auf den Stack schieben
push8 (status | FLAG_BREAK); // CPU Status zum Stapeln verschieben
setinterrupt (); // Interrupt Flag setzen
pc = (uint16_t) read6502 (0xFFFE) | ((uint16_t) read6502 (0xFFFF) << 8);
}
statische Leere bvc () {
if ((status & FLAG_OVERFLOW) == 0) {
oldpc = pc;
pc + = reladdr;
if ((oldpc & 0xFF00)! = (pc & 0xFF00)) clockticks6502 + = 2; // überprüfe, ob der Sprung eine Seitengrenze überschritten hat
sonst clockticks6502 ++;
}
}
statische void bvs () {
if ((status & FLAG_OVERFLOW) == FLAG_OVERFLOW) {
oldpc = pc;
pc + = reladdr;
if ((oldpc & 0xFF00)! = (pc & 0xFF00)) clockticks6502 + = 2; // überprüfe, ob der Sprung eine Seitengrenze überschritten hat
sonst clockticks6502 ++;
}
}
statische Lücke clc () {
clearcarry ();
}
statische Lücke cld () {
cleardecimal ();
}
statische Lücke cli () {
clearinterrupt ();
}
statische Lücke clv () {
Clearoverflow ();
}
statische Lücke cmp () {
Penaltyop = 1;
value = getvalue ();
Ergebnis = (uint16_t) a - Wert;
if (a> = (uint8_t) (Wert & 0x00FF)) setcarry ();
sonst clearcarry ();
if (a == (uint8_t) (Wert & 0x00FF)) setzero ();
sonst clearzero ();
signcalc (Ergebnis);
}
statisches void cpx () {
value = getvalue ();
Ergebnis = (uint16_t) x - Wert;
if (x> = (uint8_t) (Wert & 0x00FF)) setcarry ();
sonst clearcarry ();
if (x == (uint8_t) (Wert & 0x00FF)) setzero ();
sonst clearzero ();
signcalc (Ergebnis);
}
statische void cpy () {
value = getvalue ();
Ergebnis = (uint16_t) y - Wert;
if (y> = (uint8_t) (Wert & 0x00FF)) setcarry ();
sonst clearcarry ();
if (y == (uint8_t) (Wert & 0x00FF)) setzero ();
sonst clearzero ();
signcalc (Ergebnis);
}
statische Lücke dec () {
value = getvalue ();
Ergebnis = Wert - 1;
zerocalc (Ergebnis);
signcalc (Ergebnis);
putvalue (Ergebnis);
}
statische Leere dex () {
x--;
zerocalc (x);
signcalc (x);
}
statische Leere dey () {
y--;
nullocalc (y);
signcalc (y);
}
statische Lücke eor () {
Penaltyop = 1;
value = getvalue ();
Ergebnis = (uint16_t) ein ^ Wert;
zerocalc (Ergebnis);
signcalc (Ergebnis);
saveaccum (Ergebnis);
}
static void inc () {
value = getvalue ();
Ergebnis = Wert + 1;
zerocalc (Ergebnis);
signcalc (Ergebnis);
putvalue (Ergebnis);
}
statische Lücke inx () {
x ++;
zerocalc (x);
signcalc (x);
}
statische Lücke iny () {
y ++;
nullocalc (y);
signcalc (y);
}
statische Leere jmp () {
pc = ea;
}
statische Leere jsr () {
push16 (pc - 1);
pc = ea;
}
statische Lücke lda () {
Penaltyop = 1;
value = getvalue ();
a = (uint8_t) (Wert & 0x00FF);
nullocalc (a);
signcalc (a);
}
statische void ldx () {
Penaltyop = 1;
value = getvalue ();
x = (uint8_t) (Wert & 0x00FF);
zerocalc (x);
signcalc (x);
}
statische Leere ldy () {
Penaltyop = 1;
value = getvalue ();
y = (uint8_t) (Wert & 0x00FF);
nullocalc (y);
signcalc (y);
}
statische Leere lsr () {
value = getvalue ();
Ergebnis = Wert >> 1;
if (Wert & 1) setcarry ();
sonst clearcarry ();
zerocalc (Ergebnis);
signcalc (Ergebnis);
putvalue (Ergebnis);
}
statische Lücke nop () {
Schalter (Opcode) {
case 0x1C:
case 0x3C:
case 0x5C:
case 0x7C:
case 0xDC:
case 0xFC:
Penaltyop = 1;
brechen;
}
}
statische Leere ora () {
Penaltyop = 1;
value = getvalue ();
Ergebnis = (uint16_t) a | Wert;
zerocalc (Ergebnis);
signcalc (Ergebnis);
saveaccum (Ergebnis);
}
statische Lücke pha () {
push8 (a);
}
statische void php () {
push8 (status | FLAG_BREAK);
}
statische Lücke pla () {
a = pull8 ();
nullocalc (a);
signcalc (a);
}
statische Lücke plp () {
status = pull8 () | FLAG_CONSTANT;
}
statische leere Rolle () {
value = getvalue ();
Ergebnis = (Wert << 1) | (status & FLAG_CARRY);
carrycalc (Ergebnis);
zerocalc (Ergebnis);
signcalc (Ergebnis);
putvalue (Ergebnis);
}
statische Lücke ror () {
value = getvalue ();
Ergebnis = (Wert >> 1) | ((status & FLAG_CARRY) << 7);
if (Wert & 1) setcarry ();
sonst clearcarry ();
zerocalc (Ergebnis);
signcalc (Ergebnis);
putvalue (Ergebnis);
}
statische Lücke rti () {
status = pull8 ();
value = pull16 ();
pc = Wert;
}
statische leere rts () {
value = pull16 ();
pc = Wert + 1;
}
statische Leere sbc () {
Penaltyop = 1;
value = getvalue () ^ 0x00FF;
Ergebnis = (uint16_t) a + Wert + (uint16_t) (Status & FLAG_CARRY);
carrycalc (Ergebnis);
zerocalc (Ergebnis);
overflowcalc (Ergebnis, a, Wert);
signcalc (Ergebnis);
#ifndef NES_CPU
if (status & FLAG_DECIMAL) {
clearcarry ();
a - = 0x66;
if ((a & 0x0F)> 0x09) {
a + = 0x06;
}
if ((a & 0xF0)> 0x90) {
a + = 0x60;
setcarry ();
}
clockticks6502 ++;
}
#endif
saveaccum (Ergebnis);
}
statische Lücke sec () {
setcarry ();
}
statische Leere sed () {
setdecimal ();
}
statische Leere sei () {
setinterrupt ();
}
statische Leere sta () {
putvalue (a);
}
statische Lücke stx () {
putvalue (x);
}
statische Leere sty () {
putvalue (y);
}
statische stornosteuer () {
x = a;
zerocalc (x);
signcalc (x);
}
statische Leere tay () {
y = a;
nullocalc (y);
signcalc (y);
}
statische Leere tsx () {
x = sp;
zerocalc (x);
signcalc (x);
}
statische Leere txa () {
a = x;
nullocalc (a);
signcalc (a);
}
statische leere txs () {
sp = x;
}
statische Leere tya () {
a = y;
nullocalc (a);
signcalc (a);
}
// undokumentierte Anweisungen
#ifdef UNDOCUMENTED
statische Lücke lax () {
lda ();
ldx ();
}
statische Leere Sax () {
sta ();
stx ();
putvalue (a & x);
if (Penaltyop && Penaltyaddr) clockticks6502--;
}
statische Lücke dcp () {
dec ();
cmp ();
if (Penaltyop && Penaltyaddr) clockticks6502--;
}
statische Leere isb () {
inc ();
sbc ();
if (Penaltyop && Penaltyaddr) clockticks6502--;
}
statische leere slo () {
asl ();
oder ein();
if (Penaltyop && Penaltyaddr) clockticks6502--;
}
statische Lücke rla () {
rol ();
und();
if (Penaltyop && Penaltyaddr) clockticks6502--;
}
statische Leere sre () {
lsr ();
eor ();
if (Penaltyop && Penaltyaddr) clockticks6502--;
}
statische Lücke rra () {
ror ();
adc ();
if (Penaltyop && Penaltyaddr) clockticks6502--;
}
#sonst
#define lax nop
#define sax nop
#define dcp nop
#define isb nop
#define slo nop
#define rla nop
#define sre nop
#define rra nop
#endif
statische Leere (* addrtable [256]) () = {
/ * | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F | * /
/ * 0 * / imp, indx, imp, indx, zp, zp, zp, zp, imp, imm, acc, imm, abso, abso, abso, abso, / * 0 * /
/ * 1 * / rel, indy, imp, indy, zpx, zpx, zpx, zpx, imp, absy, imp, absy, absx, absx, absx, absx, / * 1 * /
/ * 2 * / abso, indx, imp, indx, zp, zp, zp, zp, imp, imm, acc, imm, abso, abso, abso, abso, / * 2 * /
/ * 3 * / rel, indy, imp, indy, zpx, zpx, zpx, zpx, imp, absy, imp, absy, absx, absx, absx, absx, / * 3 * /
/ * 4 * / imp, indx, imp, indx, zp, zp, zp, zp, imp, imm, acc, imm, abso, abso, abso, abso, / * 4 * /
/ * 5 * / rel, indy, imp, indy, zpx, zpx, zpx, zpx, imp, absy, imp, absy, absx, absx, absx, absx, / * 5 * /
/ * 6 * / imp, indx, imp, indx, zp, zp, zp, zp, imp, imm, acc, imm, ind, abso, abso, abso, / * 6 * /
/ * 7 * / rel, indy, imp, indy, zpx, zpx, zpx, zpx, imp, absy, imp, absy, absx, absx, absx, absx, / * 7 * /
/ * 8 * / imm, indx, imm, indx, zp, zp, zp, zp, imp, imm, imp, imm, abso, abso, abso, abso, / * 8 * /
/ * 9 * / rel, indy, imp, indy, zpx, zpx, zpy, zpy, imp, absy, imp, absy, absx, absx, absy, absy, / * 9 * /
/ * A * / imm, indx, imm, indx, zp, zp, zp, zp, imp, imm, imp, imm, abso, abso, abso, abso, / * A * /
/ * B * / rel, indy, imp, indy, zpx, zpx, zpy, zpy, imp, absy, imp, absy, absx, absx, absy, absy, / * B * /
/ * C * / imm, indx, imm, indx, zp, zp, zp, zp, imp, imm, imp, imm, abso, abso, abso, abso, / * C * /
/ * D * / rel, indy, imp, indy, zpx, zpx, zpx, zpx, imp, absy, imp, absy, absx, absx, absx, absx, / * D * /
/ * E * / imm, indx, imm, indx, zp, zp, zp, zp, imp, imm, imp, imm, abso, abso, abso, abso, / * E * /
/ * F * / rel, indy, imp, indy, zpx, zpx, zpx, zpx, imp, absy, imp, absy, absx, absx, absx, absx / * F * /
};
statische Leere (* optable [256]) () = {
/ * | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F | * /
/ * 0 * / brk, ora, nop, slo, nop, ora, asl, slo, php, ora, asl, nop, nop, ora, asl, slo, / * 0 * /
/ * 1 * / bpl, ora, nop, slo, nop, ora, asl, slo, clc, ora, nop, slo, nop, ora, asl, slo, / * 1 * /
/ * 2 * / jsr und, nop, rla, bit und, rol, rla, plp und, rol, nop, bit und, rol, rla, / * 2 * /
/ * 3 * / bmi und, nop, rla, nop und, rol, rla, sec und, nop, rla, nop und, rol, rla, / * 3 * /
/ * 4 * / rti, eor, nop, sre, nop, eor, lsr, sre, pha, eor, lsr, nop, jmp, eor, lsr, sre, / * 4 * /
/ * 5 * / bvc, eor, nop, sre, nop, eor, lsr, sre, cli, eor, nop, sre, nop, eor, lsr, sre, / * 5 * /
/ * 6 * / rts, adc, nop, rra, nop, adc, ror, rra, pla, adc, ror, nop, jmp, adc, ror, rra, / * 6 * /
/ * 7 * / bvs, adc, nop, rra, nop, adc, ror, rra, sei, adc, nop, rra, nop, adc, ror, rra, / * 7 * /
/ * 8 * / nop, sta, nop, sax, stall, sta, stx, sax, dey, nop, txa, nop, stall, sta, stx, sax, / * 8 * /
/ * 9 * / bcc, sta, nop, nop, sty, sta, stx, sax, tya, sta, txs, nop, nop, sta, nop, nop, / * 9 * /
/ * A * / ldy, lda, ldx, lax, ldy, lda, ldx, lax, tay, lda, steuer, nop, ldy, lda, ldx, lax, / * A * /
/ * B * / bcs, lda, nop, lax, ldy, lda, ldx, lax, clv, lda, tsx, lax, ldy, lda, ldx, lax, / * B * /
/ * C * / cpy, cmp, nop, dcp, cpy, cmp, dez, dcp, iny, cmp, dex, nop, cpy, cmp, dez, dcp, / * C * /
/ * D * / bne, cmp, nop, dcp, nop, cmp, dez, dcp, cld, cmp, nop, dcp, nop, cmp, dez, dcp, / * D * /
/ * E * / CPX, SBC, NOP, ISB, CPX, SBC, INC, ISB, INX, SBC, NOP, SBC, CPX, SBC, INC, ISB, / * E * /
/ * F * / beq, sbc, nop, isb, nop, sbc, inc, isb, sed, sbc, nop, isb, nop, sbc, inc, isb / * F * /
};
static const uint32_t ticktable [256] = {
/ * | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F | * /
/ * 0 * / 7, 6, 2, 8, 3, 3, 5, 5, 3, 2, 2, 2, 4, 4, 6, 6, / * 0 * /
/ * 1 * / 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, / * 1 * /
/ * 2 * / 6, 6, 2, 8, 3, 3, 5, 5, 4, 2, 2, 2, 4, 4, 6, 6, / * 2 * /
/ * 3 * / 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, / * 3 * /
/ * 4 * / 6, 6, 2, 8, 3, 3, 5, 5, 3, 2, 2, 2, 3, 4, 6, 6, / * 4 * /
/ * 5 * / 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, / * 5 * /
/ * 6 * / 6, 6, 2, 8, 3, 3, 5, 5, 4, 2, 2, 2, 5, 4, 6, 6, / * 6 * /
/ * 7 * / 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, / * 7 * /
/ * 8 * / 2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 2, 4, 4, 4, 4, / * 8 * /
/ * 9 * / 2, 6, 2, 6, 4, 4, 4, 4, 2, 5, 2, 5, 5, 5, 5, 5, / * 9 * /
/ * A * / 2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 2, 4, 4, 4, 4, / * A * /
/ * B * / 2, 5, 2, 5, 4, 4, 4, 4, 2, 4, 2, 4, 4, 4, 4, 4, / * B * /
/ * C * / 2, 6, 2, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 6, 6, / * C * /
/ * D * / 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, / * D * /
/ * E * / 2, 6, 2, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 6, 6, / * E * /
/ * F * / 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7 / * F * /
};
nichtig nmi6502 () {
push16 (pc);
push8 (status);
status | = FLAG_INTERRUPT;
pc = (uint16_t) read6502 (0xFFFA) | ((uint16_t) read6502 (0xFFFB) << 8);
}
nichtig irq6502 () {
push16 (pc);
push8 (status);
status | = FLAG_INTERRUPT;
pc = (uint16_t) read6502 (0xFFFE) | ((uint16_t) read6502 (0xFFFF) << 8);
}
uint8_t callexternal = 0;
void (* loopexternal) ();
nichtig exec6502 (uint32_t tickcount) {
clockgoal6502 + = tickcount;
while (clockticks6502 <clockgoal6502) {
opcode = read6502 (pc ++);
Penaltyop = 0;
Penaltyaddr = 0;
(* addrtable [opcode]) ();
(* optable [opcode]) ();
clockticks6502 + = ticktable [opcode];
if (Penaltyop && Penaltyaddr) clockticks6502 ++;
Anweisungen ++;
if (callexternal) (* loopexternal) ();
}
}
nichtig step6502 () {
opcode = read6502 (pc ++);
Penaltyop = 0;
Penaltyaddr = 0;
(* addrtable [opcode]) ();
(* optable [opcode]) ();
clockticks6502 + = ticktable [opcode];
if (Penaltyop && Penaltyaddr) clockticks6502 ++;
clockgoal6502 = clockticks6502;
Anweisungen ++;
if (callexternal) (* loopexternal) ();
}
nichtig hookexternal (void * funcptr) {
if (funcptr! = (void *) NULL) {
loopexternal = funcptr;
callexternal = 1;
} else callexternal = 0;
}