सोचा था कि मैं आगे बढ़ूंगा और अपना खुद का कार्यान्वयन करूंगा। यह पूरी तरह से असंयमित है, लेकिन यह एक पूर्ण कार्यान्वयन है।
- सी। की 668 लाइनें (केवल टिप्पणियों के साथ खाली लाइनों या लाइनों की गिनती नहीं)
- समर्थन करता है (मुझे लगता है) सभी अवांछित निर्देश।
- BCD का समर्थन करता है।
- सीपीयू घड़ी चक्र समय। (कुछ पृष्ठ-सीमा आवरण पर समायोजन सहित)
- एकल-चरण द्वारा या टिक्स की संख्या निर्दिष्ट करके निर्देशों को निष्पादित कर सकते हैं।
- हर निर्देश के समाप्त होने के बाद एक बाहरी फ़ंक्शन को हुक करने का समर्थन करता है। ऐसा इसलिए था क्योंकि यह मूल रूप से एक एनईएस एमुलेटर के लिए था और मैंने इसका उपयोग ऑडियो टाइमिंग के लिए किया था।
/ * नकली 6502 सीपीयू एमुलेटर कोर v1.1 *******************
* (c) 2011-2013 माइक चेम्बर्स *
************************************************** *** /
# अलग करें <stdio.h>
# अलग करें <stdint.h>
// बाहरी रूप से आपूर्ति किए गए कार्य
extern uint8_t read6502 (uint16_t पता);
बाहरी शून्य राइट 6502 (uint16_t पता, uint8_t मूल्य);
// 6502 परिभाषित करता है
#define UNDOCUMENTED // जब इसे परिभाषित किया जाता है, तो अनिर्धारित ऑपकोड को संभाला जाता है।
// अन्यथा, वे बस NOPs के रूप में व्यवहार किया जाता है।
// # परिभाषित NES_CPU // जब यह परिभाषित किया जाता है, तो बाइनरी-कोडेड दशमलव (BCD)
// स्थिति ध्वज एडीसी और एसबीसी द्वारा सम्मानित नहीं किया गया है। 2A03
// निन्टेंडो एंटरटेनमेंट सिस्टम में सीपीयू नहीं है
// समर्थन बीसीडी ऑपरेशन।
#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
# डेफिन सैविएक्कुम (n) a = (uint8_t) ((n) & 0x00FFF)
// ध्वज संशोधक मैक्रोज़
#define setcarry () स्थिति | = FLAG_CARRY
#define क्लर्करी () स्थिति और = (~ FLAG_CARRY)
#define setzero () स्थिति | = FLAG_ZERO
# डाइन क्लीज़रो () स्थिति और = (~ FLAG_ZERO)
#define setinterrupt () स्थिति | = FLAG_INTERRUPT
#define clearinterrupt () स्थिति और = (~ FLAG_INTERRUPT)
#define setdecimal () स्थिति | = FLAG_DECIMAL
#define क्लियरडेसिमल () स्थिति और = (~ FLAG_DECIMAL)
#define setoverflow () स्थिति | = FLAG_OVERFLOW
#define clearoverflow () स्थिति और = (~ FLAG_OVERFLOW)
#define setign () स्थिति | = FLAG_SIGN
#define clearsign () स्थिति और = (~ FLAG_SIGN)
// ध्वज गणना मैक्रोज़
#define zerocalc (n) {\ _
if (n) और 0x00FF) क्लीज़रो () ;;
अन्य सेज़रो () ;;
}
#define signcalc (n) {\ _
if (n) & 0x0080) setign () ;;
और स्पष्ट () ;;
}
# डेफ़िन कैरीकेल्क (n) {\ _
if (n) & 0xFF00) setcarry () ;;
और स्पष्टता () ;;
}
# ओवरफ्लो ओवरक्लॉक (एन, एम, ओ) {/ * एन = परिणाम, एम = संचायक, ओ = एल * * / \
if ((n) ^ (uint16_t) (m)) & ((n) ^ (o)) & 0x0080) setoverflow () ;;
और क्लीवरफ़्लो () ;;
}
// 6502 सीपीयू रजिस्टर
uint16_t पीसी;
uint8_t sp, a, x, y, status = FLAG_CONSTANT;
// सहायक चर
uint64_t निर्देश = 0; // निष्पादित कुल निर्देशों का ट्रैक रखें
uint32_t clockticks6502 = 0, clockgoal6502 = 0;
uint16_t oldpc, ea, reladdr, value, result;
uint8_t opcode, oldstatus;
// कुछ अन्य सामान्य कार्यों द्वारा उपयोग किए जाने वाले कुछ सामान्य कार्य
शून्य पुश 16 (uint16_t पुशवल) {
राइट 6502 (BASE_STACK + सपा, (पुशवल >> 8) और 0xFF);
राइट 6502 (BASE_STACK + ((sp - 1) और 0xFF), पुशवल और 0xFF);
एसपी - = 2;
}
शून्य पुश 8 (uint8_t पुशवल) {
राइट 6502 (BASE_STACK + sp--, पुशवल);
}
uint16_t पुल 16 () {
uint16_t temp16;
temp16 = read6502 (BASE_STACK + ((sp + 1) & 0xFF)) | ((uint16_t) रीड 6502 (BASE_STACK + ((sp + 2) & 0xFF) << <<);
sp + = 2;
वापसी (temp16);
}
uint8_t pull8 () {
वापसी (रीड 6502 (BASE_STACK + ++ sp));
}
शून्य रीसेट 6502 () {
pc = (uint16_t) रीड 6502 (0xFFFC) | ((uint16_t) रीड 6502 (0xFFFD) << 8);
a = 0;
x = 0;
y = 0;
sp = 0xFD;
स्थिति | = FLAG_CONSTANT;
}
स्थिर शून्य (* addrtable [256]) ();
स्थिर शून्य (* वैकल्पिक [256]) ();
uint8_t पेनाल्टी, पेनाल्टीड्र;
// संबोधित मोड मोड, प्रभावी पते की गणना करता है
स्थिर शून्य छोटा सा भूत () {// निहित
}
स्थिर शून्य एसीसी () {// संचायक
}
स्थिर शून्य imm () {// तत्काल
ea = पीसी ++;
}
स्थिर शून्य zp () {// शून्य-पृष्ठ
ea = (uint16_t) read6502 ((uint16_t) पीसी ++);
}
स्थिर शून्य zpx () {// शून्य-पृष्ठ, एक्स
ea = ((uint16_t) read6502 ((uint16_t) पीसी ++) + (uint16_t) x) & 0xFF; // शून्य-पृष्ठ आवरण
}
स्थिर शून्य zpy () {// शून्य-पृष्ठ, वाई
ea = ((uint16_t) read6502 ((uint16_t) PC ++) + (uint16_t) y) & 0xFF; // शून्य-पृष्ठ आवरण
}
स्थिर शून्य संबंध () {// शाखा ऑप्स के लिए सापेक्ष (8-बिट तत्काल मूल्य, हस्ताक्षर-विस्तारित)
reladdr = (uint16_t) रीड 6502 (पीसी ++);
if (reladdr & 0x80) reladdr | = 0xFF00;
}
स्थैतिक शून्य abso () {// निरपेक्ष
ea = (uint16_t) रीड 6502 (पीसी) | ((uint16_t) पठन 6502 (पीसी + 1) << 8);
पीसी + = 2;
}
स्थैतिक शून्य absx () {// निरपेक्ष, एक्स
uint16_t प्रारंभ पृष्ठ;
ea = ((uint16_t) रीड 6502 (पीसी) | ((uint16_t) रीड 6502 (पीसी + 1) << 8));
startpage = ea & 0xFF00;
ea + = (uint16_t) x;
अगर (स्टार्टपेज! = (ea & 0xFF00)) {// कुछ ओपकोड पर पेज-क्रॉसिंग के लिए एक चक्र जुर्माना
दंडाद्र = १;
}
पीसी + = 2;
}
स्थिर शून्य अनुपस्थित () {// निरपेक्ष, वाई
uint16_t प्रारंभ पृष्ठ;
ea = ((uint16_t) रीड 6502 (पीसी) | ((uint16_t) रीड 6502 (पीसी + 1) << 8));
startpage = ea & 0xFF00;
ea + = (uint16_t) y;
अगर (स्टार्टपेज! = (ea & 0xFF00)) {// कुछ ओपकोड पर पेज-क्रॉसिंग के लिए एक चक्र जुर्माना
दंडाद्र = १;
}
पीसी + = 2;
}
स्थिर शून्य इंडस्ट्रीज़ () {// अप्रत्यक्ष
uint16_t eahelp, eahelp2;
eahelp = (uint16_t) रीड 6502 (पीसी) | (uint16_t) ((uint16_t) रीड 6502 (पीसी + 1) << 8);
eahelp2 = (eahelp & 0xFF00) | ((ehelp + 1) & 0x00FF); // प्रतिकृति 6502 पृष्ठ-सीमा रैपराउंड बग
ea = (uint16_t) रीड 6502 (ईएचएलपी) | ((uint16_t) पठन 6502 (eahelp2) << 8);
पीसी + = 2;
}
स्थिर शून्य इंडेक्स () {// (अप्रत्यक्ष, एक्स)
uint16_t eahelp;
eahelp = (uint16_t) (((uint16_t) रीड 6502 (पीसी ++) + (uint16_t) x) & 0xFF); // टेबल पॉइंटर के लिए जीरो पेज रैपराउंड
ea = (uint16_t) read6502 (eahelp & 0x00FF) | ((uint16_t) read6502 ((ehelp + 1) & 0x00FF) << 8);
}
स्थिर शून्य इंडि () {// (अप्रत्यक्ष), वाई
uint16_t eahelp, eahelp2, startpage;
eahelp = (uint16_t) रीड 6502 (पीसी ++);
eahelp2 = (eahelp & 0xFF00) | ((ehelp + 1) & 0x00FF); // शून्य-पृष्ठ आवरण
ea = (uint16_t) रीड 6502 (ईएचएलपी) | ((uint16_t) पठन 6502 (eahelp2) << 8);
startpage = ea & 0xFF00;
ea + = (uint16_t) y;
अगर (स्टार्टपेज! = (ea & 0xFF00)) {// कुछ ओपकोड पर पेज-क्रॉसिंग के लिए एक चक्र जुर्माना
दंडाद्र = १;
}
}
स्थिर uint16_t getvalue () {
अगर (addrtable [opcode] == acc) वापसी ((uint16_t) a);
और वापसी (uint16_t) रीड 6502 (ईआर));
}
स्थैतिक शून्य पुटुले (uint16_t बचत) {
अगर (addrtable [opcode] == एसीसी) a = (uint8_t) (बचत और 0x00FF);
अन्य राइट 6502 (ea, (बचत और 0x00FF));
}
// निर्देश हैंडलर फ़ंक्शन
स्थिर शून्य () {
पेनलोप = 1;
मूल्य = getvalue ();
परिणाम = (uint16_t) एक + मूल्य + (uint16_t) (स्थिति और FLAG_CARRY);
carrycalc (परिणाम);
zerocalc (परिणाम);
अतिप्रवाह (परिणाम, ए, मूल्य);
signcalc (परिणाम);
#ifndef NES_CPU
यदि (स्थिति और FLAG_DECIMAL) {
clearcarry ();
अगर ((a & 0x0F)> 0x09) {
ए + = 0x06;
}
अगर ((a & 0xF0)> 0x90) {
ए + = 0x60;
setcarry ();
}
clockticks6502 ++;
}
#अगर अंत
saveaccum (परिणाम);
}
स्थिर शून्य और () {
पेनलोप = 1;
मूल्य = getvalue ();
परिणाम = (uint16_t) a & value;
zerocalc (परिणाम);
signcalc (परिणाम);
saveaccum (परिणाम);
}
स्थिर शून्य asl () {
मूल्य = getvalue ();
परिणाम = मान << 1;
carrycalc (परिणाम);
zerocalc (परिणाम);
signcalc (परिणाम);
putvalue (परिणाम);
}
स्थिर शून्य bcc () {
अगर (स्थिति और FLAG_CARRY) == 0) {
पुराना पीसी = पीसी;
PC + = reladdr;
if ((oldpc & 0xFF00)! = (pc & 0xFF00)) clockticks6502 + = 2; // चेक करें कि क्या जंप ने पृष्ठ सीमा पार की है
और घड़ीसाज़ 6502 ++;
}
}
स्थिर शून्य बक्स () {
अगर (स्थिति और FLAG_CARRY) == FLAG_CARRY) {
पुराना पीसी = पीसी;
PC + = reladdr;
if ((oldpc & 0xFF00)! = (pc & 0xFF00)) clockticks6502 + = 2; // चेक करें कि क्या जंप ने पृष्ठ सीमा पार की है
और घड़ीसाज़ 6502 ++;
}
}
स्थिर शून्य beq () {
अगर (स्थिति और FLAG_ZERO) == FLAG_ZERO) {
पुराना पीसी = पीसी;
PC + = reladdr;
if ((oldpc & 0xFF00)! = (pc & 0xFF00)) clockticks6502 + = 2; // चेक करें कि क्या जंप ने पृष्ठ सीमा पार की है
और घड़ीसाज़ 6502 ++;
}
}
स्थिर शून्य बिट () {
मूल्य = getvalue ();
परिणाम = (uint16_t) a & value;
zerocalc (परिणाम);
स्टेटस = (स्थिति & 0x3F) | (uint8_t) (मान & 0xC0);
}
स्थिर शून्य बीएमआई () {
अगर (स्थिति और FLAG_SIGN) == FLAG_SIGN) {
पुराना पीसी = पीसी;
PC + = reladdr;
if ((oldpc & 0xFF00)! = (pc & 0xFF00)) clockticks6502 + = 2; // चेक करें कि क्या जंप ने पृष्ठ सीमा पार की है
और घड़ीसाज़ 6502 ++;
}
}
स्थिर शून्य () {
अगर (स्थिति और FLAG_ZERO) == 0) {
पुराना पीसी = पीसी;
PC + = reladdr;
if ((oldpc & 0xFF00)! = (pc & 0xFF00)) clockticks6502 + = 2; // चेक करें कि क्या जंप ने पृष्ठ सीमा पार की है
और घड़ीसाज़ 6502 ++;
}
}
स्थिर शून्य bpl () {
अगर (स्थिति और FLAG_SIGN) == 0) {
पुराना पीसी = पीसी;
PC + = reladdr;
if ((oldpc & 0xFF00)! = (pc & 0xFF00)) clockticks6502 + = 2; // चेक करें कि क्या जंप ने पृष्ठ सीमा पार की है
और घड़ीसाज़ 6502 ++;
}
}
स्थिर शून्य brk () {
पीसी ++;
push16 (पीसी); // स्टैक पर अगले निर्देश पते को धक्का दें
push8 (स्थिति | FLAG_BREAK); // ढेर करने के लिए सीपीयू स्थिति धक्का
setinterrupt (); // सेट इंटरप्ट फ्लैग
pc = (uint16_t) रीड 6502 (0xFFFE) | ((uint16_t) रीड 6502 (0xFFFF) << 8);
}
स्थिर शून्य पीवीसी () {
अगर (स्थिति और FLAG_OVERFLOW) == 0) {
पुराना पीसी = पीसी;
PC + = reladdr;
if ((oldpc & 0xFF00)! = (pc & 0xFF00)) clockticks6502 + = 2; // चेक करें कि क्या जंप ने पृष्ठ सीमा पार की है
और घड़ीसाज़ 6502 ++;
}
}
स्थिर शून्य bvs () {
अगर (स्थिति और FLAG_OVERFLOW) == FLAG_OVERFLOW) {
पुराना पीसी = पीसी;
PC + = reladdr;
if ((oldpc & 0xFF00)! = (pc & 0xFF00)) clockticks6502 + = 2; // चेक करें कि क्या जंप ने पृष्ठ सीमा पार की है
और घड़ीसाज़ 6502 ++;
}
}
स्थिर शून्य clc () {
clearcarry ();
}
स्थिर शून्य cld () {
cleardecimal ();
}
स्थिर शून्य क्ली () {
clearinterrupt ();
}
स्थिर शून्य clv () {
clearoverflow ();
}
स्थिर शून्य cmp () {
पेनलोप = 1;
मूल्य = getvalue ();
परिणाम = (uint16_t) a - मूल्य;
if (a> = (uint8_t) (मान और 0x00FF)) setcarry ();
और स्पष्टता ();
अगर (a == (uint8_t) (मान & 0x00FF)) सेज़रो ();
और क्लीज़रो ();
signcalc (परिणाम);
}
स्थिर शून्य cpx () {
मूल्य = getvalue ();
परिणाम = (uint16_t) x - मान;
अगर (x> = (uint8_t) (मान और 0x00FF)) सेटकार्री ();
और स्पष्टता ();
अगर (x == (uint8_t) (मान और 0x00FF)) सेज़रो ();
और क्लीज़रो ();
signcalc (परिणाम);
}
स्थिर शून्य खांसी () {
मूल्य = getvalue ();
परिणाम = (uint16_t) y - मूल्य;
अगर (y> = (uint8_t) (मान और 0x00FF)) सेटकार्री ();
और स्पष्टता ();
if (y == (uint8_t) (मान और 0x00FF)) सेज़रो ();
और क्लीज़रो ();
signcalc (परिणाम);
}
स्थिर शून्य से () {
मूल्य = getvalue ();
परिणाम = मूल्य - 1;
zerocalc (परिणाम);
signcalc (परिणाम);
putvalue (परिणाम);
}
स्थिर शून्य डेक्स () {
एक्स--;
zerocalc (x);
signcalc (x);
}
स्थिर शून्य दे () {
y--;
zerocalc (y);
signcalc (y);
}
स्थिर शून्य () {
पेनलोप = 1;
मूल्य = getvalue ();
परिणाम = (uint16_t) ए ^ मूल्य;
zerocalc (परिणाम);
signcalc (परिणाम);
saveaccum (परिणाम);
}
स्थिर शून्य इंक () {
मूल्य = getvalue ();
परिणाम = मूल्य + 1;
zerocalc (परिणाम);
signcalc (परिणाम);
putvalue (परिणाम);
}
स्थिर शून्य inx () {
एक्स ++;
zerocalc (x);
signcalc (x);
}
स्थिर शून्य () {
y ++;
zerocalc (y);
signcalc (y);
}
स्थिर शून्य jmp () {
PC = ea;
}
स्थिर शून्य jsr () {
push16 (पीसी - 1);
PC = ea;
}
स्थिर शून्य lda () {
पेनलोप = 1;
मूल्य = getvalue ();
a = (uint8_t) (मान & 0x00FF);
zerocalc (क);
signcalc (क);
}
स्थिर शून्य ldx () {
पेनलोप = 1;
मूल्य = getvalue ();
x = (uint8_t) (मान & 0x00FF);
zerocalc (x);
signcalc (x);
}
स्थिर शून्य () {
पेनलोप = 1;
मूल्य = getvalue ();
y = (uint8_t) (मूल्य और 0x00FF);
zerocalc (y);
signcalc (y);
}
स्थिर शून्य lsr () {
मूल्य = getvalue ();
परिणाम = मूल्य >> 1;
अगर (मान & 1) सेटकार्री ();
और स्पष्टता ();
zerocalc (परिणाम);
signcalc (परिणाम);
putvalue (परिणाम);
}
स्थिर शून्य () {
स्विच (opcode) {
मामला 0x1C:
मामला 0x3C:
मामला 0x5C:
मामला 0x7C:
मामला 0xDC:
मामला 0xFC:
पेनलोप = 1;
टूटना;
}
}
स्थिर शून्य () {
पेनलोप = 1;
मूल्य = getvalue ();
परिणाम = (uint16_t) ए | मूल्य;
zerocalc (परिणाम);
signcalc (परिणाम);
saveaccum (परिणाम);
}
स्थिर शून्य चरण () {
push8 (क);
}
स्थिर शून्य php () {
push8 (स्थिति | FLAG_BREAK);
}
स्थिर शून्य प्लाया () {
a = pull8 ();
zerocalc (क);
signcalc (क);
}
स्थिर शून्य plp () {
स्टेटस = पुल 8 () | FLAG_CONSTANT;
}
स्थिर शून्य रोल () {
मूल्य = getvalue ();
परिणाम = (मूल्य << 1) | (स्थिति और FLAG_CARRY);
carrycalc (परिणाम);
zerocalc (परिणाम);
signcalc (परिणाम);
putvalue (परिणाम);
}
स्थिर शून्य रोर () {
मूल्य = getvalue ();
परिणाम = (मूल्य >> 1) | ((स्थिति & FLAG_CARRY) << 7);
अगर (मान & 1) सेटकार्री ();
और स्पष्टता ();
zerocalc (परिणाम);
signcalc (परिणाम);
putvalue (परिणाम);
}
स्थिर शून्य आरटीआई () {
स्थिति = पुल 8 ();
मूल्य = pull16 ();
पीसी = मूल्य;
}
स्थिर शून्य आरटीएस () {
मूल्य = pull16 ();
पीसी = मान + 1;
}
स्थिर शून्य sbc () {
पेनलोप = 1;
मान = getvalue () ^ 0x00FF;
परिणाम = (uint16_t) एक + मूल्य + (uint16_t) (स्थिति और FLAG_CARRY);
carrycalc (परिणाम);
zerocalc (परिणाम);
अतिप्रवाह (परिणाम, ए, मूल्य);
signcalc (परिणाम);
#ifndef NES_CPU
यदि (स्थिति और FLAG_DECIMAL) {
clearcarry ();
ए - = 0x66;
अगर ((a & 0x0F)> 0x09) {
ए + = 0x06;
}
अगर ((a & 0xF0)> 0x90) {
ए + = 0x60;
setcarry ();
}
clockticks6502 ++;
}
#अगर अंत
saveaccum (परिणाम);
}
स्थिर शून्य सेकंड () {
setcarry ();
}
स्थिर शून्य सेड () {
setdecimal ();
}
स्थिर शून्य सेई () {
setinterrupt ();
}
स्थिर शून्य sta () {
putvalue (क);
}
स्थिर शून्य स्टॉक्स () {
putvalue (x);
}
स्थिर शून्य शैली () {
putvalue (y);
}
स्थिर शून्य कर () {
x = ए;
zerocalc (x);
signcalc (x);
}
स्थिर शून्य () {
य = ए;
zerocalc (y);
signcalc (y);
}
स्थिर शून्य tsx () {
x = सपा;
zerocalc (x);
signcalc (x);
}
स्थिर शून्य txa () {
ए = एक्स;
zerocalc (क);
signcalc (क);
}
स्थिर शून्य txs () {
sp = x;
}
स्थिर शून्य () {
a = y;
zerocalc (क);
signcalc (क);
}
// अनिर्दिष्ट निर्देश
#ifdef UNDOCUMENTED
स्थिर शून्य लक्स () {
झील प्राधिकरण ();
LDX ();
}
स्थिर शून्य सैक्स () {
स्टेशन ();
stx ();
putvalue (a & x);
if (पेनलोप और& पेनलैडड्र) क्लॉकटिक्स 6502--;
}
स्थिर शून्य dcp () {
दिसम्बर ();
सीएमपी ();
if (पेनलोप और& पेनलैडड्र) क्लॉकटिक्स 6502--;
}
स्थिर शून्य () {
इंक ();
SBC ();
if (पेनलोप और& पेनलैडड्र) क्लॉकटिक्स 6502--;
}
स्थिर शून्य का नारा () {
एएसएल ();
ओरा ();
if (पेनलोप और& पेनलैडड्र) क्लॉकटिक्स 6502--;
}
स्थिर शून्य राला () {
ROL ();
तथा();
if (पेनलोप और& पेनलैडड्र) क्लॉकटिक्स 6502--;
}
स्थिर शून्य sre () {
LSR ();
ईओआर ();
if (पेनलोप और& पेनलैडड्र) क्लॉकटिक्स 6502--;
}
स्थिर शून्य आरआरए () {
ROR ();
एडीसी ();
if (पेनलोप और& पेनलैडड्र) क्लॉकटिक्स 6502--;
}
#अन्य
# डेफिन लैक्स नॉप
# डेफिन सैक्स नं
# डेफिन डीसीपी एनओपी
# डेफिन इसब नॉप
# डेफिन स्लो एनओपी
# डेफिन रला नोप
# डेफिन सेरे नोप
# डेफिन आरआरए एनओपी
#अगर अंत
स्थिर शून्य (* addrtable [256]) () = {
/ * | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ए | B | सी | डी | ई | एफ | * /
/ * 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, 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, 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, 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, absx, / * 7 * /
/ * 8 * / imm, इंडेक्स, imm, इंडेक्स, 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, absx, absy, absy, / * * 9 * /
/ * ए * / ईएनडी, ईएक्सएक्स, ईएमडी, इंडेक्स, जेडपी, जेडपी, जेडपी, जेडपी, छोटा सा भूत, आईएम, आईएम, एब्स, एब्स, एब्सो, एब्सो, / * ए * /
/ * B * / rel, indy, imp, indy, zpx, zpx, zpy, zpy, imp, absy, imp, absy, absx, 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, absx, / * D * /
/ * ई * / ईएनडी, इंडेक्स, एक्सएक्सएक्स, इंडेक्स, जेडपी, जेडपी, जेडपी, जेडपी, छोटा सा भूत, ईएमपी, एबी, एसो, एब्सो, एब्सो, / * ई * /
/ * F * / rel, indy, imp, indy, zpx, zpx, zpx, zpx, imp, absy, imp, absy, absx, absx, absx, absx / * F * /
};
स्थिर शून्य (* वैकल्पिक [256]) () = {
/ * | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ए | B | सी | डी | ई | एफ | * /
/ * 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, और, एनओपी, आरएलए, बिट, और, रोल, आरएलए, पीएलपी, और, रोल, एनओपी, बिट, और, रोल, आरएलए, / * 2 * /
/ * 3 * / bmi, और, nop, rla, nop, और, rol, rla, sec, और, nop, rla, nop और, rol, rla, / * 3 * /
/ * 4 * / आरटीआई, ईओआर, एनओपी, एसआरई, एनओपी, ईएसआर, एलएसआर, एसआरए, फे, ईओआर, एलएसआर, एनओपी, जेएमपी, ईआरआर, एलएसआर, एसआरई, / * 4 * /
/ * 5 * / bvc, eor, nop, sre, nop, eor, lsr, sre, cli, eor, nop, sre, nop, eor, lsr, sre, / 5 * /
/ * 6 * / आरटीएस, एडीसी, एनओपी, आरआरए, एनओपी, आरसीआर, आरएआर, आरएआर, पीएलए, एडीसी, आरओआर, एनओपी, जेएमपी, एडीसी, आरओआर, आरएआर, / * 6/3/
/ * 7 * / bvs, adc, nop, rra, nop, adc, ror, rra, sei, adc, nop, rra, nop, adc, ror, rra, / 7/7 / /
/ * 8 * / nop, sta, nop, sax, style, sta, stx, sax, dex, nop, txa, nop, style, sta, stx, sax, / * 8 * *
/ * 9 * / bcc, sta, nop, nop, style, sta, stx, sax, tya, sta, txs, nop, nop, sta, nop, nop, / * 9/3/
/ * ए * / ldy, lda, ldx, lax, ldy, lda, ldx, lax, tay, lda, tax, nop, ldy, lda, ldx, lax, / A * /
/ * बी * / बीसीएस, एलडीए, एनओपी, लैक्स, एलडीआई, एलडीए, एलएक्सएक्स, एलएक्स, एलडीए, टीएक्सएक्स, एलएक्स, एलडीआई, एलडीए, एलडीएक्स, लैक्स, / * बी * /
/ * C * / cpy, cmp, nop, dcp, cpy, cmp, dec, dcp, iny, cmp, dex, nop, cpy, cmp, dec, dcp, / * * *
/ * D * / bne, cmp, nop, dcp, nop, cmp, dec, dcp, cld, cmp, nop, dcp, nop, cmp, dec, 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 / /
};
स्थिर कास्ट uint32_t टिकटेबल [256] = {
/ * | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ए | B | सी | डी | ई | एफ | * /
/ * 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, 3, 2, 2, 2, 2, 4, 4, 4, 4, / * 8 * /
/ * 9 * / 2, 6, 2, 6, 4, 4, 4, 4, 4, 2, 5, 2, 5, 5, 5, 5, 5, / * 9 * /
/ * ए * / 2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 2, 4, 4, 4, 4, / * ए * /
/ * B * / 2, 5, 2, 5, 4, 4, 4, 4, 4, 2, 4, 2, 4, 4, 4, 4, / * B * /
/ * C * / 2, 6, 2, 8, 3, 3, 5, 5, 2, 2, 2, 2, 2, 4, 6, 6, / * C * /
/ * डी * / 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, / * डी * /
/ * ई * / 2, 6, 2, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 6, 6, / * ई * /
/ * एफ * / 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7 / * एफ * /
};
शून्य nmi6502 () {
push16 (पीसी);
push8 (स्थिति);
स्थिति | = FLAG_INTERRUPT;
pc = (uint16_t) रीड 6502 (0xFFFA) | ((uint16_t) पठन 6502 (0xFFFB) << 8);
}
शून्य irq6502 () {
push16 (पीसी);
push8 (स्थिति);
स्थिति | = FLAG_INTERRUPT;
pc = (uint16_t) रीड 6502 (0xFFFE) | ((uint16_t) रीड 6502 (0xFFFF) << 8);
}
uint8_t कैलक्लेरेंट = 0;
शून्य (* लूपटेक्स्टर्न) ();
शून्य निष्पादित 6502 (uint32_t टिककाउंट) {
clockgoal6502 + = टिक्काउंट;
जबकि (क्लॉकटिक्स 6502 <क्लॉकगोला 6502) {
opcode = read6502 (पीसी ++);
दंड = 0;
दंडाद्र्ध = ०;
(* Addrtable [opcode]) ();
(* Optable [opcode]) ();
क्लॉकटिक्स 6502 + = टिकटेबल [ओपकोड];
if (पेनलोप && पेनलैडड्र) क्लॉकटिक्स 6502 ++;
निर्देश ++;
यदि (कैलेक्सैनेटिक) (* लूपेक्सटर्न) ();
}
}
शून्य चरण 6502 () {
opcode = read6502 (पीसी ++);
दंड = 0;
दंडाद्र्ध = ०;
(* Addrtable [opcode]) ();
(* Optable [opcode]) ();
क्लॉकटिक्स 6502 + = टिकटेबल [ओपकोड];
if (पेनलोप && पेनलैडड्र) क्लॉकटिक्स 6502 ++;
क्लॉकगोला 6502 = क्लॉकटिक्स 6502;
निर्देश ++;
यदि (कैलेक्सैनेटिक) (* लूपेक्सटर्न) ();
}
शून्य हुक-रहित (शून्य * कवक) {
अगर (funcptr! = (void *) NULL) {
लूपेक्सटर्न = फंकप्ट्र;
कैलेस्टर्न = 1;
} और कैलक्लेरेंट = 0;
}