/* Eww, long titles. So yea, I've been working on a NES emulator. ( https://wiki.nesdev.com/w/index.php/NES_reference_guide ) And in order to test the emulator I had to write some assembly code. Instead of downloading an assembler for the 6502 processor ( https://en.wikipedia.org/wiki/MOS_Technology_6502 ) I decided I might as well write one myself for some experience, which I had never done before. Now that it is pretty much working I felt I might as well upload a demo to Sololearn. The job of an assembler is to translate assembly instructions into machine code for a specific CPU. Don't confuse it with a compiler. A compiler converts source code into assembly, not machine code. Maybe I'll make my own small programming language, a compiler and an assembler for modern CPU's, gonna be fun. And it'll probably take a while... Anyway, this program contains the assembler and a small, stripped NES emulator. Barely enough to support this demo program. I only finished the CPU's jump table not so long ago, but I had to remove most of it's functionality in this program otherwise it would take another 2- or 3000 lines on top of this and most phones probably won't like that. They probably already don't like this size. Code might be a bit messy, because I crammed multiple source files into 1. #'s everywhere :) I didn't comment much... or at all actually. Just ask if you don't understand something. */ // #define ASSEMBLER_DEBUG #define NES_DEBUG const char g_Program[] = // All it basically does is call a function and add 2 numbers 0x8A + 0x1F = 0xA9 ( A register ) "LDA #$00 ; LoaD Accumulator ( with 0x00 )\n" "LDX #$8A ; LoaD X register ( with 0x8A )\n" "LDY #$1F ; LoaD Y register ( with 0x1F )\n" "JSR ADD ; Jump to SubRoutine ( to label ADD )\n" "JMP END ; JuMP\n" "\n" "ADD: ; Just a label\n" " LDA #$00\n" " STX $FF ; STore X register ( X to memory 0xFF )\n" " STY $FE ; STore Y register ( Y to memory 0xFE )\n" " ADC $FF ; ADd with Carry ( load value at 0xFF )\n" " CLC ; CLear Carry flag\n" " ADC $FE ; \n" " RTS ; ReTurn from Subroutine\n" "\n" "END: NOP ; No OPeration\n" "NOP\n"; #ifndef MOS_6502_ASSEMBLER_H #define MOS_6502_ASSEMBLER_H #include #include #include #include #include #include #ifndef MOS_6502_INSTRUCTION_H #define MOS_6502_INSTRUCTION_H #ifndef MOS_6502_DEFINES_H #define MOS_6502_DEFINES_H #include namespace MOS6502 { using u8 = uint8_t; using s8 = int8_t; using u16 = uint16_t; } #endif // MOS_6502_DEFINES_H #include #include #include #include namespace MOS6502 { class Instruction { public: enum class Identifier : u8 { Undefined, Label, // Label is special ADC, ALR, ANC, AND, ARR, ASL, AXS, BCC, BCS, BEQ, BIT, BMI, BNE, BPL, BRK, BVC, BVS, CLC, CLD, CLI, CLV, CMP, CPX, CPY, DCP, DEC, DEX, DEY, EOR, INC, INX, INY, ISC, JMP, JSR, LAX, LDA, LDX, LDY, LSR, NOP, ORA, PHA, PHP, PLA, PLP, ROL, ROR, RRA, RTI, RTS, SAX, SBC, SEC, SED, SEI, SLO, SRE, STA, STX, STY, TAX, TAY, TSX, TXA, TXS, TYA, XAA }; struct Addressing { std::optional implied; std::optional accumulator; std::optional immediate; std::optional zeroPage; std::optional zeroPageX; std::optional zeroPageY; std::optional absolute; std::optional absoluteX; std::optional absoluteY; std::optional indirect; std::optional indirectX; std::optional indirectY; std::optional relative; }; struct Assembly { std::string text; // Instruction name Identifier id; // Instruction id Addressing opcodes; // Instruction opcodes std::vector arguments; // Instruction arguments friend bool operator<( const Assembly& lhs, const Assembly& rhs ) { return lhs.text == rhs.text; } }; struct AssemblyCompare { // Allows comparison with different types using is_transparent = std::true_type; bool operator()( const Assembly& lhs, const std::string& rhs ) const { return lhs.text < rhs; } bool operator()( const std::string& lhs, const Assembly& rhs ) const { return lhs < rhs.text; } bool operator()( const Assembly& lhs, const Identifier& rhs ) const { return lhs.id < rhs; } bool operator()( const Identifier& lhs, const Assembly& rhs ) const { return lhs < rhs.id; } bool operator()( const Assembly& lhs, const Assembly& rhs ) const { return lhs.text < rhs.text; } }; const static std::set IdentifierStrings; public: explicit Instruction(); explicit Instruction( Identifier id ); explicit Instruction( const std::string& s ); explicit Instruction( Identifier id, const std::string& s ); void setArguments( const std::vector& arguments ){ m_Assembly.arguments = arguments; } const std::string& getText() const{ return m_Assembly.text; } Identifier getId() const { return m_Assembly.id; } Addressing getOpcodes() const { return m_Assembly.opcodes; } const std::vector& getArguments() const { return m_Assembly.arguments; } static bool isInstruction( const std::string& s ); static std::pair isInstructionWithId( const std::string& s ); friend bool operator==( const Instruction& lhs, Instruction::Identifier rhs ) { return lhs.m_Assembly.id == rhs; } friend bool operator==( Instruction::Identifier lhs, const Instruction& rhs ) { return lhs == rhs.m_Assembly.id; } private: explicit Instruction( const Assembly& _asm ); static std::string getIdentifierString( Identifier id ); static Assembly getInstruction( const std::string& s ); private: Assembly m_Assembly; }; } #endif // MOS_6502_INSTRUCTION_H namespace MOS6502 { const std::set Instruction::IdentifierStrings = { #define O( x ) #x, Identifier::x { O( ADC ), { { }, { }, {0x69}, {0x65}, {0x75}, { }, {0x6D}, {0x7D}, {0x79}, { }, {0x61}, {0x71}, { } } }, { O( ALR ), { { }, { }, {0x4B}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( ANC ), { { }, { }, {0x0B}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( AND ), { { }, { }, {0x29}, {0x25}, {0x35}, { }, {0x2D}, {0x3D}, {0x39}, { }, {0x21}, {0x31}, { } } }, { O( ARR ), { { }, { }, {0x6B}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( ASL ), { { }, {0x0A}, { }, {0x06}, {0x16}, { }, {0x0E}, {0x1E}, { }, { }, { }, { }, { } } }, { O( AXS ), { { }, { }, {0xCB}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( BCC ), { { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, {0x90} } }, { O( BCS ), { { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, {0xB0} } }, { O( BEQ ), { { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, {0xF0} } }, { O( BIT ), { { }, { }, { }, {0x24}, { }, { }, {0x2C}, { }, { }, { }, { }, { }, { } } }, { O( BMI ), { { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, {0x30} } }, { O( BNE ), { { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, {0xD0} } }, { O( BPL ), { { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, {0x10} } }, { O( BRK ), { {0x00}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( BVC ), { { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, {0x50} } }, { O( BVS ), { { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, {0x70} } }, { O( CLC ), { {0x18}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( CLD ), { {0xD8}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( CLI ), { {0x58}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( CLV ), { {0xB8}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( CMP ), { { }, { }, {0xC9}, {0xC5}, {0xD5}, { }, {0xCD}, {0xDD}, {0xD9}, { }, {0xC1}, {0xD1}, { } } }, { O( CPX ), { { }, { }, {0xE0}, {0xE4}, { }, { }, {0xEC}, { }, { }, { }, { }, { }, { } } }, { O( CPY ), { { }, { }, {0xC0}, {0xC4}, { }, { }, {0xCC}, { }, { }, { }, { }, { }, { } } }, { O( DCP ), { { }, { }, { }, {0xC7}, {0xB7}, { }, {0xCF}, {0xDF}, {0xDB}, { }, {0xC3}, {0xD3}, { } } }, { O( DEC ), { { }, { }, { }, {0xC6}, {0xD6}, { }, {0xCE}, {0xDE}, { }, { }, { }, { }, { } } }, { O( DEX ), { {0xCA}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( DEY ), { {0x88}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( EOR ), { { }, { }, {0x49}, {0x45}, {0x55}, { }, {0x4D}, {0x5D}, {0x59}, { }, {0x41}, {0x51}, { } } }, { O( INC ), { { }, { }, { }, {0xE6}, {0xF6}, { }, {0xEE}, {0xFE}, { }, { }, { }, { }, { } } }, { O( INX ), { {0xE8}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( INY ), { {0xC8}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( ISC ), { { }, { }, { }, {0xE7}, {0xF7}, { }, {0xEF}, {0xFF}, {0xFB}, { }, {0xE3}, {0xF3}, { } } }, { O( JMP ), { { }, { }, { }, { }, { }, { }, {0x4C}, { }, { }, {0x6C}, { }, { }, { } } }, { O( JSR ), { { }, { }, { }, { }, { }, { }, {0x20}, { }, { }, { }, { }, { }, { } } }, { O( LAX ), { { }, { }, {0xAB}, {0xA7}, {0xB7}, { }, {0xAF}, { }, {0xBF}, { }, {0xA3}, {0xB3}, { } } }, { O( LDA ), { { }, { }, {0xA9}, {0xA5}, {0xB5}, { }, {0xAD}, {0xBD}, {0xB9}, { }, {0xA1}, {0xB1}, { } } }, { O( LDX ), { { }, { }, {0xA2}, {0xA6}, { }, {0xB6}, {0xAE}, { }, {0xBE}, { }, { }, { }, { } } }, { O( LDY ), { { }, { }, {0xA0}, {0xA4}, {0xB4}, { }, {0xAC}, {0xBC}, { }, { }, { }, { }, { } } }, { O( LSR ), { { }, {0x4A}, { }, {0x46}, {0x56}, { }, {0x4E}, {0x5E}, { }, { }, { }, { }, { } } }, { O( NOP ), { {0xEA}, { }, {0x80}, {0x04}, {0x14}, { }, {0x0C}, {0x1C}, { }, { }, { }, { }, { } } }, { O( ORA ), { { }, { }, {0x09}, {0x05}, {0x15}, { }, {0x0D}, {0x1D}, {0x19}, { }, {0x01}, {0x11}, { } } }, { O( PHA ), { {0x48}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( PHP ), { {0x08}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( PLA ), { {0x68}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( PLP ), { {0x28}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( ROL ), { { }, {0x2A}, { }, {0x26}, {0x36}, { }, {0x2E}, {0x3E}, { }, { }, { }, { }, { } } }, { O( ROR ), { { }, {0x6A}, { }, {0x66}, {0x76}, { }, {0x6E}, {0x7E}, { }, { }, { }, { }, { } } }, { O( RRA ), { { }, { }, { }, {0x67}, {0x77}, { }, {0x6F}, {0x7F}, {0x7B}, { }, {0x63}, {0x73}, { } } }, { O( RTI ), { {0x40}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( RTS ), { {0x60}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( SAX ), { { }, { }, { }, {0x87}, {0x97}, { }, {0x8F}, { }, { }, { }, {0x83}, { }, { } } }, { O( SBC ), { { }, { }, {0xE9}, {0xE5}, {0xF5}, { }, {0xED}, {0xFD}, {0xF9}, { }, {0xE1}, {0xF1}, { } } }, { O( SEC ), { {0x38}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( SED ), { {0xF8}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( SEI ), { {0x78}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( SLO ), { { }, { }, { }, {0x07}, {0x17}, { }, {0x0F}, {0x1F}, {0x1B}, { }, {0x03}, {0x13}, { } } }, { O( SRE ), { { }, { }, { }, {0x47}, {0x57}, { }, {0x4F}, {0x5F}, {0x5B}, { }, {0x43}, {0x53}, { } } }, { O( STA ), { { }, { }, { }, {0x85}, {0x95}, { }, {0x8D}, {0x9D}, {0x99}, { }, {0x81}, {0x91}, { } } }, { O( STX ), { { }, { }, { }, {0x86}, { }, {0x96}, {0x8E}, { }, { }, { }, { }, { }, { } } }, { O( STY ), { { }, { }, { }, {0x84}, {0x94}, { }, {0x8C}, { }, { }, { }, { }, { }, { } } }, { O( TAX ), { {0xAA}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( TAY ), { {0xA8}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( TSX ), { {0xBA}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( TXA ), { {0x8A}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( TXS ), { {0x9A}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( TYA ), { {0x98}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, { O( XAA ), { { }, { }, {0xBB}, { }, { }, { }, { }, { }, { }, { }, { }, { }, { } } }, #undef O }; Instruction::Instruction() : m_Assembly{ "Undefined", Identifier::Undefined } {} Instruction::Instruction( Identifier id ) : m_Assembly{ getIdentifierString( id ), id } {} Instruction::Instruction( const Assembly& _asm ) : m_Assembly( _asm ) {} Instruction::Instruction( const std::string& s ) : m_Assembly( getInstruction( s ) ) {} Instruction::Instruction( Identifier id, const std::string& s ) : m_Assembly{ s, id } { } std::string Instruction::getIdentifierString( Identifier id ) { if( id == Identifier::Undefined ) return "Undefined"; else if( id == Identifier::Label ) return ""; if( auto it = IdentifierStrings.find( id ); it != IdentifierStrings.end() ) { return it->text; } return "Undefined"; } bool Instruction::isInstruction( const std::string& s ) { return IdentifierStrings.find( s ) != IdentifierStrings.end(); } std::pair Instruction::isInstructionWithId( const std::string& s ) { if( auto it = IdentifierStrings.find( s ); it != IdentifierStrings.end() ) { return std::make_pair( it->id, true ); } else { return std::make_pair( Identifier::Undefined, false ); } } Instruction::Assembly Instruction::getInstruction( const std::string& s ) { if( auto it = IdentifierStrings.find( s ); it != IdentifierStrings.end() ) { return *it; } else { return { getIdentifierString( Identifier::Undefined ), Identifier::Undefined }; } } } namespace MOS6502 { class Assembler { private: enum class AddressingMode { Undefined, Accumulator, Implied, Immediate, ZeroPage, ZeroPageX, ZeroPageY, Absolute, AbsoluteX, AbsoluteY, Indirect, IndirectX, IndirectY, Relative }; struct InstructionInfo { Instruction assembly; size_t index; std::string line; }; struct Label { std::string text; size_t index; size_t offset; friend bool operator<( const Label& lhs, const Label& rhs ) { return lhs.text < rhs.text; } }; struct ParseInfo { std::variant variant; bool valid; Label label; }; struct ScanInfo { AddressingMode mode; bool valid; }; struct LabelTranslateInfo { AddressingMode mode; bool written; std::variant offset; }; struct LabelTracker { Label label; size_t opcodeIndex; AddressingMode mode; }; public: explicit Assembler(); bool loadFromFile( const std::string& filepath ); bool writeToFile( const std::string& filepath ); bool assemble(); #if defined( ASSEMBLER_DEBUG ) void debug(); #endif private: bool parseFile( std::ifstream& file ); bool generateMachineCode(); bool translateInstructions(); Instruction parseInstruction( const std::string& instruction, size_t index ); std::vector parseLine( std::string line, size_t index ); std::vector parseArguments( const std::string& arguments ) const; int generateInstruction( const InstructionInfo& instruction ); void pushToAssembly( u8 opcode ); void pushToAssembly( u8 opcode, u8 byte ); void pushToAssembly( u8 opcode, u16 word ); ScanInfo scanAll( const InstructionInfo& instruction ); LabelTranslateInfo translateLabel( const InstructionInfo& instruction, u8 opcode ); std::optional parseImmediate8( const std::string& hexString ) const; std::optional parseImmediate16( const std::string& hexString ) const; ParseInfo parseLabel( const std::string& instruction ) const; ParseInfo patternScanAccumulator( const InstructionInfo& instruction ) const; ParseInfo patternScanImmediate( const InstructionInfo& instruction ) const; ParseInfo patternScanZeroPage( const InstructionInfo& instruction ) const; ParseInfo patternScanZeroPageX( const InstructionInfo& instruction ) const; ParseInfo patternScanZeroPageY( const InstructionInfo& instruction ) const; ParseInfo patternScanAbsolute( const InstructionInfo& instruction ) const; ParseInfo patternScanAbsoluteX( const InstructionInfo& instruction ) const; ParseInfo patternScanAbsoluteY( const InstructionInfo& instruction ) const; ParseInfo patternScanIndirect( const InstructionInfo& instruction ) const; ParseInfo patternScanIndirectX( const InstructionInfo& instruction ) const; ParseInfo patternScanIndirectY( const InstructionInfo& instruction ) const; ParseInfo patternScanLabel( const InstructionInfo& instruction ) const; bool __loadFromFile( const std::string& filepath ); private: int m_LastError = 0; /* Contains every line of the file */ std::vector m_Lines; /* Contains the instruction info of every line Can contain more lines than m_Lines because "LABEL: STA $44", for example, gets split into 2 lines. */ std::vector m_Instructions; /* Stores all labels. */ std::vector m_Labels; /* The generated machine code. */ std::vector m_MachineCode; /* Keeps track of any instruction that wants to jump to a label but does not know the offset yet. When the label is found this gets searched and it overwrites the appropriate bytes with the calculated offset. */ std::vector m_LabelTracker; }; } #endif // MOS_6502_ASSEMBLER_H #include #ifndef MOS_6502_UTILITY_H #define MOS_6502_UTILITY_H #include #include #include #include #include #if defined(ASSEMBLER_DEBUG) #include #include #endif namespace MOS6502::Utility { std::vector split( std::string_view sv, const std::vector& delimiters ) { std::vector tokens; std::string tmp; auto cmp = [&tmp]( std::string_view v ) { if( tmp.size() < v.size() ) return false; // Check if the last part of the string equals the delimiter return tmp.substr( tmp.size() - v.size() ) == v; }; for( auto c : sv ) { tmp += c; if( auto it = std::find_if( delimiters.begin(), delimiters.end(), cmp ); it != delimiters.end() ) { // Ignore empty strings if( tmp.size() > it->size() ) // Ignore the delimiter part of the string tokens.push_back( tmp.substr( 0, tmp.size() - it->size() ) ); tmp.clear(); } } if( !tmp.empty() ) tokens.push_back( tmp ); return tokens; } std::vector split( std::string_view sv, const std::string& delimiters ) { std::vector r; for( auto c : delimiters ) { r.push_back( std::string( 1, c ) ); } return split( sv, r ); } std::string trim( std::string s, const std::string& trimString = " \t" ) { if( auto firstNonWhiteSpaceIndex = s.find_first_not_of( trimString ); firstNonWhiteSpaceIndex != std::string::npos ) { if( firstNonWhiteSpaceIndex > 0 ) s.erase( s.begin(), s.begin() + firstNonWhiteSpaceIndex ); } else { // If the first search can't find a non whitespace then the string is empty or only contains whitespace, might as well return an empty string instead of erasing. return ""; } if( auto lastNonWhiteSpaceIndex = s.find_last_not_of( trimString ); lastNonWhiteSpaceIndex != std::string::npos ) { if( lastNonWhiteSpaceIndex + 1 != s.size() ) s.erase( lastNonWhiteSpaceIndex + 1, s.size() - lastNonWhiteSpaceIndex ); } return s; } std::string removeComment( std::string line ) { if( auto indexOfComment = line.find( ';' ); indexOfComment != std::string::npos ) { return line.erase( indexOfComment, line.size() - indexOfComment ); } return line; } char charAt( std::string_view sv, size_t index ) { return index < sv.size() ? sv[index] : 0; } std::string substr( std::string_view sv, size_t index = 0, size_t length = std::string_view::npos ) { return std::string( sv.substr( index, std::min( length, sv.size() ) ) ); } template bool isHex( It begin, It end ) { return std::find_if_not( begin, end, ::isxdigit ) == end; } template bool isValidVariable( It begin, It end ) { auto first_character_cmp = []( char c ) { return ::isalpha( c ) || c == '_'; }; auto rest_cmp = []( char c ) { return ::isalpha( c ) || ::isdigit( c ) || c == '_'; }; size_t distance = std::distance( begin, end ); if( distance == 0 || !first_character_cmp( *begin ) ) { return false; } return distance > 1 ? std::find_if_not( std::next( begin ), end, rest_cmp ) == end : true; } } #endif // MOS_6502_UTILITY_H #include #include #if defined( ASSEMBLER_DEBUG ) #include #define PUSH_FLAGS std::ios_base::fmtflags f( std::cout.flags() ) #define POP_FLAGS std::cout.flags( f ) #define HEX_FLAGS( x ) std::cout << "0x" << std::hex << std::setfill( '0' ) << std::setw( 2 ) << std::uppercase << (int)x << ' ' #define HEX_FLAGS_N( x ) std::cout << "0x" << std::hex << std::setfill( '0' ) << std::setw( 2 ) << std::uppercase << (int)x << '\n' #define HEX_FLAGS_SN( s, x ) std::cout << s << " 0x" << std::hex << std::setfill( '0' ) << std::setw( 2 ) << std::uppercase << (int)x << '\n' #define PRINT( s, x ) { PUSH_FLAGS; HEX_FLAGS_SN( s, x ); POP_FLAGS; } #endif namespace MOS6502 { Assembler::Assembler() { } bool Assembler::loadFromFile( const std::string& filepath ) { m_Lines.clear(); return __loadFromFile( filepath ); } bool Assembler::__loadFromFile( const std::string& filepath ) { std::ifstream file( filepath ); if( !file ) return false; return parseFile( file ); } bool Assembler::writeToFile( const std::string& filepath ) { std::fstream file( filepath, std::fstream::out | std::fstream::trunc | std::fstream::binary ); if( !file ) return false; constexpr size_t BufferSize = 8192; size_t remainingSize = m_MachineCode.size(); size_t currentCycle = 0; while( remainingSize > 0 ) { size_t size = remainingSize > BufferSize ? BufferSize : remainingSize; char buffer[BufferSize]; for( size_t i = 0; i < size; ++i ) { buffer[i] = m_MachineCode[i + currentCycle * size]; } if( !file.write( buffer, size ) ) return false; ++currentCycle; remainingSize -= size; } return true; } bool Assembler::parseFile( std::ifstream& file ) { using Utility::trim; using Utility::removeComment; using Utility::charAt; std::string line; size_t index = 0; while( std::getline( file, line ) ) { ++index; std::string trimmedLine = trim( removeComment( line ) ); // Just a basic include for now. %include "" must specifiy the entire path. Without a path, it will search in the bin folder instead by default if( trimmedLine.compare( 0, 8, "%include", 8 ) == 0 ) { std::string includeFileName = trim( trimmedLine.substr( 8 ) ); if( charAt( includeFileName, 0 ) == '\"' && charAt( trimmedLine, trimmedLine.size() - 1 ) == '\"' ) { includeFileName = trim( includeFileName, "\"" ); if( !__loadFromFile( includeFileName ) ) { std::cerr << "Line " << index << ": could not include " << includeFileName << '\n'; return false; } } else { std::cerr << "Line " << index << ": missing quotes in " << line << '\n'; return false; } continue; } m_Lines.push_back( trimmedLine ); } return true; } bool Assembler::assemble() { m_MachineCode.clear(); m_Labels.clear(); m_Instructions.clear(); return translateInstructions() ? generateMachineCode() : false; } bool Assembler::translateInstructions() { size_t index = 0; for( const auto& line : m_Lines ) { // Skip empty lines ++index; if( line.empty() ) { // Still increment line count tho continue; } for( const auto& i : parseLine( line, index ) ) // A line can contain multiple labels and 0 or 1 instruction { if( i.assembly == Instruction::Identifier::Undefined ) { std::cerr << "Error: \"" << line << "\" is invalid!\n"; return false; } m_Instructions.push_back( i ); } } return true; } std::vector Assembler::parseLine( std::string line, size_t index ) { using Utility::trim; using Utility::substr; std::vector instructionVector; bool repeat; do { repeat = false; std::string instruction = substr( line, 0, line.find_first_of( " \t" ) ); // Get the arguments for the instruction and remove leading and trailing whitespace for easier parsing auto arguments = parseArguments( trim( line.substr( instruction.size() ) ) ); InstructionInfo info; info.assembly = parseInstruction( instruction, index ); info.line = line; info.index = index; if( info.assembly == Instruction::Identifier::Label ) { if( !arguments.empty() ) // Remove the arguments from the label and move it back into the line for another pass { line = std::move( arguments[0] ); arguments.clear(); repeat = true; } } info.assembly.setArguments( arguments ); instructionVector.push_back( info ); }while( repeat ); return instructionVector; } auto Assembler::parseInstruction( const std::string& instruction, size_t index ) -> Instruction { using Utility::trim; using Utility::substr; if( auto info = parseLabel( instruction ); info.valid ) { info.label.index = index; if( std::find_if( m_Labels.begin(), m_Labels.end(), [&info]( const Label& other ) { return other.text == info.label.text; } ) == m_Labels.end() ) { m_Labels.push_back( info.label ); return Instruction( Instruction::Identifier::Label, info.label.text ); } else { m_LastError = 1; std::cerr << "Label \"" << info.label.text << "\" already exists!\n"; return Instruction(); } } return Instruction( instruction ); } std::vector Assembler::parseArguments( const std::string& arguments ) const { using Utility::split; using Utility::trim; std::vector r; if( !arguments.empty() ) { for( const auto& i : split( arguments, "," ) ) { r.emplace_back( trim( i ) ); } } return r; } auto Assembler::parseLabel( const std::string& instruction ) const -> ParseInfo { using Utility::isValidVariable; using Utility::charAt; using Utility::substr; ParseInfo info; info.valid = false; if( instruction.size() > 1 && charAt( instruction, instruction.size() - 1 ) == ':' && isValidVariable( instruction.begin(), instruction.end() - 1 ) ) { // Check if the label is a keyword std::string labelWithoutColon = substr( instruction, 0, instruction.size() - 1 ); if( !Instruction::isInstruction( labelWithoutColon ) ) { // Not a keyword info.valid = true; info.label.text = labelWithoutColon; info.label.offset = -1; } } return info; } auto Assembler::patternScanAccumulator( const InstructionInfo& instruction ) const -> ParseInfo { using Utility::substr; using Utility::charAt; ParseInfo info; info.valid = false; const auto& args = instruction.assembly.getArguments(); if( ( args.size() == 1 && charAt( args[0], 0 ) == 'A' ) || args.empty() ) // Implied 'A' if args is empty { // Valid instruction info.valid = true; } return info; } auto Assembler::patternScanImmediate( const InstructionInfo& instruction ) const -> ParseInfo { using Utility::substr; using Utility::charAt; ParseInfo info; info.valid = false; const auto& args = instruction.assembly.getArguments(); if( args.size() == 1 && substr( args[0], 0, 2 ) == "#$" && args[0].size() <= 4 ) { if( auto opt = parseImmediate8( substr( args[0], 2 ) ); opt.has_value() ) { // Valid immediate info.variant = opt.value(); info.valid = true; } } return info; } auto Assembler::patternScanZeroPage( const InstructionInfo& instruction ) const -> ParseInfo { using Utility::substr; using Utility::charAt; ParseInfo info; info.valid = false; const auto& args = instruction.assembly.getArguments(); if( args.size() == 1 && charAt( args[0], 0 ) == '$' && args[0].size() <= 3 ) { if( auto opt = parseImmediate8( substr( args[0], 1 ) ); opt.has_value() ) { // Valid immediate info.variant = opt.value(); info.valid = true; } } return info; } auto Assembler::patternScanZeroPageX( const InstructionInfo& instruction ) const -> ParseInfo { using Utility::substr; using Utility::charAt; ParseInfo info; info.valid = false; const auto& args = instruction.assembly.getArguments(); if( args.size() == 2 && charAt( args[0], 0 ) == '$' && ::toupper( charAt( args[1], 0 ) ) == 'X' && args[0].size() <= 3 && args[1].size() == 1 ) { if( auto opt = parseImmediate8( substr( args[0], 1 ) ); opt.has_value() ) { // Valid immediate info.variant = opt.value(); info.valid = true; } } return info; } auto Assembler::patternScanZeroPageY( const InstructionInfo& instruction ) const -> ParseInfo { using Utility::substr; using Utility::charAt; ParseInfo info; info.valid = false; const auto& args = instruction.assembly.getArguments(); if( args.size() == 2 && charAt( args[0], 0 ) == '$' && ::toupper( charAt( args[1], 0 ) ) == 'Y' && args[0].size() == 3 && args[1].size() == 1 ) { if( auto opt = parseImmediate8( substr( args[0], 1 ) ); opt.has_value() ) { // Valid immediate info.variant = opt.value(); info.valid = true; } } return info; } auto Assembler::patternScanAbsolute( const InstructionInfo& instruction ) const -> ParseInfo { using Utility::substr; using Utility::charAt; ParseInfo info; info.valid = false; const auto& args = instruction.assembly.getArguments(); if( args.size() == 1 && charAt( args[0], 0 ) == '$' && args[0].size() <= 5 ) { if( auto opt = parseImmediate16( substr( args[0], 1 ) ); opt.has_value() ) { // Valid immediate info.variant = opt.value(); info.valid = true; } } return info; } auto Assembler::patternScanAbsoluteX( const InstructionInfo& instruction ) const -> ParseInfo { using Utility::substr; using Utility::charAt; ParseInfo info; info.valid = false; const auto& args = instruction.assembly.getArguments(); if( args.size() == 2 && charAt( args[0], 0 ) == '$' && ::toupper( charAt( args[1], 0 ) ) == 'X' && args[0].size() <= 5 && args[1].size() == 1 ) { if( auto opt = parseImmediate16( substr( args[0], 1 ) ); opt.has_value() ) { // Valid immediate info.variant = opt.value(); info.valid = true; } } return info; } auto Assembler::patternScanAbsoluteY( const InstructionInfo& instruction ) const -> ParseInfo { using Utility::substr; using Utility::charAt; ParseInfo info; info.valid = false; const auto& args = instruction.assembly.getArguments(); if( args.size() == 2 && charAt( args[0], 0 ) == '$' && ::toupper( charAt( args[1], 0 ) ) == 'Y' && args[0].size() <= 5 && args[1].size() == 1 ) { if( auto opt = parseImmediate16( substr( args[0], 1 ) ); opt.has_value() ) { // Valid immediate info.variant = opt.value(); info.valid = true; } } return info; } auto Assembler::patternScanIndirect( const InstructionInfo& instruction ) const -> ParseInfo { using Utility::substr; using Utility::charAt; ParseInfo info; info.valid = false; const auto& args = instruction.assembly.getArguments(); if( args.size() == 1 && substr( args[0], 0, 2 ) == "($" && charAt( args[0], args[0].size() - 1 ) == ')' && args[0].size() == 7 ) { if( auto opt = parseImmediate16( substr( args[0], 2, 4 ) ); opt.has_value() ) { // Valid immediate info.variant = opt.value(); info.valid = true; } } return info; } auto Assembler::patternScanIndirectX( const InstructionInfo& instruction ) const -> ParseInfo { using Utility::substr; ParseInfo info; info.valid = false; const auto& args = instruction.assembly.getArguments(); if( args.size() == 2 && substr( args[0], 0, 2 ) == "($" && (args[1] == "X)" || args[1] == "x)") && substr( args[0], 2 ).size() <= 2 && args[1].size() == 2 ) // Yes, I know, we already know the size is 2 because of the "X)" check above already. But sometimes I like to play it safe :) { if( auto opt = parseImmediate8( substr( args[0], 2 ) ); opt.has_value() ) { // Valid immediate info.variant = opt.value(); info.valid = true; } } return info; } auto Assembler::patternScanIndirectY( const InstructionInfo& instruction ) const -> ParseInfo { using Utility::substr; using Utility::charAt; ParseInfo info; info.valid = false; const auto& args = instruction.assembly.getArguments(); if( args.size() == 2 && substr( args[0], 0, 2 ) == "($" && ( charAt( args[0], 3 ) == ')' || charAt( args[0], 4 ) == ')' ) && // If the immediate has only 1 character the ')' will be at position 3, 4 otherwise. ::toupper( charAt( args[1], 0 ) ) == 'Y' && args[0].size() <= 5 && args[1].size() == 1 ) { size_t size = args[0].size() == 5 ? 2 : 1; // Similarly if the length is 4 then there is only 1 digit, if the length is 5 there are 2 digits. Other lengths shouldn't reach this point if( auto opt = parseImmediate8( substr( args[0], 2, size ) ); opt.has_value() ) { // Valid immediate info.variant = opt.value(); info.valid = true; } } return info; } auto Assembler::patternScanLabel( const InstructionInfo& instruction ) const -> ParseInfo { using Utility::substr; using Utility::charAt; using Utility::isValidVariable; ParseInfo info; info.valid = false; const auto& args = instruction.assembly.getArguments(); if( args.size() == 1 && isValidVariable( args[0].begin(), args[0].end() ) ) { if( auto it = std::find_if( m_Labels.begin(), m_Labels.end(), [&args]( const Label& label ) { return label.text == args[0]; } ); it != m_Labels.end() ) { // Found label info.label = *it; info.variant = it->offset; info.valid = true; } else { // Label doesn't exist return info; } } return info; } std::optional Assembler::parseImmediate8( const std::string& hexString ) const { using Utility::isHex; if( hexString.empty() || !isHex( hexString.begin(), hexString.end() ) || hexString.size() > 2 ) return std::optional(); return stoi( hexString, nullptr, 16 ); } std::optional Assembler::parseImmediate16( const std::string& hexString ) const { using Utility::isHex; if( hexString.empty() || !isHex( hexString.begin(), hexString.end() ) || hexString.size() > 4 ) return std::optional(); return stoi( hexString, nullptr, 16 ); } void Assembler::pushToAssembly( u8 opcode ) { m_MachineCode.push_back( opcode ); } void Assembler::pushToAssembly( u8 opcode, u8 byte ) { m_MachineCode.push_back( opcode ); m_MachineCode.push_back( byte ); } void Assembler::pushToAssembly( u8 opcode, u16 word ) { m_MachineCode.push_back( opcode ); m_MachineCode.push_back( word & 0xFF ); m_MachineCode.push_back( ( word & 0xFF00 ) >> 8 ); } auto Assembler::scanAll( const InstructionInfo& instruction ) -> ScanInfo { ScanInfo info; info.mode = AddressingMode::Undefined; info.valid = false; Instruction::Addressing opcodes = instruction.assembly.getOpcodes(); if( opcodes.implied.has_value() ) { pushToAssembly( opcodes.implied.value() ); info.mode = AddressingMode::Implied; info.valid = true; return info; } if( opcodes.accumulator.has_value() ) { if( auto parse = patternScanAccumulator( instruction ); parse.valid ) { pushToAssembly( opcodes.accumulator.value() ); info.mode = AddressingMode::Accumulator; info.valid = true; return info; } } if( opcodes.immediate.has_value() ) { if( auto parse = patternScanImmediate( instruction ); parse.valid ) { u8 byte = std::get<0>( parse.variant ); pushToAssembly( opcodes.immediate.value(), byte ); info.mode = AddressingMode::Immediate; info.valid = true; return info; } } if( opcodes.zeroPage.has_value() ) { if( auto parse = patternScanZeroPage( instruction ); parse.valid ) { u8 byte = std::get<0>( parse.variant ); pushToAssembly( opcodes.zeroPage.value(), byte ); info.mode = AddressingMode::ZeroPage; info.valid = true; return info; } } if( opcodes.zeroPageX.has_value() ) { if( auto parse = patternScanZeroPageX( instruction ); parse.valid ) { u8 byte = std::get<0>( parse.variant ); pushToAssembly( opcodes.zeroPageX.value(), byte ); info.mode = AddressingMode::ZeroPageX; info.valid = true; return info; } } if( opcodes.zeroPageY.has_value() ) { if( auto parse = patternScanZeroPageY( instruction ); parse.valid ) { u8 byte = std::get<0>( parse.variant ); pushToAssembly( opcodes.zeroPageY.value(), byte ); info.mode = AddressingMode::ZeroPageY; info.valid = true; return info; } } if( opcodes.absolute.has_value() ) { if( auto parse = patternScanAbsolute( instruction ); parse.valid ) { u16 word = std::get<1>( parse.variant ); pushToAssembly( opcodes.absolute.value(), word ); info.mode = AddressingMode::Absolute; info.valid = true; return info; } else if( instruction.assembly == Instruction::Identifier::JMP || instruction.assembly == Instruction::Identifier::JSR ) { // Special case for JMP and JSR if( translateLabel( instruction, opcodes.absolute.value() ).written ) { info.mode = AddressingMode::Absolute; info.valid = true; return info; } } } if( opcodes.absoluteX.has_value() ) { if( auto parse = patternScanAbsoluteX( instruction ); parse.valid ) { u16 word = std::get<1>( parse.variant ); pushToAssembly( opcodes.absoluteX.value(), word ); info.mode = AddressingMode::AbsoluteX; info.valid = true; return info; } } if( opcodes.absoluteY.has_value() ) { if( auto parse = patternScanAbsoluteY( instruction ); parse.valid ) { u16 word = std::get<1>( parse.variant ); pushToAssembly( opcodes.absoluteY.value(), word ); info.mode = AddressingMode::AbsoluteY; info.valid = true; return info; } } if( opcodes.indirect.has_value() ) { if( auto parse = patternScanIndirect( instruction ); parse.valid ) { u16 word = std::get<1>( parse.variant ); pushToAssembly( opcodes.indirect.value(), word ); info.mode = AddressingMode::Indirect; info.valid = true; return info; } } if( opcodes.indirectX.has_value() ) { if( auto parse = patternScanIndirectX( instruction ); parse.valid ) { u8 word = std::get<0>( parse.variant ); pushToAssembly( opcodes.indirectX.value(), word ); info.mode = AddressingMode::IndirectX; info.valid = true; return info; } } if( opcodes.indirectY.has_value() ) { if( auto parse = patternScanIndirectY( instruction ); parse.valid ) { u8 word = std::get<0>( parse.variant ); pushToAssembly( opcodes.indirectY.value(), word ); info.mode = AddressingMode::IndirectY; info.valid = true; return info; } } if( opcodes.relative.has_value() ) { if( translateLabel( instruction, opcodes.relative.value() ).written ) { info.mode = AddressingMode::Relative; info.valid = true; return info; } else { // BCS $74 is not a zero page but it has the same pattern, so might as well reuse it if( auto parse = patternScanZeroPage( instruction ); parse.valid ) { u8 word = std::get<0>( parse.variant ); pushToAssembly( opcodes.relative.value(), word ); info.mode = AddressingMode::Relative; info.valid = true; return info; } } } return info; } auto Assembler::translateLabel( const InstructionInfo& instruction, u8 opcode ) -> LabelTranslateInfo { LabelTranslateInfo info; info.written = false; if( auto labelScan = patternScanLabel( instruction ); labelScan.valid ) { size_t offset = labelScan.label.offset; // Label has been found already so we can calculate the offset if( instruction.assembly == Instruction::Identifier::JMP || instruction.assembly == Instruction::Identifier::JSR ) { // JMP uses a 16 bit absolute address if( offset != -1ull ) { u16 absolute = static_cast( offset ); pushToAssembly( opcode, absolute ); info.written = true; } else { LabelTracker tracker; tracker.label = labelScan.label; tracker.opcodeIndex = m_MachineCode.size(); tracker.mode = AddressingMode::Absolute; m_LabelTracker.push_back( tracker ); pushToAssembly( opcode, static_cast( 0x0000 ) ); info.written = true; } } else if( instruction.assembly == Instruction::Identifier::BPL || instruction.assembly == Instruction::Identifier::BMI || instruction.assembly == Instruction::Identifier::BVC || instruction.assembly == Instruction::Identifier::BVS || instruction.assembly == Instruction::Identifier::BCC || instruction.assembly == Instruction::Identifier::BCS || instruction.assembly == Instruction::Identifier::BNE || instruction.assembly == Instruction::Identifier::BEQ ) { // These jumps are relative offsets if( offset != -1ull ) { u8 relative = ( static_cast( offset ) - static_cast( m_MachineCode.size() ) ) - 2; pushToAssembly( opcode, relative ); info.written = true; } else { LabelTracker tracker; tracker.label = labelScan.label; tracker.opcodeIndex = m_MachineCode.size(); tracker.mode = AddressingMode::Relative; m_LabelTracker.push_back( tracker ); pushToAssembly( opcode, static_cast( 0x00 ) ); info.written = true; } } } return info; } int Assembler::generateInstruction( const InstructionInfo& instruction ) { ScanInfo info = scanAll( instruction ); if( !info.valid ) { #if defined( ASSEMBLER_DEBUG ) std::cerr << "Invalid instruction on line " << instruction.index << ": " << instruction.line << " Adressing mode: " << static_cast( info.mode ) << '\n'; #else std::cerr << "Invalid instruction on line " << instruction.index << ": " << instruction.line << '\n'; #endif } return !info.valid; } bool Assembler::generateMachineCode() { int error = 0; for( auto& instruction : m_Instructions ) { switch( instruction.assembly.getId() ) { case Instruction::Identifier::Label: { if( auto it = std::find_if( m_Labels.begin(), m_Labels.end(), [&instruction]( Label& label ) { return instruction.assembly.getText() == label.text; } ); it != m_Labels.end() ) { // If a label is found, write its offset into the machine code to its struct for later use it->offset = m_MachineCode.size(); } // Check if there are instructions that jump to the label // These previous instructions don't have a valid jump yet because they didn't know the offset of the label // But they do know the label exists or the program would have stopped much earlier. for( const auto& i : m_LabelTracker ) { if( instruction.assembly.getText() == i.label.text ) { if( i.mode == AddressingMode::Absolute ) { // JMP requires a 16 bit address, little endian m_MachineCode[i.opcodeIndex + 1] = m_MachineCode.size() & 0xFF; m_MachineCode[i.opcodeIndex + 2] = (m_MachineCode.size() & 0xFF00) >> 8; } else if( i.mode == AddressingMode::Relative ) { // TODO: Probably should stop compilation if the distance is bigger than 127 bytes? // Because its most likely unintended. m_MachineCode[i.opcodeIndex + 1] = static_cast( m_MachineCode.size() ) - static_cast( i.opcodeIndex ) - 2; } else { // Shouldn't reach this point. // Only branch and the JMP instructions can jump and they are Relative and Absolute respectively. assert( false ); } } } break; } case Instruction::Identifier::Undefined: return false; default: { error = generateInstruction( instruction ); } } if( error ) return false; } return true; } #if defined( ASSEMBLER_DEBUG ) void Assembler::debug() { size_t index = 0; for( const auto& line : m_Lines ) { std::cout << index + 1 << ": " << line << '\n'; ++index; } index = 0; for( const auto& instruction : m_Instructions ) { std::cout << index + 1 << ": " << instruction.assembly.getText() << " ID: " << static_cast( instruction.assembly.getId() ) << '\n'; size_t argSize = instruction.assembly.getArguments().size(); size_t current = 0; if( argSize > 0 ) { std::cout << "Arg size: " << argSize << " Args: "; for( const auto& arguments : instruction.assembly.getArguments() ) { std::cout << arguments; ++current; if( current != argSize ) std::cout << ", "; } std::cout << '\n'; } std::cout << '\n'; ++index; } PUSH_FLAGS; for( auto i : m_MachineCode ) { HEX_FLAGS( i ); } std::cout << '\n'; POP_FLAGS; } #endif } #ifndef NES_MEMORY_H #define NES_MEMORY_H #ifndef NES_DEFINES_H #define NES_DEFINES_H #include namespace NES_Emulator { size_t g_MaxOpcodes = 0; using u8 = uint8_t; using s8 = int8_t; using u16 = uint16_t; using s16 = int16_t; namespace Constants { constexpr size_t ScreenWidth = 280; constexpr size_t ScreenHeight = 240; constexpr size_t MemorySize = 0x10000; constexpr u8 DefaultMemory = 0xEA; } } #endif // NES_DEFINES_H #include #include namespace NES_Emulator { class Memory { public: explicit Memory(); bool loadFromFile( std::ifstream& file ); void initialize(); u8 readMemory( u16 address ) const; void writeMemory( u16 address, u8 byte ); u16 readWord( u16 address ) const; private: std::unique_ptr m_Memory; }; } #endif // NES_MEMORY_H #include #ifdef NES_DEBUG #include #include #include #endif namespace NES_Emulator { Memory::Memory() : m_Memory( new u8[Constants::MemorySize] ) { } bool Memory::loadFromFile( std::ifstream& file ) { initialize(); // file.read( reinterpret_cast( &m_Memory[0x8000] ), 32768 ); file.read( reinterpret_cast( &m_Memory[0] ), 32768 ); if( char c; file >> c ) { std::cerr << "Warning: There are still some unread bytes left"; } return true; } void Memory::initialize() { memset( &m_Memory[0], Constants::DefaultMemory, Constants::MemorySize ); } u8 Memory::readMemory( u16 address ) const { return m_Memory[address]; } void Memory::writeMemory( u16 address, u8 byte ) { m_Memory[address] = byte; } u16 Memory::readWord( u16 address ) const { u8 lo = readMemory( address ); u8 hi = readMemory( address + 1 ); return static_cast( hi ) << 8 | lo; } } #ifndef NES_PROCESSOR_H #define NES_PROCESSOR_H #ifdef NES_DEBUG #include #include #endif namespace NES_Emulator { class Memory; class Processor { private: enum class Flag : u8 { Negative = 7, // N (1 when result is negative) Overflow = 6, // V (1 on signed overflow) Unused = 5, // . (always 1) Break = 4, // B (1 when interupt was caused by a BRK) Decimal = 3, // D (1 when CPU in BCD mode) Interrupt = 2, // I (when 1, no interupts will occur (exceptions are IRQs forced by BRK and NMIs)) Zero = 1, // Z (1 when all bits of a result are 0) Carry = 0, // C (1 on unsigned overflow) }; public: explicit Processor( Memory*& memory ); void initialize(); void update(); bool ready() const { return m_CompletedFrame; } void nextFrame(){ m_CompletedFrame = false; } private: void setFlag( Flag flag ); void resetFlag( Flag flag ); void setFlagIf( Flag flag, bool cc ); bool isFlagSet( Flag flag ) const; void fetchOpcode(); void executeOpcode( u8 opcode ); bool isPageCross( u8 lhs, u8 rhs ) const; void pushToStack( u8 byte ); void pushToStack( u16 word ); void popFromStack( u8& byte ); void popFromStack( u16& word ); #ifdef NES_DEBUG void printDebugInfo() const; struct OpcodeInfo { std::optional opcode; }; #endif private: void ADC( u8 byte ); void AND( u8 byte ); void ASL( u8& byte ); void BIT( u8 byte ); void LDA( u8 byte ); void LDX( u8 byte ); void LDY( u8 byte ); void LSR( u8& byte ); void STA( u8& byte ); void STX( u8& byte ); void STY( u8& byte ); void JSR( u16 word ); void RTI(); void RTS(); void INC( u8& byte ); void DEC( u8& byte ); void ORA( u8 byte ); void EOR( u8 byte ); void ROL( u8& byte ); void ROR( u8& byte ); void CMP( u8 byte ); void CPX( u8 byte ); void CPY( u8 byte ); void SBC( u8 byte ); private: Memory*& m_Memory; u8 m_Flags; u8 m_A; u8 m_X; u8 m_Y; u16 m_IP; u8 m_SP; int m_CycleCount; bool m_CompletedFrame; #ifdef NES_DEBUG OpcodeInfo m_LastExecutedOpcode; #endif }; } #endif // NES_PROCESSOR_H #include #include namespace NES_Emulator { Processor::Processor( Memory*& memory ) : m_Memory( memory ) { } void Processor::initialize() { m_Flags = 0b00110100; m_A = 0; m_X = 0; m_Y = 0; m_IP = 0; m_SP = 0xFD; m_Memory->writeMemory( 0x4015, 0x00 ); m_Memory->writeMemory( 0x4017, 0x00 ); m_CycleCount = 0; for( u8 i = 0; i <= 0x0F; ++i ) m_Memory->writeMemory( 0x4000 + i, 0x00 ); } void Processor::update() { #ifdef NES_DEBUG printDebugInfo(); #endif fetchOpcode(); } void Processor::setFlagIf( Flag flag, bool cc ) { if( cc ) setFlag( flag ); else resetFlag( flag ); } void Processor::setFlag( Flag flag ) { m_Flags |= 1 << static_cast( flag ); } void Processor::resetFlag( Flag flag ) { m_Flags &= ~( 1 << static_cast( flag ) ); } bool Processor::isFlagSet( Flag flag ) const { return m_Flags & ( 1 << static_cast( flag ) ); } bool Processor::isPageCross( u8 lhs, u8 rhs ) const { return static_cast( lhs ) + rhs > 0xFF; } void Processor::pushToStack( u8 byte ) { m_Memory->writeMemory( 0x0100 | --m_SP, byte ); } void Processor::pushToStack( u16 word ) { m_Memory->writeMemory( 0x0100 | --m_SP, word >> 8 ); m_Memory->writeMemory( 0x0100 | --m_SP, word & 0xFF ); } void Processor::popFromStack( u8& byte ) { byte = m_Memory->readMemory( 0x0100 | m_SP++ ); } void Processor::popFromStack( u16& word ) { u8 lo = m_Memory->readMemory( 0x0100 | m_SP++ ); u8 hi = m_Memory->readMemory( 0x0100 | m_SP++ ); word = static_cast( hi ) << 8 | lo; } void Processor::fetchOpcode() { //BEGIN_BENCHMARK; <-- macro not defined in this demo u8 opcode = m_Memory->readMemory( m_IP++ ); executeOpcode( opcode ); //END_BENCHMARK; <-- macro not defined in this demo #ifdef NES_DEBUG m_LastExecutedOpcode.opcode = opcode; #endif } #ifdef NES_DEBUG void Processor::printDebugInfo() const { std::ios_base::fmtflags f( std::cout.flags() ); std::cout << std::hex << "A: 0x" << std::setfill( '0' ) << std::setw( 2 ) << (int)m_A << " " << "X: 0x" << std::setfill( '0' ) << std::setw( 2 ) << (int)m_X << " " << "Y: 0x" << std::setfill( '0' ) << std::setw( 2 ) << (int)m_Y << " " << "IP: 0x" << std::setfill( '0' ) << std::setw( 4 ) << (int)m_IP << " " << "SP: 0x" << std::setfill( '0' ) << std::setw( 2 ) << (int)m_SP << " " << "Flags: 0x" << std::setfill( '0' ) << std::setw( 2 ) << (int)m_Flags << "\n" << "Negative flag: " << ( isFlagSet( Flag::Negative ) ? "set\n" : "clear\n" ) << "Overflow flag: " << ( isFlagSet( Flag::Overflow ) ? "set\n" : "clear\n" ) << "Break flag: " << ( isFlagSet( Flag::Break ) ? "set\n" : "clear\n" ) << "Decimal flag: " << ( isFlagSet( Flag::Decimal ) ? "set\n" : "clear\n" ) << "Interrupt flag: " << ( isFlagSet( Flag::Interrupt ) ? "set\n" : "clear\n" ) << "Zero flag: " << ( isFlagSet( Flag::Zero ) ? "set\n" : "clear\n" ) << "Carry flag: " << ( isFlagSet( Flag::Carry ) ? "set\n" : "clear\n" ) << '\n'; if( m_LastExecutedOpcode.opcode.has_value() ) std::cout << "Last executed opcode: 0x" << std::setfill( '0' ) << std::setw( 2 ) << (int)m_LastExecutedOpcode.opcode.value() << "\n" << std::endl; else std::cout << "Last executed opcode: N/A\n" << std::endl; std::cout.flags( f ); } #endif void Processor::ADC( u8 byte ) // ADd with Carry { bool carry = isFlagSet( Flag::Carry ); u16 value = m_A + byte + carry; setFlagIf( Flag::Negative, value & 0x80 ); setFlagIf( Flag::Zero, ( value & 0xFF ) == 0 ); setFlagIf( Flag::Carry, value > 0xFF ); setFlagIf( Flag::Overflow, ~( m_A ^ byte ) & ( m_A ^ value ) & 0x80 ); m_A = value & 0xFF; } void Processor::LDA( u8 byte ) // LoaD Accumulator { m_A = byte; setFlagIf( Flag::Negative, m_A & 0x80 ); setFlagIf( Flag::Zero, m_A == 0 ); } void Processor::LDX( u8 byte ) // LoaD X register { m_X = byte; setFlagIf( Flag::Negative, m_X & 0x80 ); setFlagIf( Flag::Zero, m_X == 0 ); } void Processor::LDY( u8 byte ) // Load Y Register { m_Y = byte; setFlagIf( Flag::Negative, m_Y & 0x80 ); setFlagIf( Flag::Zero, m_Y == 0 ); } void Processor::STA( u8& byte ) // STore Accumulator { byte = m_A; } void Processor::STX( u8& byte ) // STore X register { byte = m_X; } void Processor::STY( u8& byte ) // STore Y register { byte = m_Y; } void Processor::JSR( u16 word ) // Jump to SubRoutine { pushToStack( static_cast( m_IP - 1 ) ); m_IP = word; } void Processor::RTS() // ReTurn from Subroutine { popFromStack( m_IP ); ++m_IP; } #if defined( __GNUC__ ) || defined( __MINGW32__ ) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wpedantic" /// Disabling -Wpedantic for this next function because it'll generate 257 "warning: taking the address of a label is non-standard [-Wpedantic]" otherwise /// Computed goto's are non standard C++, but they are faster than a switch. /// Every bit counts :) // Not using computed goto's in this demo because I can't fill the entire table from 0 to 255 with only a few opcodes available #endif void Processor::executeOpcode( u8 opcode ) { switch( opcode ) { case 0x18: // CLC { resetFlag( Flag::Carry ); m_CycleCount += 2; break; } case 0x20: // JSR aaaa { u16 word = m_Memory->readWord( m_IP ); m_IP += 2; JSR( word ); m_CycleCount += 6; break; } case 0x4C: // JMP aaaa { u16 word = m_Memory->readWord( m_IP ); m_IP = word; m_CycleCount += 3; break; } case 0x60: // RTS { RTS(); m_CycleCount += 6; break; } case 0x65: // ADC aa { u8 byte = m_Memory->readMemory( m_IP++ ); ADC( m_Memory->readMemory( 0x0000 | byte ) ); m_CycleCount += 3; break; } case 0x84: // STY aa { u8 address = m_Memory->readMemory( m_IP++ ); u8 byte = 0; STY( byte ); m_Memory->writeMemory( address, byte ); m_CycleCount += 3; break; } case 0x86: // STX aa { u8 address = m_Memory->readMemory( m_IP++ ); u8 byte = 0; STX( byte ); m_Memory->writeMemory( address, byte ); m_CycleCount += 3; break; } case 0xA0: // LDY #aa { u8 byte = m_Memory->readMemory( m_IP++ ); LDY( byte ); m_CycleCount += 2; break; } case 0xA2: // LDX #aa { u8 byte = m_Memory->readMemory( m_IP++ ); LDX( byte ); m_CycleCount += 2; break; } case 0xA9: // LDA #aa { u8 byte = m_Memory->readMemory( m_IP++ ); LDA( byte ); m_CycleCount += 2; break; } case 0xEA: // NOP { m_CycleCount += 2; break; } default: { std::cerr << "0x" << std::hex << std::setfill( '0' ) << std::setw( 2 ) << (int)opcode << " is an unsupported opcode in this demo\n"; } } } #if defined( __GNUC__ ) || defined( __MINGW32__ ) #pragma GCC diagnostic pop #endif } #ifndef NES_APPLICATION_H #define NES_APPLICATION_H // #include #include namespace NES_Emulator { class Memory; class Processor; class Graphics; class Application { public: explicit Application(); int run(); bool loadFromFile( const std::string& filepath ); private: void handleEvents(); void update(); void render(); private: Memory* m_Memory; Processor* m_Processor; Graphics* m_Graphics; // sf::RenderWindow m_RenderWindow; }; } #endif // NES_APPLICATION_H #include #ifdef NES_DEBUG #include #endif namespace NES_Emulator { Application::Application() : m_Memory( new Memory ) , m_Processor( new Processor( m_Memory ) ) // , m_Graphics( new Graphics( m_Memory ) ) //, m_RenderWindow( sf::VideoMode( Constants::ScreenWidth, Constants::ScreenHeight ), "NES Emulator" ) { //BEGIN_BENCHMARK; //END_BENCHMARK; } int Application::run() { //sf::Clock clock; m_Processor->initialize(); //while( m_RenderWindow.isOpen() ) while( g_MaxOpcodes-- > 0 ) { // BEGIN_BENCHMARK; handleEvents(); update(); render(); // float framerate = 1.f / clock.restart().asSeconds(); // std::cout << "FPS: " << framerate << '\r'; // END_BENCHMARK; #ifdef NES_DEBUG /* if( g_DebugWindow.m_RenderWindow.isOpen() ) { g_DebugWindow.handleEvents(); g_DebugWindow.update(); g_DebugWindow.render(); } */ #endif } return 0; } bool Application::loadFromFile( const std::string& filepath ) { std::ifstream file( filepath, std::ifstream::binary ); if( !file || !m_Memory->loadFromFile( file ) ) { return false; } return true; } void Application::handleEvents() { //BEGIN_BENCHMARK; /* sf::Event event; while( m_RenderWindow.pollEvent( event ) ) { if( event.type == sf::Event::Closed ) { m_RenderWindow.close(); } #ifdef NES_DEBUG if( event.type == sf::Event::KeyPressed ) { if( event.key.code == sf::Keyboard::Key::F3 ) { g_NextStep = true; } } #endif } */ // END_BENCHMARK; } void Application::update() { //BEGIN_BENCHMARK; m_Processor->update(); // m_Graphics ->update(); //END_BENCHMARK; } void Application::render() { //BEGIN_BENCHMARK; /* m_RenderWindow.clear(); m_RenderWindow.draw( *m_Graphics ); m_RenderWindow.display(); m_Processor->nextFrame(); */ //END_BENCHMARK; } } int main() { { std::ofstream file( "Assembly.asm" ); if( !file ) { std::cerr << "Failed to open file\n"; return 1; } file << g_Program; } MOS6502::Assembler assembler; if( !assembler.loadFromFile( "Assembly.asm" ) ) { std::cerr << "Failed to open file\n"; return 2; } if( !assembler.assemble() ) { std::cerr << "Failed to assemble\n"; return 3; } #ifdef ASSEMBLER_DEBUG assembler.debug(); #endif assembler.writeToFile( "Assembly.bin" ); std::vector machineCode; { std::ifstream file( "Assembly.bin" ); if( !file ) { std::cerr << "Failed to open file\n"; return 4; } MOS6502::u8 c; while( file.read( reinterpret_cast( &c ), 1 ) ) { machineCode.push_back( c ); } } NES_Emulator::g_MaxOpcodes = 13; std::cout << "Program assembly:\n\n" << g_Program << "\n" << "Generated machine code:\n"; size_t index = 0; for( auto i : machineCode ) { if( index != 0 && index % 10 == 0 ) std::cout << "-\n"; std::cout << "0x" << std::hex << std::setfill( '0' ) << std::setw( 2 ) << (int)i << ' '; ++index; } std::cout << "\n\nNES Emulator:\n\n"; NES_Emulator::Application app; if( !app.loadFromFile( "Assembly.bin" ) ) { std::cerr << "Failed to open file\n"; return 5; } return app.run(); }

6502 Assembler and NES Emu demo