//================================================ // // Very Simple Virtual Machine. // v.0.1.1. // // You can see how low-level programs work // (very simplistic). // // VSVM is a virtual machine with four 8-bit // general-purpose registers, one instruction // register and 256 bytes of RAM. // // *********************************************** // Leave the input box empty to load and run // a test program (cTestAsm in main()). // *********************************************** // // Or you can input your own program on asm-like // language. // // eg: // mov al, 5; // mov bl, 10; // add al, bl; // xor al, al; // int EXIT; // // ';' needs because Code Playground user input // constraints. Then parser deletes it. // // Use lowercase except for "int EXIT" // and "int TEXT". // Use decimal values in code (and for address) // -- I will add hex later. // VSVM output uses hex. // // Other semantics and opcodes see in code. // // This is the first rough version. // I think I'll make code better, // sometime later... // // For better view on mobile devices I wrote code // more width-compact (but then I found it // impossible for C++). // // Copyright © 2017 sam0delk1n. // //================================================ #include #include #include #include #include #include #include using namespace std; namespace vsvm { //================================================ // General-purpose registers. enum RegCode_t : uint8_t { REG_AL, // al REG_CL, // cl REG_DL, // dl REG_BL // bl }; //================================================ // VSVM OpCodes. enum OpCode_t : uint8_t { OPC_NOP, // No operation. OPC_ADD_RR, // Add value from register and register (result store into first register). OPC_ADD_RV, // Add reg. and value. OPC_MOV_RR, // Move from second reg. into first reg. OPC_MOV_RV, // Move val. into reg. OPC_MOV_RM, // Move val. from memory (by address) into register. OPC_MOV_MR, // Move from register into memory. OPC_MOV_MV, // Move val. into memory. OPC_XOR_RR, // Xor reg. and reg. OPC_XOR_RV, // Xor reg. and val. OPC_INT_TEXT, // Output text by address up to null terminator. OPC_INT_EXIT // Shutdown VSVM (end of program). }; //================================================ // Exception //================================================ //================================================ class except_c final : public exception { public: inline const char* what( void ) const noexcept override; inline except_c& operator=( const except_c& ex ) noexcept; inline explicit except_c( const string& cWhat ) noexcept; inline except_c( const except_c& ex ) noexcept; inline ~except_c( void ) = default; private: string mWhat; }; //================================================ inline except_c& except_c::operator=( const except_c& ex ) noexcept { exception::operator=( ex ); mWhat = ex.mWhat; } //================================================ inline except_c::except_c( const string& cWhat ) noexcept : mWhat( cWhat ) {} //================================================ inline except_c::except_c( const except_c& ex ) noexcept : exception( ex ), mWhat( ex.mWhat ) {} //================================================ inline const char* except_c::what( void ) const noexcept { return mWhat.c_str(); } //================================================ // Translator //================================================ //================================================ class trans_c final { public: inline const string& mcGetIn( void ) const noexcept; inline const vector< unsigned char >& mcGetOut( void ) const noexcept; void mTranslate( void ); trans_c& operator=( const trans_c& ) = delete; explicit trans_c( const string& cIn ); trans_c( const trans_c& ) = delete; ~trans_c( void ) = default; private: const string mcIn; vector< unsigned char > mOut; static vector< unsigned char > sTranslateLine( const string& cLine ); static vector< unsigned char > sOpAdd( const vector< string >& cTokens ); static vector< unsigned char > sOpMov( const vector< string >& cTokens ); static vector< unsigned char > sOpMmov( const vector< string >& cTokens ); static vector< unsigned char > sOpXor( const vector< string >& cTokens ); static vector< unsigned char > sOpInt( const vector< string >& cTokens ); }; //================================================ inline const string& trans_c::mcGetIn( void ) const noexcept { return mcIn; } //================================================ inline const vector< unsigned char >& trans_c::mcGetOut( void ) const noexcept { return mOut; } //================================================ void trans_c::mTranslate( void ) { vector< string > lines; string next; for ( const char c : mcIn ) { if ( '\n' == c ) { lines.emplace_back( next ); next.clear(); } else { next += c; } } lines.emplace_back( next ); cout << setw( 25 ) << left << setfill( ' ' ) << "- Tokens -" << "| " << "- Binary -" << endl; for ( const string cLine : lines ) { const vector< unsigned char > cBytes( sTranslateLine( cLine ) ); mOut.resize( mOut.size() + cBytes.size(), 0 ); copy( cBytes.begin(), cBytes.end(), mOut.end() - cBytes.size() ); } } //================================================ trans_c::trans_c( const string& cIn ) : mcIn( cIn ) {} //================================================ vector< unsigned char > trans_c::sTranslateLine( const string& cLine ) { vector< unsigned char > bytes; vector< string > tokens; string next; for ( const char cChar : cLine ) { if ( ' ' == cChar ) { if ( next.size() ) { tokens.emplace_back( next ); next.clear(); } } else if ( ',' == cChar ) { if ( next.size() ) { tokens.emplace_back( next ); next.clear(); } tokens.push_back( "," ); } else if ( '\n' == cChar ) { if ( next.size() ) { tokens.emplace_back( next ); next.clear(); } break; } else { next += cChar; } } if ( next.size() ) { tokens.emplace_back( next ); } if ( !tokens.size() ) { return bytes; // An empty line. } if ( "nop" == tokens.at( 0 ) ) { cout << "It's nop\n\n"; } else if ( "add" == tokens.at( 0 ) ) { bytes = sOpAdd( tokens ); } else if ( "mov" == tokens.at( 0 ) ) { bytes = sOpMov( tokens ); } else if ( "mmov" == tokens.at( 0 ) ) { bytes = sOpMmov( tokens ); } else if ( "xor" == tokens.at( 0 ) ) { bytes = sOpXor( tokens ); } else if ( "int" == tokens.at( 0 ) ) { bytes = sOpInt( tokens ); } else { throw except_c { "Unknown lexeme '" + tokens.at( 0 ) + "'" }; } stringstream leftCol; stringstream rightCol; for ( const string cToken : tokens ) { leftCol << "<" << cToken << "> "; } for ( const unsigned int byte : bytes ) { rightCol << hex << setw( 2 ) << setfill( '0' ) << byte << " "; } cout << setw( 25 ) << left << setfill( ' ' ) << leftCol.str() << "| " << rightCol.str() << endl; return bytes; } //================================================ vector< unsigned char > trans_c::sOpAdd( const vector< string >& cTokens ) { if ( "add" != cTokens.at( 0 ) ) { throw except_c( "Wrong OpCode" ); } if ( 4 != cTokens.size() ) { throw except_c( "Wrong number of arguments" ); } if ( "," != cTokens.at( 2 ) ) { throw except_c( "Lexical error" ); } const string cArg1( cTokens.at( 1 ) ); const string cArg2( cTokens.at( 3 ) ); vector< unsigned char > bytes( 3, 0 ); if ( "al" == cArg1 ) { bytes.at( 1 ) = REG_AL; } else if ( "cl" == cArg1 ) { bytes.at( 1 ) = REG_CL; } else if ( "dl" == cArg1 ) { bytes.at( 1 ) = REG_DL; } else if ( "bl" == cArg1 ) { bytes.at( 1 ) = REG_BL; } else { throw except_c( "The first argument - unknown lexeme" ); } if ( "al" == cArg2 ) { bytes.at( 0 ) = OPC_ADD_RR; bytes.at( 2 ) = REG_AL; } else if ( "cl" == cArg2 ) { bytes.at( 0 ) = OPC_ADD_RR; bytes.at( 2 ) = REG_CL; } else if ( "dl" == cArg2 ) { bytes.at( 0 ) = OPC_ADD_RR; bytes.at( 2 ) = REG_DL; } else if ( "bl" == cArg2 ) { bytes.at( 0 ) = OPC_ADD_RR; bytes.at( 2 ) = REG_BL; } else { try { bytes.at( 0 ) = OPC_ADD_RV; bytes.at( 2 ) = static_cast< unsigned char >( atoi( cArg2.c_str() ) ); } catch ( ... ) { throw except_c( "The second argument - unknown lexeme" ); } } return bytes; } //================================================ vector< unsigned char > trans_c::sOpMov( const vector< string >& cTokens ) { if ( "mov" != cTokens.at( 0 ) ) { throw except_c( "Wrong OpCode" ); } if ( 4 != cTokens.size() ) { throw except_c( "Wrong number of arguments" ); } if ( "," != cTokens.at( 2 ) ) { throw except_c( "Lexical error" ); } const string cArg1( cTokens.at( 1 ) ); const string cArg2( cTokens.at( 3 ) ); vector< unsigned char > bytes( 3, 0 ); if ( "al" == cArg1 ) { bytes.at( 1 ) = REG_AL; } else if ( "cl" == cArg1 ) { bytes.at( 1 ) = REG_CL; } else if ( "dl" == cArg1 ) { bytes.at( 1 ) = REG_DL; } else if ( "bl" == cArg1 ) { bytes.at( 1 ) = REG_BL; } else { throw except_c( "The first argument - unknown lexeme" ); } if ( "al" == cArg2 ) { bytes.at( 0 ) = OPC_MOV_RR; bytes.at( 2 ) = REG_AL; } else if ( "cl" == cArg2 ) { bytes.at( 0 ) = OPC_MOV_RR; bytes.at( 2 ) = REG_CL; } else if ( "dl" == cArg2 ) { bytes.at( 0 ) = OPC_MOV_RR; bytes.at( 2 ) = REG_DL; } else if ( "bl" == cArg2 ) { bytes.at( 0 ) = OPC_MOV_RR; bytes.at( 2 ) = REG_BL; } else { try { bytes.at( 0 ) = OPC_MOV_RV; bytes.at( 2 ) = static_cast< unsigned char >( atoi( cArg2.c_str() ) ); } catch ( ... ) { throw except_c( "The second argument - unknown lexeme" ); } } return bytes; } //================================================ vector< unsigned char > trans_c::sOpMmov( const vector< string >& cTokens ) { if ( "mmov" != cTokens.at( 0 ) ) { throw except_c( "Wrong OpCode" ); } if ( 4 != cTokens.size() ) { throw except_c( "Wrong number of arguments" ); } if ( "," != cTokens.at( 2 ) ) { throw except_c( "Lexical error" ); } const string cArg1( cTokens.at( 1 ) ); const string cArg2( cTokens.at( 3 ) ); vector< unsigned char > bytes( 3, 0 ); bool firstReg { true }; bool secondReg { true }; if ( "al" == cArg1 ) { bytes.at( 1 ) = REG_AL; } else if ( "cl" == cArg1 ) { bytes.at( 1 ) = REG_CL; } else if ( "dl" == cArg1 ) { bytes.at( 1 ) = REG_DL; } else if ( "bl" == cArg1 ) { bytes.at( 1 ) = REG_BL; } else { firstReg = false; try { bytes.at( 1 ) = static_cast< unsigned char >( atoi( cArg1.c_str() ) ); } catch ( ... ) { throw except_c( "The first argument - unknown lexeme" ); } } if ( "al" == cArg2 ) { bytes.at( 2 ) = REG_AL; } else if ( "cl" == cArg2 ) { bytes.at( 2 ) = REG_CL; } else if ( "dl" == cArg2 ) { bytes.at( 2 ) = REG_DL; } else if ( "bl" == cArg2 ) { bytes.at( 2 ) = REG_BL; } else { secondReg = false; if ( firstReg ) { try { bytes.at( 2 ) = static_cast< unsigned char >( atoi( cArg2.c_str() ) ); } catch ( ... ) { throw except_c( "The first argument - unknown lexeme" ); } } else { try { bytes.at( 2 ) = static_cast< unsigned char >( cArg2.at( 0 ) ); } catch ( ... ) { throw except_c( "The second argument - unknown lexeme" ); } } } if ( firstReg && !secondReg ) { bytes.at( 0 ) = OPC_MOV_RM; } else if ( !firstReg && secondReg ) { bytes.at( 0 ) = OPC_MOV_MR; } else if ( !firstReg && !secondReg ) { bytes.at( 0 ) = OPC_MOV_MV; } else { throw except_c( "Syntax error" ); } return bytes; } //================================================ vector< unsigned char > trans_c::sOpXor( const vector< string >& cTokens ) { if ( "xor" != cTokens.at( 0 ) ) { throw except_c( "Wrong OpCode" ); } if ( 4 != cTokens.size() ) { throw except_c( "Wrong number of arguments" ); } if ( "," != cTokens.at( 2 ) ) { throw except_c( "Lexical error" ); } const string cArg1( cTokens.at( 1 ) ); const string cArg2( cTokens.at( 3 ) ); vector< unsigned char > bytes( 3, 0 ); if ( "al" == cArg1 ) { bytes.at( 1 ) = REG_AL; } else if ( "cl" == cArg1 ) { bytes.at( 1 ) = REG_CL; } else if ( "dl" == cArg1 ) { bytes.at( 1 ) = REG_DL; } else if ( "bl" == cArg1 ) { bytes.at( 1 ) = REG_BL; } else { throw except_c( "The first argument - unknown lexeme" ); } if ( "al" == cArg2 ) { bytes.at( 0 ) = OPC_XOR_RR; bytes.at( 2 ) = REG_AL; } else if ( "cl" == cArg2 ) { bytes.at( 0 ) = OPC_XOR_RR; bytes.at( 2 ) = REG_CL; } else if ( "dl" == cArg2 ) { bytes.at( 0 ) = OPC_XOR_RR; bytes.at( 2 ) = REG_DL; } else if ( "bl" == cArg2 ) { bytes.at( 0 ) = OPC_XOR_RR; bytes.at( 2 ) = REG_BL; } else { try { bytes.at( 0 ) = OPC_XOR_RV; bytes.at( 2 ) = static_cast< unsigned char >( atoi( cArg2.c_str() ) ); } catch ( ... ) { throw except_c( "The second argument - unknown lexeme" ); } } return bytes; } //================================================ vector< unsigned char > trans_c::sOpInt( const vector< string >& cTokens ) { if ( "int" != cTokens.at( 0 ) ) { throw except_c( "Wrong OpCode" ); } if ( cTokens.size() < 2 ) { throw except_c( "Wrong args"); } const string cArg( cTokens.at( 1 ) ); vector< unsigned char > bytes; if ( "TEXT" == cArg ) { bytes.emplace_back( OPC_INT_TEXT ); try { bytes.emplace_back( static_cast< unsigned char >( atoi( cTokens.at( 3 ).c_str() ) ) ); } catch ( ... ) { throw except_c( "The argument - unknown lexeme" ); } } else if ( "EXIT" == cArg ) { bytes.emplace_back( OPC_INT_EXIT ); } else { throw except_c( "Interruption - wrong argument" ); } return bytes; } //================================================ // Machine //================================================ //================================================ class machine_c final { public: void mcShowOpCode( const uint8_t cCode ) const; void mcShowRegs( void ) const; void mcShowRam( const uint8_t cAddr = 0 ) const; void mLoadRun( const vector< uint8_t >& cProg ); machine_c& operator=( const machine_c& ) = delete; machine_c( void ); machine_c( const machine_c& ) = delete; ~machine_c( void ) = default; private: uint8_t mRegIp { 0 }; array< uint8_t, 4 > mGpr {{ 0, 0, 0, 0 }}; array< uint8_t, 256 > mRam; bool mDoIter( void ); }; //================================================ void machine_c::mcShowOpCode( const uint8_t cCode ) const { cout << "OpCode=" << hex << setfill( '0' ) << setw( 2 ) << static_cast< unsigned int >( cCode ); } //================================================ void machine_c::mcShowRegs( void ) const { auto fmt = []( ostream& cout ) ->ostream& { return cout << hex << setfill( '0' ) << setw( 2 ); }; auto val = []( uint8_t val ) ->unsigned int { return val; }; cout << "ip=" << fmt << val( mRegIp ); cout << " al=" << fmt << val( mGpr[ REG_AL ] ); cout << " cl=" << fmt << val( mGpr[ REG_CL ] ); cout << " dl=" << fmt << val( mGpr[ REG_DL ] ); cout << " bl=" << fmt << val( mGpr[ REG_BL ] ); } //================================================ void machine_c::mcShowRam( const uint8_t cAddr ) const { auto fmt = []( ostream& os ) ->ostream& { return os << hex << setfill( '0' ) << setw( 2 ) << right; }; cout << "VSVM -> Memory dump:\n"; for ( size_t line { 0 }; line < 16; ++line ) { cout << fmt << static_cast< unsigned int >( 16 * line ) << ": "; for ( size_t iByte { 0 }; iByte < 16; ++iByte ) { cout << fmt << static_cast< unsigned int >( mRam[ 16 * line + iByte ] ); switch ( iByte ) { case 7: cout << " "; break; case 15: cout << endl; break; default: cout << " "; } } } } //================================================ void machine_c::mLoadRun( const vector< uint8_t >& cProg ) { if ( cProg.size() > mRam.size() ) { throw except_c { "Program size too much." }; } for ( size_t iByte { 0 }; iByte < cProg.size(); ++iByte ) { mRam[ iByte ] = cProg[ iByte ]; } mRegIp = 0; mcShowRam(); cout << "\nVSVM -> Run:\n"; do { mcShowOpCode( mRam[ mRegIp ] ); cout << " | "; mcShowRegs(); cout << "\n"; } while ( mDoIter() ); } //================================================ machine_c::machine_c( void ) { mRam.fill( 0 ); } //================================================ bool machine_c::mDoIter( void ) { switch ( mRam[ mRegIp ] ) { case OPC_NOP: ++mRegIp; break; case OPC_ADD_RR: mGpr[ mRam[ mRegIp + 1 ] ] |= mGpr[ mRam[ mRegIp + 2 ] ]; mRegIp += 3; break; case OPC_ADD_RV: mGpr[ mRam[ mRegIp + 1 ] ] |= mRam[ mRegIp + 2 ]; mRegIp += 3; break; case OPC_MOV_RR: mGpr[ mRam[ mRegIp + 1 ] ] = mGpr[ mRam[ mRegIp + 2 ] ]; mRegIp += 3; break; case OPC_MOV_RV: mGpr[ mRam[ mRegIp + 1 ] ] = mRam[ mRegIp + 2 ]; mRegIp += 3; break; case OPC_MOV_RM: mGpr[ mRam[ mRegIp + 1 ] ] = mRam[ mRam[ mRegIp + 2 ] ]; mRegIp += 3; break; case OPC_MOV_MR: mRam[ mRam[ mRegIp + 1 ] ] = mGpr[ mRam[ mRegIp + 2 ] ]; mRegIp += 3; break; case OPC_MOV_MV: mRam[ mRam[ mRegIp + 1 ] ] = mRam[ mRegIp + 2 ]; mRegIp += 3; break; case OPC_XOR_RR: mGpr[ mRam[ mRegIp + 1 ] ] ^= mGpr[ mRam[ mRegIp + 2 ] ]; mRegIp += 3; break; case OPC_XOR_RV: mGpr[ mRam[ mRegIp + 1 ] ] ^= mRam[ mRegIp + 2 ]; mRegIp += 3; break; case OPC_INT_TEXT: cout << "VSVM -> Text: "; for ( uint8_t iByte { mRam[ mRegIp + 1 ] }; mRam[ iByte ]; ++iByte ) { cout << mRam[ iByte ]; } cout << '\n'; mRegIp += 2; break; case OPC_INT_EXIT: cout << "VSVM -> Exit...\n"; return false; default: stringstream what; what << "VSVM -> FATAL ERROR !!!:\n"; what << "Unknown OpCode=" << hex << setfill( '0' ) << setw( 2 ) << static_cast< unsigned int >( mRam[ mRegIp ] ); what << " at ip=" << hex << setfill( '0' ) << setw( 2 ) << static_cast< unsigned int >( mRegIp ); what << "\nMachine shutdown..."; throw except_c { what.str() }; break; } return true; } } // namespace vsvm //================================================ // Main //================================================ using namespace vsvm; //================================================ int main( const int argc, const char* argv[] ) try { // User input and parse. string userIn; string word; while ( true ) { word.clear(); cin >> word; if ( word.size() ) { if ( ';' == word.back() ) { word.erase( word.end() - 1 ); userIn += word + "\n"; } else { userIn += word + " "; } } else { // Erase space or new_line character in the end. if ( userIn.size() ) { userIn.erase( userIn.end() - 1 ); } break; } } // Test asm program. const string cTestAsm { "add al, 5 \n" "add cl, 10 \n" "add al, cl \n" "mov dl, cl \n" "mov cl, 50 \n" "mmov 255, al \n" "mmov bl, 255 \n" "xor cl, cl \n" "mov al, 255 \n" "xor al, 170 \n" "mmov 128, H \n" "mmov 129, a \n" "mmov 130, l \n" "mmov 131, l \n" "mmov 132, o \n" "mmov 133, _ \n" "mmov 134, W \n" "mmov 135, o \n" "mmov 136, r \n" "mmov 137, l \n" "mmov 138, d \n" "mmov 139, ! \n" "int TEXT, 128 \n" //"0x33 \n" "int EXIT " }; bool emptyFlag { true }; if ( userIn.empty() ) { userIn = cTestAsm; } else if ( 8 > userIn.size() ) { emptyFlag = false; cout << "What do you want?\nSee example:\n" << endl; userIn = cTestAsm; } // Translator. trans_c trans( userIn ); cout << "Translator input:\n" << trans.mcGetIn() << "\n" << endl; trans.mTranslate(); // Machine. machine_c vm; /* // Test binary program. const vector< unsigned char > cTestProg { OPC_ADD_RV, REG_AL, 5, // add al, 5 OPC_ADD_RV, REG_CL, 10, // add cl, 10 OPC_ADD_RR, REG_AL, REG_CL, // add al, cl OPC_MOV_RR, REG_DL, REG_CL, // mov dl, cl OPC_MOV_RV, REG_CL, 50, // mov cl, 50 OPC_MOV_MR, 255, REG_AL, // mmov 255, al OPC_MOV_RM, REG_BL, 255, // mmov bl, 255 OPC_XOR_RR, REG_CL, REG_CL, // xor cl, cl OPC_MOV_RV, REG_AL, 0xff, // mov al, 0xff OPC_XOR_RV, REG_AL, 0xaa, // xor al, 0xaa OPC_MOV_MV, 0x80, 'H', OPC_MOV_MV, 0x81, 'a', OPC_MOV_MV, 0x82, 'l', OPC_MOV_MV, 0x83, 'l', OPC_MOV_MV, 0x84, 'o', OPC_MOV_MV, 0x85, '_', OPC_MOV_MV, 0x86, 'W', OPC_MOV_MV, 0x87, 'o', OPC_MOV_MV, 0x88, 'r', OPC_MOV_MV, 0x89, 'l', OPC_MOV_MV, 0x8a, 'd', OPC_MOV_MV, 0x8b, '!', OPC_INT_TEXT, 0x80, //0x33, OPC_INT_EXIT // int EXIT }; if ( trans.mcGetOut() == cTestProg ) { cout << "\nData checked." << endl; } else { cout << "\nData has been corrupted." << endl; } */ cout << endl; vm.mLoadRun( /*cTestProg*/trans.mcGetOut() ); cout << endl; if ( !emptyFlag ) { cout << "OK?\n" << "Please input correct program and try again.\n" << "Read the code for more details." << endl; } return 0; } catch ( const exception& cEx ) { cout << cEx.what() << endl; return 1; } catch ( ... ) { cout << "FATAL ERROR !!!" << endl; return 1; }

Very Simple Virtual Machine v.0.1.1