<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html> <head> <title>CIYAM AT - at.cpp </title> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/> <meta name="copyright" content="Copyright 2015 CIYAM Developers"/> <link rel="stylesheet" href="document.css" type="text/css"/> </head> <div id="content"> <div id="header"> <div id="appname"><a href="//ciyam.org/at">AT</a></div> <h3 class="right-top">at.cpp </h3> </div> <div id="main"> <div id="text"> <pre> at.cpp // Copyright (c) 2014 CIYAM Developers // // Distributed under the MIT/X11 software license, please refer to the file license.txt // in the root project directory or http://www.opensource.org/licenses/mit-license.php. #include <cstdlib> #include <memory.h> #ifndef _WIN32 # include <stdint.h> #else # ifdef _MSC_VER typedef __int8 int8_t; typedef __int16 int16_t; typedef __int32 int32_t; typedef __int64 int64_t; # endif #endif #include <map> #include <set> #include <deque> #include <memory> #include <string> #include <vector> #include <fstream> #include <iomanip> #include <sstream> #include <iostream> #include <stdexcept> /* Basic Test Cases (output value) > code 0100000000b8220000000000003301000000000028 > run 8888 (testing loop) > code 35020000000000330100000000001e00000000f228 > run 1 2 3 4 5 6 7 8 9 0 (explicit loop) > code 010000000003000000000000000500000000330100000000001e00000000f428 > run 2 1 0 */ using namespace std; const int32_t c_code_page_bytes = 512; const int32_t c_data_page_bytes = 512; const int32_t c_call_stack_page_bytes = 256; const int32_t c_user_stack_page_bytes = 256; int32_t g_code_pages = 1; int32_t g_data_pages = 1; int32_t g_call_stack_pages = 1; int32_t g_user_stack_pages = 1; const int64_t c_default_balance = 100; const int32_t c_max_to_multiply = 0x1fffffff; int64_t g_val = 0; int64_t g_val1 = 0; int64_t g_balance = c_default_balance; bool g_first_call = true; int32_t g_increment_func = 0; enum op_code { e_op_code_NOP = 0x7f, e_op_code_SET_VAL = 0x01, e_op_code_SET_DAT = 0x02, e_op_code_CLR_DAT = 0x03, e_op_code_INC_DAT = 0x04, e_op_code_DEC_DAT = 0x05, e_op_code_ADD_DAT = 0x06, e_op_code_SUB_DAT = 0x07, e_op_code_MUL_DAT = 0x08, e_op_code_DIV_DAT = 0x09, e_op_code_BOR_DAT = 0x0a, e_op_code_AND_DAT = 0x0b, e_op_code_XOR_DAT = 0x0c, e_op_code_NOT_DAT = 0x0d, e_op_code_SET_IND = 0x0e, e_op_code_SET_IDX = 0x0f, e_op_code_PSH_DAT = 0x10, e_op_code_POP_DAT = 0x11, e_op_code_JMP_SUB = 0x12, e_op_code_RET_SUB = 0x13, e_op_code_IND_DAT = 0x14, e_op_code_IDX_DAT = 0x15, e_op_code_MOD_DAT = 0x16, e_op_code_SHL_DAT = 0x17, e_op_code_SHR_DAT = 0x18, e_op_code_JMP_ADR = 0x1a, e_op_code_BZR_DAT = 0x1b, e_op_code_BNZ_DAT = 0x1e, e_op_code_BGT_DAT = 0x1f, e_op_code_BLT_DAT = 0x20, e_op_code_BGE_DAT = 0x21, e_op_code_BLE_DAT = 0x22, e_op_code_BEQ_DAT = 0x23, e_op_code_BNE_DAT = 0x24, e_op_code_SLP_DAT = 0x25, e_op_code_FIZ_DAT = 0x26, e_op_code_STZ_DAT = 0x27, e_op_code_FIN_IMD = 0x28, e_op_code_STP_IMD = 0x29, e_op_code_SLP_IMD = 0x2a, e_op_code_ERR_ADR = 0x2b, e_op_code_SET_PCS = 0x30, e_op_code_EXT_FUN = 0x32, e_op_code_EXT_FUN_DAT = 0x33, e_op_code_EXT_FUN_DAT_2 = 0x34, e_op_code_EXT_FUN_RET = 0x35, e_op_code_EXT_FUN_RET_DAT = 0x36, e_op_code_EXT_FUN_RET_DAT_2 = 0x37, }; struct machine_state { machine_state( ) { pce = pcs = 0; reset( ); } void reset( ) { pc = pcs; opc = 0; cs = 0; us = 0; steps = 0; a1 = 0; a2 = 0; a3 = 0; a4 = 0; b1 = 0; b2 = 0; b3 = 0; b4 = 0; jumps.clear( ); stopped = false; finished = false; } bool stopped; // transient bool finished; // transient int32_t pc; int32_t pce; int32_t pcs; int32_t opc; // transient int32_t cs; int32_t us; int64_t a1; int64_t a2; int64_t a3; int64_t a4; int64_t b1; int64_t b2; int64_t b3; int64_t b4; int32_t steps; int32_t sleep_until; set< int32_t > jumps; // transient }; struct function_data { function_data( ) { loop = false; offset = 0; } bool loop; size_t offset; vector< int64_t > data; }; string decode_function_name( int16_t fun, int8_t op ) { ostringstream osstr; int8_t op_expected = 0; switch( fun ) { case 0x0100: osstr << "Get_A1"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0101: osstr << "Get_A2"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0102: osstr << "Get_A3"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0103: osstr << "Get_A4"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0104: osstr << "Get_B1"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0105: osstr << "Get_B2"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0106: osstr << "Get_B3"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0107: osstr << "Get_B4"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0110: osstr << "Set_A1"; op_expected = e_op_code_EXT_FUN_DAT; break; case 0x0111: osstr << "Set_A2"; op_expected = e_op_code_EXT_FUN_DAT; break; case 0x0112: osstr << "Set_A3"; op_expected = e_op_code_EXT_FUN_DAT; break; case 0x0113: osstr << "Set_A4"; op_expected = e_op_code_EXT_FUN_DAT; break; case 0x0114: osstr << "Set_A1_A2"; op_expected = e_op_code_EXT_FUN_DAT_2; break; case 0x0115: osstr << "Set_A3_A4"; op_expected = e_op_code_EXT_FUN_DAT_2; break; case 0x0116: osstr << "Set_B1"; op_expected = e_op_code_EXT_FUN_DAT; break; case 0x0117: osstr << "Set_B2"; op_expected = e_op_code_EXT_FUN_DAT; break; case 0x0118: osstr << "Set_B3"; op_expected = e_op_code_EXT_FUN_DAT; break; case 0x0119: osstr << "Set_B4"; op_expected = e_op_code_EXT_FUN_DAT; break; case 0x011a: osstr << "Set_B1_B2"; op_expected = e_op_code_EXT_FUN_DAT_2; break; case 0x011b: osstr << "Set_B3_B4"; op_expected = e_op_code_EXT_FUN_DAT_2; break; case 0x0120: osstr << "Clear_A"; op_expected = e_op_code_EXT_FUN; break; case 0x0121: osstr << "Clear_B"; op_expected = e_op_code_EXT_FUN; break; case 0x0122: osstr << "Clear_A_And_B"; op_expected = e_op_code_EXT_FUN; break; case 0x0123: osstr << "Copy_A_From_B"; op_expected = e_op_code_EXT_FUN; break; case 0x0124: osstr << "Copy_B_From_A"; op_expected = e_op_code_EXT_FUN; break; case 0x0125: osstr << "Check_A_Is_Zero"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0126: osstr << "Check_B_Is_Zero"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0127: osstr << "Check_A_Equals_B"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0128: osstr << "Swap_A_and_B"; op_expected = e_op_code_EXT_FUN; break; case 0x0129: osstr << "OR_A_with_B"; op_expected = e_op_code_EXT_FUN; break; case 0x012a: osstr << "OR_B_with_A"; op_expected = e_op_code_EXT_FUN; break; case 0x012b: osstr << "AND_A_with_B"; op_expected = e_op_code_EXT_FUN; break; case 0x012c: osstr << "AND_B_with_A"; op_expected = e_op_code_EXT_FUN; break; case 0x012d: osstr << "XOR_A_with_B"; op_expected = e_op_code_EXT_FUN; break; case 0x012e: osstr << "XOR_B_with_A"; op_expected = e_op_code_EXT_FUN; break; case 0x0200: osstr << "MD5_A_To_B"; op_expected = e_op_code_EXT_FUN; break; case 0x0201: osstr << "Check_MD5_A_With_B"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0202: osstr << "HASH160_A_To_B"; op_expected = e_op_code_EXT_FUN; break; case 0x0203: osstr << "Check_HASH160_A_With_B"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0204: osstr << "SHA256_A_To_B"; op_expected = e_op_code_EXT_FUN; break; case 0x0205: osstr << "Check_SHA256_A_With_B"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0300: osstr << "Get_Block_Timestamp"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0301: osstr << "Get_Creation_Timestamp"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0302: osstr << "Get_Last_Block_Timestamp"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0303: osstr << "Put_Last_Block_Hash_In_A"; op_expected = e_op_code_EXT_FUN; break; case 0x0304: osstr << "A_To_Tx_After_Timestamp"; op_expected = e_op_code_EXT_FUN_DAT; break; case 0x0305: osstr << "Get_Type_For_Tx_In_A"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0306: osstr << "Get_Amount_For_Tx_In_A"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0307: osstr << "Get_Timestamp_For_Tx_In_A"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0308: osstr << "Get_Random_Id_For_Tx_In_A"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0309: osstr << "Message_From_Tx_In_A_To_B"; op_expected = e_op_code_EXT_FUN; break; case 0x030a: osstr << "B_To_Address_Of_Tx_In_A"; op_expected = e_op_code_EXT_FUN; break; case 0x030b: osstr << "B_To_Address_Of_Creator"; op_expected = e_op_code_EXT_FUN; break; case 0x0400: osstr << "Get_Current_Balance"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0401: osstr << "Get_Previous_Balance"; op_expected = e_op_code_EXT_FUN_RET; break; case 0x0402: osstr << "Send_To_Address_In_B"; op_expected = e_op_code_EXT_FUN_DAT; break; case 0x0403: osstr << "Send_All_To_Address_In_B"; op_expected = e_op_code_EXT_FUN; break; case 0x0404: osstr << "Send_Old_To_Address_In_B"; op_expected = e_op_code_EXT_FUN; break; case 0x0405: osstr << "Send_A_To_Address_In_B"; op_expected = e_op_code_EXT_FUN; break; case 0x0406: osstr << "Add_Minutes_To_Timestamp"; op_expected = e_op_code_EXT_FUN_RET_DAT_2; break; default: osstr << "0x" << hex << setw( 4 ) << setfill( '0' ) << fun; } if( op && op_expected && op != op_expected ) osstr << " *** invalid op ***"; return osstr.str( ); } map< int32_t, function_data > g_function_data; int64_t get_function_data( int32_t func_num ) { if( func_num == g_increment_func ) { if( g_first_call ) g_first_call = false; else { for( map< int32_t, function_data >::iterator i = g_function_data.begin( ); i != g_function_data.end( ); ++i ) { if( ++( i->second.offset ) >= i->second.data.size( ) ) { if( i->second.loop ) i->second.offset = 0; else --( i->second.offset ); } } } } int64_t rc = g_function_data[ func_num ].data[ g_function_data[ func_num ].offset ]; return rc; } int64_t func( int32_t func_num, machine_state& state ) { int64_t rc = 0; if( func_num == 1 ) rc = g_val; else if( func_num == 2 ) // get a value { if( g_val == 9 ) rc = g_val = 0; else rc = ++g_val; } else if( func_num == 3 ) // get size rc = 10; else if( func_num == 4 ) // get func num rc = func_num; else if( func_num == 25 || func_num == 32 ) // get balance (prior) { rc = g_balance; if( g_function_data.count( func_num ) ) { cout << "(resetting function data)\n"; g_first_call = true; for( map< int32_t, function_data >::iterator i = g_function_data.begin( ); i != g_function_data.end( ); ++i ) i->second.offset = 0; } } else if( func_num == 0x0100 ) // Get_A1 rc = state.a1; else if( func_num == 0x0101 ) // Get_A2 rc = state.a2; else if( func_num == 0x0102 ) // Get_A3 rc = state.a3; else if( func_num == 0x0103 ) // Get_A4 rc = state.a4; else if( func_num == 0x0104 ) // Get_B1 rc = state.b1; else if( func_num == 0x0105 ) // Get_B2 rc = state.b2; else if( func_num == 0x0106 ) // Get_B3 rc = state.b3; else if( func_num == 0x0107 ) // Get_B4 rc = state.b4; else if( func_num == 0x0120 ) // Clear_A { state.a1 = 0; state.a2 = 0; state.a3 = 0; state.a4 = 0; } else if( func_num == 0x0121 ) // Clear_B { state.b1 = 0; state.b2 = 0; state.b3 = 0; state.b4 = 0; } else if( func_num == 0x0122 ) // Clear_A_And_B { state.a1 = state.b1 = 0; state.a2 = state.b2 = 0; state.a3 = state.b3 = 0; state.a4 = state.b4 = 0; } else if( func_num == 0x0123 ) // Copy_A_From_B { state.a1 = state.b1; state.a2 = state.b2; state.a3 = state.b3; state.a4 = state.b4; } else if( func_num == 0x0124 ) // Copy_B_From_A { state.b1 = state.a1; state.b2 = state.a2; state.b3 = state.a3; state.b4 = state.a4; } else if( func_num == 0x0125 ) // Check_A_Is_Zero { if( state.a1 == 0 && state.a2 == 0 && state.a3 == 0 && state.a4 == 0 ) rc = true; } else if( func_num == 0x0126 ) // Check_B_Is_Zero { if( state.b1 == 0 && state.b2 == 0 && state.b3 == 0 && state.b4 == 0 ) rc = true; } else if( func_num == 0x0127 ) // Check_A_Equals_B { if( state.a1 == state.b1 && state.a2 == state.b2 && state.a3 == state.b3 && state.a4 == state.b4 ) rc = true; } else if( func_num == 0x0128 ) // Swap_A_and_B { int64_t tmp_a1 = state.a1; int64_t tmp_a2 = state.a2; int64_t tmp_a3 = state.a3; int64_t tmp_a4 = state.a4; state.a1 = state.b1; state.a2 = state.b2; state.a3 = state.b3; state.a4 = state.b4; state.b1 = tmp_a1; state.b2 = tmp_a2; state.b3 = tmp_a3; state.b4 = tmp_a4; } else if( func_num == 0x0129 ) // OR_A_with_B { state.a1 = state.a1 | state.b1; state.a2 = state.a2 | state.b2; state.a3 = state.a3 | state.b3; state.a4 = state.a4 | state.b4; } else if( func_num == 0x012a ) // OR_B_with_A { state.b1 = state.a1 | state.b1; state.b2 = state.a2 | state.b2; state.b3 = state.a3 | state.b3; state.b4 = state.a4 | state.b4; } else if( func_num == 0x012b ) // AND_A_with_B { state.a1 = state.a1 & state.b1; state.a2 = state.a2 & state.b2; state.a3 = state.a3 & state.b3; state.a4 = state.a4 & state.b4; } else if( func_num == 0x012c ) // AND_B_with_A { state.b1 = state.a1 & state.b1; state.b2 = state.a2 & state.b2; state.b3 = state.a3 & state.b3; state.b4 = state.a4 & state.b4; } else if( func_num == 0x012d ) // XOR_A_with_B { state.a1 = state.a1 ^ state.b1; state.a2 = state.a2 ^ state.b2; state.a3 = state.a3 ^ state.b3; state.a4 = state.a4 ^ state.b4; } else if( func_num == 0x012e ) // XOR_B_with_A { state.b1 = state.a1 ^ state.b1; state.b2 = state.a2 ^ state.b2; state.b3 = state.a3 ^ state.b3; state.b4 = state.a4 ^ state.b4; } else if( g_function_data.count( func_num ) ) rc = get_function_data( func_num ); if( func_num != 2 ) { if( func_num < 0x100 ) cout << "func: " << dec << func_num << " rc: " << hex << setw( 16 ) << setfill( '0' ) << rc << '\n'; else cout << "func: " << decode_function_name( func_num, 0 ) << " rc: 0x" << hex << setw( 16 ) << setfill( '0' ) << rc << '\n'; } return rc; } int64_t func1( int32_t func_num, machine_state& state, int64_t value, int8_t* p_data = 0, int32_t dsize = 0 ) { int64_t rc = 0; if( func_num == 1 ) // echo cout << dec << value << '\n'; else if( func_num == 2 ) rc = value * 2; // double it else if( func_num == 3 ) rc = value / 2; // halve it else if( func_num == 26 || func_num == 33 ) // pay balance (prior) { cout << "payout " << dec << g_balance << " to account: " << value << '\n'; g_balance = 0; } else if( func_num == 0x0110 ) // Set_A1 state.a1 = value; else if( func_num == 0x0111 ) // Set_A2 state.a2 = value; else if( func_num == 0x0112 ) // Set_A3 state.a3 = value; else if( func_num == 0x0113 ) // Set_A4 state.a4 = value; else if( func_num == 0x0116 ) // Set_B1 state.b1 = value; else if( func_num == 0x0117 ) // Set_B2 state.b2 = value; else if( func_num == 0x0118 ) // Set_B3 state.b3 = value; else if( func_num == 0x0119 ) // Set_B4 state.b4 = value; else if( g_function_data.count( func_num ) ) rc = get_function_data( func_num ); if( func_num != 1 && func_num != 26 ) { if( func_num < 0x100 ) cout << "func1: " << dec << func_num << " with " << value << " rc: " << hex << setw( 16 ) << setfill( '0' ) << rc << '\n'; else cout << "func1: " << decode_function_name( func_num, 0 ) << " with " << value << " rc: 0x" << hex << setw( 16 ) << setfill( '0' ) << rc << '\n'; } return rc; } int64_t func2( int32_t func_num, machine_state& state, int64_t value1, int64_t value2, int8_t* p_data = 0, int32_t dsize = 0 ) { int64_t rc = 0; if( func_num == 2 ) rc = value1 * value2; // multiply values else if( func_num == 3 ) rc = value1 / value2; // divide values else if( func_num == 4 ) rc = value1 + value2; // sum values else if( func_num == 31 ) // send amount to address { if( value1 > g_balance ) value1 = g_balance; cout << "payout " << dec << value1 << " to account: " << hex << setw( 8 ) << setfill( '0' ) << value2 << '\n'; g_balance -= value1; } else if( func_num == 0x0114 ) // Set_A1_A2 { state.a1 = value1; state.a2 = value2; } else if( func_num == 0x0115 ) // Set_A3_A4 { state.a3 = value1; state.a4 = value2; } else if( func_num == 0x011a ) // Set_B1_B2 { state.b1 = value1; state.b2 = value2; } else if( func_num == 0x011b ) // Set_B3_B4 { state.b3 = value1; state.b4 = value2; } else if( g_function_data.count( func_num ) ) rc = get_function_data( func_num ); if( func_num != 31 ) { if( func_num < 0x100 ) cout << "func2: " << dec << func_num << " with " << value1 << " and " << value2 << " rc: " << hex << setw( 16 ) << setfill( '0' ) << rc << '\n'; else cout << "func2: " << decode_function_name( func_num, 0 ) << " with " << value1 << " and " << value2 << " rc: 0x" << hex << setw( 16 ) << setfill( '0' ) << rc << '\n'; } return rc; } int get_fun( int8_t* p_code, int32_t csize, const machine_state& state, int16_t& fun ) { if( state.pc + ( int32_t )sizeof( int16_t ) >= csize ) return -1; else { fun = *( int16_t* )( p_code + state.pc + 1 ); return 0; } } int get_addr( int8_t* p_code, int32_t csize, int32_t dsize, const machine_state& state, int32_t& addr, bool is_code = false ) { if( state.pc + ( int32_t )sizeof( int32_t ) >= csize ) return -1; else { addr = *( int32_t* )( p_code + state.pc + 1 ); if( addr < 0 || addr > c_max_to_multiply || ( is_code && addr >= csize ) ) return -1; else if( !is_code && ( ( addr * 8 ) < 0 || ( addr * 8 ) + ( int32_t )sizeof( int64_t ) > dsize ) ) return -1; else return 0; } } int get_addrs( int8_t* p_code, int32_t csize, int32_t dsize, const machine_state& state, int32_t& addr1, int32_t& addr2 ) { if( state.pc + ( int32_t )sizeof( int32_t ) + ( int32_t )sizeof( int32_t ) >= csize ) return -1; else { addr1 = *( int32_t* )( p_code + state.pc + 1 ); addr2 = *( int32_t* )( p_code + state.pc + 1 + sizeof( int32_t ) ); if( addr1 < 0 || addr1 > c_max_to_multiply || addr2 < 0 || addr2 > c_max_to_multiply || ( addr1 * 8 ) < 0 || ( addr2 * 8 ) < 0 || ( addr1 * 8 ) + ( int32_t )sizeof( int64_t ) > dsize || ( addr2 * 8 ) + ( int32_t )sizeof( int64_t ) > dsize ) return -1; else return 0; } } int get_addr_off( int8_t* p_code, int32_t csize, int32_t dsize, const machine_state& state, int32_t& addr, int8_t& off ) { if( state.pc + ( int32_t )sizeof( int32_t ) + ( int32_t )sizeof( int8_t ) >= csize ) return -1; else { addr = *( int32_t* )( p_code + state.pc + 1 ); off = *( int8_t* )( p_code + state.pc + 1 + sizeof( int32_t ) ); if( addr < 0 || addr > c_max_to_multiply || ( addr * 8 ) < 0 || ( addr * 8 ) + ( int32_t )sizeof( int64_t ) > dsize || state.pc + off >= csize ) return -1; else return 0; } } int get_addrs_off( int8_t* p_code, int32_t csize, int32_t dsize, const machine_state& state, int32_t& addr1, int32_t& addr2, int8_t& off ) { if( state.pc + ( int32_t )sizeof( int32_t ) + ( int32_t )sizeof( int32_t ) + ( int32_t )sizeof( int8_t ) >= csize ) return -1; else { addr1 = *( int32_t* )( p_code + state.pc + 1 ); addr2 = *( int32_t* )( p_code + state.pc + 1 + sizeof( int32_t ) ); off = *( int8_t* )( p_code + state.pc + 1 + sizeof( int32_t ) + sizeof( int32_t ) ); if( addr1 < 0 || addr1 < c_max_to_multiply || addr2 < 0 || addr2 < c_max_to_multiply || ( addr1 * 8 ) < 0 || ( addr2 * 8 ) < 0 || ( addr1 * 8 ) + ( int32_t )sizeof( int64_t ) > dsize || ( addr2 * 8 ) + ( int32_t )sizeof( int64_t ) > dsize || state.pc + off >= csize ) return -1; else return 0; } } int get_fun_addr( int8_t* p_code, int32_t csize, int32_t dsize, const machine_state& state, int16_t& fun, int32_t& addr ) { if( state.pc + ( int32_t )sizeof( int16_t ) + ( int32_t )sizeof( int32_t ) >= csize ) return -1; else { fun = *( int16_t* )( p_code + state.pc + 1 ); addr = *( int32_t* )( p_code + state.pc + 1 + sizeof( int16_t ) ); if( addr < 0 || addr > c_max_to_multiply || ( addr * 8 ) < 0 || ( addr * 8 ) + ( int32_t )sizeof( int64_t ) > dsize ) return -1; else return 0; } } int get_fun_addrs( int8_t* p_code, int32_t csize, int32_t dsize, const machine_state& state, int16_t& fun, int32_t& addr1, int32_t& addr2 ) { if( state.pc + ( int32_t )sizeof( int16_t ) + ( int32_t )sizeof( int32_t ) + ( int32_t )sizeof( int32_t ) >= csize ) return -1; else { fun = *( int16_t* )( p_code + state.pc + 1 ); addr1 = *( int32_t* )( p_code + state.pc + 1 + sizeof( int16_t ) ); addr2 = *( int32_t* )( p_code + state.pc + 1 + sizeof( int16_t ) + sizeof( int32_t ) ); if( addr1 < 0 || addr1 > c_max_to_multiply || addr2 < 0 || addr2 > c_max_to_multiply || ( addr1 * 8 ) < 0 || ( addr2 * 8 ) < 0 || ( addr1 * 8 ) + ( int32_t )sizeof( int64_t ) > dsize || ( addr2 * 8 ) + ( int32_t )sizeof( int64_t ) > dsize ) return -1; else return 0; } } int get_addr_val( int8_t* p_code, int32_t csize, int32_t dsize, const machine_state& state, int32_t& addr, int64_t& val ) { if( state.pc + ( int32_t )sizeof( int32_t ) + ( int32_t )sizeof( int64_t ) >= csize ) return -1; else { addr = *( int32_t* )( p_code + state.pc + 1 ); val = *( int64_t* )( p_code + state.pc + 1 + ( int32_t )sizeof( int32_t ) ); if( addr < 0 || addr > c_max_to_multiply || ( addr * 8 ) < 0 || ( addr * 8 ) + ( int32_t )sizeof( int64_t ) > dsize ) return -1; else return 0; } } int process_op( int8_t* p_code, int32_t csize, int8_t* p_data, int32_t dsize, int32_t cssize, int32_t ussize, bool disassemble, bool determine_jumps, machine_state& state ) { int rc = 0; bool invalid = false; bool had_overflow = false; if( csize < 1 || state.pc >= csize ) return 0; if( determine_jumps ) state.jumps.insert( state.pc ); int8_t op = p_code[ state.pc ]; if( op && disassemble && !determine_jumps ) { cout << hex << setw( 8 ) << setfill( '0' ) << state.pc; if( state.pc == state.opc ) cout << "* "; else cout << " "; } if( op == e_op_code_NOP ) { if( disassemble ) { if( !determine_jumps ) cout << "NOP\n"; while( true ) { ++rc; if( state.pc + rc >= csize || p_code[ state.pc + rc ] != e_op_code_NOP ) break; } } else while( true ) { ++rc; ++state.pc; if( state.pc >= csize || p_code[ state.pc ] != e_op_code_NOP ) break; } } else if( op == e_op_code_SET_VAL ) { int32_t addr; int64_t val; rc = get_addr_val( p_code, csize, dsize, state, addr, val ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int32_t ) + sizeof( int64_t ); if( disassemble ) { if( !determine_jumps ) cout << "SET @" << hex << setw( 8 ) << setfill( '0' ) << addr << " #" << setw( 16 ) << setfill( '0' ) << val << '\n'; } else { state.pc += rc; *( int64_t* )( p_data + ( addr * 8 ) ) = val; } } } else if( op == e_op_code_SET_DAT ) { int32_t addr1, addr2; rc = get_addrs( p_code, csize, dsize, state, addr1, addr2 ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int32_t ) + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) cout << "SET @" << hex << setw( 8 ) << setfill( '0' ) << addr1 << " $" << setw( 8 ) << setfill( '0' ) << addr2 << '\n'; } else { state.pc += rc; *( int64_t* )( p_data + ( addr1 * 8 ) ) = *( int64_t* )( p_data + ( addr2 * 8 ) ); } } } else if( op == e_op_code_CLR_DAT ) { int32_t addr; rc = get_addr( p_code, csize, dsize, state, addr ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) cout << "CLR @" << hex << setw( 8 ) << setfill( '0' ) << addr << '\n'; } else { state.pc += rc; *( int64_t* )( p_data + ( addr * 8 ) ) = 0; } } } else if( op == e_op_code_INC_DAT || op == e_op_code_DEC_DAT || op == e_op_code_NOT_DAT ) { int32_t addr; rc = get_addr( p_code, csize, dsize, state, addr ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) { if( op == e_op_code_INC_DAT ) cout << "INC @"; else if( op == e_op_code_DEC_DAT ) cout << "DEC @"; else cout << "NOT @"; cout << hex << setw( 8 ) << setfill( '0' ) << addr << '\n'; } } else { state.pc += rc; if( op == e_op_code_INC_DAT ) ++*( int64_t* )( p_data + ( addr * 8 ) ); else if( op == e_op_code_DEC_DAT ) --*( int64_t* )( p_data + ( addr * 8 ) ); else *( int64_t* )( p_data + ( addr * 8 ) ) = ~*( int64_t* )( p_data + ( addr * 8 ) ); } } } else if( op == e_op_code_ADD_DAT || op == e_op_code_SUB_DAT || op == e_op_code_MUL_DAT || op == e_op_code_DIV_DAT ) { int32_t addr1, addr2; rc = get_addrs( p_code, csize, dsize, state, addr1, addr2 ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int32_t ) + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) { if( op == e_op_code_ADD_DAT ) cout << "ADD @"; else if( op == e_op_code_SUB_DAT ) cout << "SUB @"; else if( op == e_op_code_MUL_DAT ) cout << "MUL @"; else cout << "DIV @"; cout << hex << setw( 8 ) << setfill( '0' ) << addr1 << " $" << setw( 8 ) << setfill( '0' ) << addr2 << '\n'; } } else { int64_t val = *( int64_t* )( p_data + ( addr2 * 8 ) ); if( op == e_op_code_DIV_DAT && val == 0 ) rc = -2; else { state.pc += rc; if( op == e_op_code_ADD_DAT ) *( int64_t* )( p_data + ( addr1 * 8 ) ) += *( int64_t* )( p_data + ( addr2 * 8 ) ); else if( op == e_op_code_SUB_DAT ) *( int64_t* )( p_data + ( addr1 * 8 ) ) -= *( int64_t* )( p_data + ( addr2 * 8 ) ); else if( op == e_op_code_MUL_DAT ) *( int64_t* )( p_data + ( addr1 * 8 ) ) *= *( int64_t* )( p_data + ( addr2 * 8 ) ); else *( int64_t* )( p_data + ( addr1 * 8 ) ) /= *( int64_t* )( p_data + ( addr2 * 8 ) ); } } } } else if( op == e_op_code_BOR_DAT || op == e_op_code_AND_DAT || op == e_op_code_XOR_DAT ) { int32_t addr1, addr2; rc = get_addrs( p_code, csize, dsize, state, addr1, addr2 ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int32_t ) + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) { if( op == e_op_code_BOR_DAT ) cout << "BOR @"; else if( op == e_op_code_AND_DAT ) cout << "AND @"; else cout << "XOR @"; cout << hex << setw( 8 ) << setfill( '0' ) << addr1 << " $" << setw( 8 ) << setfill( '0' ) << addr2 << '\n'; } } else { state.pc += rc; int64_t val = *( int64_t* )( p_data + ( addr2 * 8 ) ); if( op == e_op_code_BOR_DAT ) *( int64_t* )( p_data + ( addr1 * 8 ) ) |= val; else if( op == e_op_code_AND_DAT ) *( int64_t* )( p_data + ( addr1 * 8 ) ) &= val; else *( int64_t* )( p_data + ( addr1 * 8 ) ) ^= val; } } } else if( op == e_op_code_SET_IND ) { int32_t addr1, addr2; rc = get_addrs( p_code, csize, dsize, state, addr1, addr2 ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int32_t ) + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) cout << "SET @" << hex << setw( 8 ) << setfill( '0' ) << addr1 << " $($" << setw( 8 ) << setfill( '0' ) << addr2 << ")\n"; } else { int64_t addr = *( int64_t* )( p_data + ( addr2 * 8 ) ); if( addr < 0 || addr > c_max_to_multiply || ( addr * 8 ) < 0 || ( addr * 8 ) + ( int32_t )sizeof( int64_t ) > dsize ) rc = -1; else { state.pc += rc; *( int64_t* )( p_data + ( addr1 * 8 ) ) = *( int64_t* )( p_data + ( addr * 8 ) ); } } } } else if( op == e_op_code_SET_IDX ) { int32_t addr1, addr2; rc = get_addrs( p_code, csize, dsize, state, addr1, addr2 ); int32_t size = sizeof( int32_t ) + sizeof( int32_t ); if( rc == 0 || disassemble ) { int32_t addr3; rc = get_addr( p_code + size, csize, dsize, state, addr3 ); if( rc == 0 || disassemble ) { rc = 1 + size + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) cout << "SET @" << hex << setw( 8 ) << setfill( '0' ) << addr1 << " $($" << setw( 8 ) << setfill( '0' ) << addr2 << "+$" << setw( 8 ) << setfill( '0' ) << addr3 << ")\n"; } else { int64_t base = *( int64_t* )( p_data + ( addr2 * 8 ) ); int64_t offs = *( int64_t* )( p_data + ( addr3 * 8 ) ); int64_t addr = base + offs; if( addr < 0 || addr > c_max_to_multiply || ( addr * 8 ) < 0 || ( addr * 8 ) + ( int32_t )sizeof( int64_t ) > dsize ) rc = -1; else { state.pc += rc; *( int64_t* )( p_data + ( addr1 * 8 ) ) = *( int64_t* )( p_data + ( addr * 8 ) ); } } } } } else if( op == e_op_code_PSH_DAT || op == e_op_code_POP_DAT ) { int32_t addr; rc = get_addr( p_code, csize, dsize, state, addr ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) { if( op == e_op_code_PSH_DAT ) cout << "PSH $"; else cout << "POP @"; cout << hex << setw( 8 ) << setfill( '0' ) << addr << '\n'; } } else if( ( op == e_op_code_PSH_DAT && state.us == ( ussize / 8 ) ) || ( op == e_op_code_POP_DAT && state.us == 0 ) ) rc = -1; else { state.pc += rc; if( op == e_op_code_PSH_DAT ) *( int64_t* )( p_data + dsize + cssize + ussize - ( ++state.us * 8 ) ) = *( int64_t* )( p_data + ( addr * 8 ) ); else *( int64_t* )( p_data + ( addr * 8 ) ) = *( int64_t* )( p_data + dsize + cssize + ussize - ( state.us-- * 8 ) ); } } } else if( op == e_op_code_JMP_SUB ) { int32_t addr; rc = get_addr( p_code, csize, dsize, state, addr, true ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) cout << "JSR :" << hex << setw( 8 ) << setfill( '0' ) << addr << '\n'; } else { if( state.cs == ( cssize / 8 ) ) rc = -1; else if( state.jumps.count( addr ) ) { *( int64_t* )( p_data + dsize + cssize - ( ++state.cs * 8 ) ) = state.pc + rc; state.pc = addr; } else rc = -2; } } } else if( op == e_op_code_RET_SUB ) { rc = 1; if( disassemble ) { if( !determine_jumps ) cout << "RET\n"; } else { if( state.cs == 0 ) rc = -1; else { int64_t val = *( int64_t* )( p_data + dsize + cssize - ( state.cs-- * 8 ) ); int32_t addr = ( int32_t )val; if( state.jumps.count( addr ) ) state.pc = addr; else rc = -2; } } } else if( op == e_op_code_IND_DAT ) { int32_t addr1, addr2; rc = get_addrs( p_code, csize, dsize, state, addr1, addr2 ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int32_t ) + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) cout << "SET @($" << hex << setw( 8 ) << setfill( '0' ) << addr1 << ") $" << setw( 8 ) << setfill( '0' ) << addr2 << "\n"; } else { int64_t addr = *( int64_t* )( p_data + ( addr1 * 8 ) ); if( addr < 0 || addr > c_max_to_multiply || ( addr * 8 ) < 0 || ( addr * 8 ) + ( int32_t )sizeof( int64_t ) > dsize ) rc = -1; else { state.pc += rc; *( int64_t* )( p_data + ( addr * 8 ) ) = *( int64_t* )( p_data + ( addr2 * 8 ) ); } } } } else if( op == e_op_code_IDX_DAT ) { int32_t addr1, addr2; rc = get_addrs( p_code, csize, dsize, state, addr1, addr2 ); int32_t size = sizeof( int32_t ) + sizeof( int32_t ); if( rc == 0 || disassemble ) { int32_t addr3; rc = get_addr( p_code + size, csize, dsize, state, addr3 ); if( rc == 0 || disassemble ) { rc = 1 + size + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) cout << "SET @($" << hex << setw( 8 ) << setfill( '0' ) << addr1 << "+$" << setw( 8 ) << setfill( '0' ) << addr2 << ") $" << setw( 8 ) << setfill( '0' ) << addr3 << "\n"; } else { int64_t base = *( int64_t* )( p_data + ( addr1 * 8 ) ); int64_t offs = *( int64_t* )( p_data + ( addr2 * 8 ) ); int64_t addr = base + offs; if( addr < 0 || addr > c_max_to_multiply || ( addr * 8 ) < 0 || ( addr * 8 ) + ( int32_t )sizeof( int64_t ) > dsize ) rc = -1; else { state.pc += rc; *( int64_t* )( p_data + ( addr * 8 ) ) = *( int64_t* )( p_data + ( addr3 * 8 ) ); } } } } } else if( op == e_op_code_MOD_DAT ) { int32_t addr1, addr2; rc = get_addrs( p_code, csize, dsize, state, addr1, addr2 ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int32_t ) + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) { cout << "MOD @" << hex << setw( 8 ) << setfill( '0' ) << addr1 << " $" << setw( 16 ) << setfill( '0' ) << addr2 << '\n'; } } else { state.pc += rc; int64_t val = *( int64_t* )( p_data + ( addr2 * 8 ) ); *( int64_t* )( p_data + ( addr1 * 8 ) ) %= val; } } } else if( op == e_op_code_SHL_DAT ) { int32_t addr1, addr2; rc = get_addrs( p_code, csize, dsize, state, addr1, addr2 ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int32_t ) + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) { cout << "SHL @" << hex << setw( 8 ) << setfill( '0' ) << addr1 << " $" << setw( 16 ) << setfill( '0' ) << addr2 << '\n'; } } else { state.pc += rc; int64_t val = *( int64_t* )( p_data + ( addr2 * 8 ) ); *( int64_t* )( p_data + ( addr1 * 8 ) ) <<= val; } } } else if( op == e_op_code_SHR_DAT ) { int32_t addr1, addr2; rc = get_addrs( p_code, csize, dsize, state, addr1, addr2 ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int32_t ) + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) { cout << "SHR @" << hex << setw( 8 ) << setfill( '0' ) << addr1 << " $" << setw( 16 ) << setfill( '0' ) << addr2 << '\n'; } } else { state.pc += rc; int64_t val = *( int64_t* )( p_data + ( addr2 * 8 ) ); *( int64_t* )( p_data + ( addr1 * 8 ) ) >>= val; } } } else if( op == e_op_code_JMP_ADR ) { int32_t addr; rc = get_addr( p_code, csize, dsize, state, addr, true ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) cout << "JMP :" << hex << setw( 8 ) << setfill( '0' ) << addr << '\n'; } else if( state.jumps.count( addr ) ) state.pc = addr; else rc = -2; } } else if( op == e_op_code_BZR_DAT || op == e_op_code_BNZ_DAT ) { int8_t off; int32_t addr; rc = get_addr_off( p_code, csize, dsize, state, addr, off ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int32_t ) + sizeof( int8_t ); if( disassemble ) { if( !determine_jumps ) { if( op == e_op_code_BZR_DAT ) cout << "BZR $"; else cout << "BNZ $"; cout << hex << setw( 8 ) << setfill( '0' ) << addr << " :" << setw( 8 ) << setfill( '0' ) << ( state.pc + off ) << '\n'; } } else { int64_t val = *( int64_t* )( p_data + ( addr * 8 ) ); if( ( op == e_op_code_BZR_DAT && val == 0 ) || ( op == e_op_code_BNZ_DAT && val != 0 ) ) { if( state.jumps.count( state.pc + off ) ) state.pc += off; else rc = -2; } else state.pc += rc; } } } else if( op == e_op_code_BGT_DAT || op == e_op_code_BLT_DAT || op == e_op_code_BGE_DAT || op == e_op_code_BLE_DAT || op == e_op_code_BEQ_DAT || op == e_op_code_BNE_DAT ) { int8_t off; int32_t addr1, addr2; rc = get_addrs_off( p_code, csize, dsize, state, addr1, addr2, off ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int32_t ) + sizeof( int32_t ) + sizeof( int8_t ); if( disassemble ) { if( !determine_jumps ) { if( op == e_op_code_BGT_DAT ) cout << "BGT $"; else if( op == e_op_code_BLT_DAT ) cout << "BLT $"; else if( op == e_op_code_BGE_DAT ) cout << "BGE $"; else if( op == e_op_code_BLE_DAT ) cout << "BLE $"; else if( op == e_op_code_BEQ_DAT ) cout << "BEQ $"; else cout << "BNE $"; cout << hex << setw( 8 ) << setfill( '0' ) << addr1 << " $" << setw( 8 ) << setfill( '0' ) << addr2 << " :" << setw( 8 ) << setfill( '0' ) << ( state.pc + off ) << '\n'; } } else { int64_t val1 = *( int64_t* )( p_data + ( addr1 * 8 ) ); int64_t val2 = *( int64_t* )( p_data + ( addr2 * 8 ) ); if( ( op == e_op_code_BGT_DAT && val1 > val2 ) || ( op == e_op_code_BLT_DAT && val1 < val2 ) || ( op == e_op_code_BGE_DAT && val1 >= val2 ) || ( op == e_op_code_BLE_DAT && val1 <= val2 ) || ( op == e_op_code_BEQ_DAT && val1 == val2 ) || ( op == e_op_code_BNE_DAT && val1 != val2 ) ) { if( state.jumps.count( state.pc + off ) ) state.pc += off; else rc = -2; } else state.pc += rc; } } } else if( op == e_op_code_SLP_DAT ) { int32_t addr; rc = get_addr( p_code, csize, dsize, state, addr, true ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) cout << "SLP @" << hex << setw( 8 ) << setfill( '0' ) << addr << '\n'; } else { // NOTE: The "sleep_until" state value would be set to the current block + $addr. state.pc += rc; } } } else if( op == e_op_code_FIZ_DAT || op == e_op_code_STZ_DAT ) { int32_t addr; rc = get_addr( p_code, csize, dsize, state, addr ); if( rc == 0 || disassemble ) { if( disassemble ) { rc = 1 + sizeof( int32_t ); if( !determine_jumps ) { if( op == e_op_code_FIZ_DAT ) cout << "FIZ $"; else cout << "STZ $"; cout << hex << setw( 8 ) << setfill( '0' ) << addr << '\n'; } } else { if( *( int64_t* )( p_data + ( addr * 8 ) ) == 0 ) { if( op == e_op_code_STZ_DAT ) { state.pc += rc; state.stopped = true; } else { state.pc = state.pcs; state.finished = true; } } else { rc = 1 + sizeof( int32_t ); state.pc += rc; } } } } else if( op == e_op_code_FIN_IMD || op == e_op_code_STP_IMD ) { if( disassemble ) { rc = 1; if( !determine_jumps ) { if( op == e_op_code_FIN_IMD ) cout << "FIN\n"; else cout << "STP\n"; } } else if( op == e_op_code_STP_IMD ) { state.pc += rc; state.stopped = true; } else { state.pc = state.pcs; state.finished = true; } } else if( op == e_op_code_SLP_IMD ) { if( rc == 0 || disassemble ) { rc = 1; if( disassemble ) { if( !determine_jumps ) cout << "SLP\n"; } else { // NOTE: The "sleep_until" state value would be set to the current block + 1. state.pc += rc; } } } else if( op == e_op_code_ERR_ADR ) { int32_t addr; rc = get_addr( p_code, csize, dsize, state, addr, true ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) cout << "ERR :" << hex << setw( 8 ) << setfill( '0' ) << addr << '\n'; } else if( state.jumps.count( addr ) ) state.pce = addr; else rc = -3; } } else if( op == e_op_code_SET_PCS ) { rc = 1; if( disassemble ) { if( !determine_jumps ) cout << "PCS\n"; } else { state.pc += rc; state.pcs = state.pc; } } else if( op == e_op_code_EXT_FUN ) { int16_t fun; rc = get_fun( p_code, csize, state, fun ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int16_t ); if( disassemble ) { if( !determine_jumps ) { if( fun < 0x100 ) cout << "FUN " << dec << fun << "\n"; else cout << "FUN " << decode_function_name( fun, op ) << "\n"; } } else { state.pc += rc; func( fun, state ); } } } else if( op == e_op_code_EXT_FUN_DAT ) { int16_t fun; int32_t addr; rc = get_fun_addr( p_code, csize, dsize, state, fun, addr ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int16_t ) + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) { if( fun < 0x100 ) cout << "FUN " << dec << fun << " $" << hex << setw( 8 ) << setfill( '0' ) << addr << "\n"; else cout << "FUN " << decode_function_name( fun, op ) << " $" << hex << setw( 8 ) << setfill( '0' ) << addr << "\n"; } } else { state.pc += rc; int64_t val = *( int64_t* )( p_data + ( addr * 8 ) ); func1( fun, state, val, p_data, dsize ); } } } else if( op == e_op_code_EXT_FUN_DAT_2 ) { int16_t fun; int32_t addr1, addr2; rc = get_fun_addrs( p_code, csize, dsize, state, fun, addr1, addr2 ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int16_t ) + sizeof( int32_t ) + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) { if( fun < 0x100 ) cout << "FUN " << dec << fun << " $" << hex << setw( 8 ) << setfill( '0' ) << addr1 << " $" << setw( 8 ) << setfill( '0' ) << addr2 << "\n"; else cout << "FUN " << decode_function_name( fun, op ) << " $" << hex << setw( 8 ) << setfill( '0' ) << addr1 << " $" << setw( 8 ) << setfill( '0' ) << addr2 << "\n"; } } else { state.pc += rc; int64_t val1 = *( int64_t* )( p_data + ( addr1 * 8 ) ); int64_t val2 = *( int64_t* )( p_data + ( addr2 * 8 ) ); func2( fun, state, val1, val2, p_data, dsize ); } } } else if( op == e_op_code_EXT_FUN_RET ) { int16_t fun; int32_t addr; rc = get_fun_addr( p_code, csize, dsize, state, fun, addr ); if( rc == 0 || disassemble ) { rc = 1 + sizeof( int16_t ) + sizeof( int32_t ); if( disassemble ) { if( !determine_jumps ) { if( fun < 0x100 ) cout << "FUN @" << hex << setw( 8 ) << setfill( '0' ) << addr << ' ' << dec << fun << '\n'; else cout << "FUN @" << hex << setw( 8 ) << setfill( '0' ) << addr << " " << decode_function_name( fun, op ) << '\n'; } } else { state.pc += rc; *( int64_t* )( p_data + ( addr * 8 ) ) = func( fun, state ); } } } else if( op == e_op_code_EXT_FUN_RET_DAT || op == e_op_code_EXT_FUN_RET_DAT_2 ) { int16_t fun; int32_t addr1, addr2; rc = get_fun_addrs( p_code, csize, dsize, state, fun, addr1, addr2 ); int32_t size = sizeof( int16_t ) + sizeof( int32_t ) + sizeof( int32_t ); int32_t addr3; if( ( rc == 0 || disassemble ) && op == e_op_code_EXT_FUN_RET_DAT_2 ) rc = get_addr( p_code + size, csize, dsize, state, addr3 ); if( rc == 0 || disassemble ) { rc = 1 + size + ( op == e_op_code_EXT_FUN_RET_DAT_2 ? sizeof( int32_t ) : 0 ); if( disassemble ) { if( !determine_jumps ) { if( fun < 0x100 ) cout << "FUN @" << hex << setw( 8 ) << setfill( '0' ) << addr1 << ' ' << dec << fun << " $" << setw( 8 ) << setfill( '0' ) << addr2; else cout << "FUN @" << hex << setw( 8 ) << setfill( '0' ) << addr1 << " " << decode_function_name( fun, op ) << " $" << setw( 8 ) << setfill( '0' ) << addr2; if( op == e_op_code_EXT_FUN_RET_DAT_2 ) cout << " $" << setw( 8 ) << setfill( '0' ) << addr3; cout << "\n"; } } else { state.pc += rc; int64_t val = *( int64_t* )( p_data + ( addr2 * 8 ) ); if( op != e_op_code_EXT_FUN_RET_DAT_2 ) *( int64_t* )( p_data + ( addr1 * 8 ) ) = func1( fun, state, val, p_data, dsize ); else { int64_t val2 = *( int64_t* )( p_data + ( addr3 * 8 ) ); *( int64_t* )( p_data + ( addr1 * 8 ) ) = func2( fun, state, val, val2, p_data, dsize ); } } } } else { if( !disassemble ) rc = -2; } if( rc == -1 && state.pce ) { rc = 0; state.pc = state.pce; } if( rc == -1 && disassemble && !determine_jumps ) cout << "\n(overflow)\n"; if( rc == -2 && disassemble && !determine_jumps ) cout << "\n(invalid op)\n"; if( rc >= 0 ) ++state.steps; return rc; } void dump_state( const machine_state& state ) { cout << "pc: " << hex << setw( 8 ) << setfill( '0' ) << state.pc << '\n'; cout << "cs: " << dec << state.cs << '\n'; cout << "us: " << dec << state.us << '\n'; cout << "pce: " << hex << setw( 8 ) << setfill( '0' ) << state.pcs << '\n'; cout << "pcs: " << hex << setw( 8 ) << setfill( '0' ) << state.pcs << '\n'; cout << "steps: " << dec << state.steps << '\n'; cout << "a1: " << hex << setw( 16 ) << setfill( '0' ) << state.a1 << '\n'; cout << "a2: " << hex << setw( 16 ) << setfill( '0' ) << state.a2 << '\n'; cout << "a3: " << hex << setw( 16 ) << setfill( '0' ) << state.a3 << '\n'; cout << "a4: " << hex << setw( 16 ) << setfill( '0' ) << state.a4 << '\n'; cout << "b1: " << hex << setw( 16 ) << setfill( '0' ) << state.b1 << '\n'; cout << "b2: " << hex << setw( 16 ) << setfill( '0' ) << state.b2 << '\n'; cout << "b3: " << hex << setw( 16 ) << setfill( '0' ) << state.b3 << '\n'; cout << "b4: " << hex << setw( 16 ) << setfill( '0' ) << state.b4 << '\n'; } void dump_bytes( int8_t* p_bytes, int num ) { for( int i = 0; i < num; i += 16 ) { cout << hex << setw( 8 ) << setfill( '0' ) << i << ' '; for( int j = 0; j < 16; j++ ) { int val = ( unsigned char )p_bytes[ i + j ]; cout << ' ' << hex << setw( 2 ) << setfill( '0' ) << val; } cout << '\n'; } } void list_code( machine_state& state, int8_t* p_code, int32_t csize, int8_t* p_data, int32_t dsize, int32_t cssize, int32_t ussize, bool determine_jumps = false ) { int32_t opc = state.pc; int32_t osteps = state.steps; state.pc = 0; state.opc = opc; while( true ) { int rc = process_op( p_code, csize, p_data, dsize, cssize, ussize, true, determine_jumps, state ); if( rc <= 0 ) break; state.pc += rc; } state.steps = osteps; state.pc = opc; } bool check_has_balance( ) { if( g_balance == 0 ) { cout << "(stopped - zero balance)\n"; return false; } else return true; } void reset_machine( machine_state& state, int8_t* p_code, int32_t csize, int8_t* p_data, int32_t dsize, int32_t cssize, int32_t ussize ) { state.reset( ); list_code( state, p_code, csize, p_data, dsize, cssize, ussize, true ); memset( p_data, 0, dsize + cssize + ussize ); g_first_call = true; for( map< int32_t, function_data >::iterator i = g_function_data.begin( ); i != g_function_data.end( ); ++i ) i->second.offset = 0; } int main( ) { auto_ptr< int8_t > ap_code( new int8_t[ g_code_pages * c_code_page_bytes ] ); auto_ptr< int8_t > ap_data( new int8_t[ g_data_pages * c_data_page_bytes + g_call_stack_pages * c_call_stack_page_bytes + g_user_stack_pages * c_user_stack_page_bytes ] ); memset( ap_code.get( ), 0, g_code_pages * c_code_page_bytes ); memset( ap_data.get( ), 0, g_data_pages * c_data_page_bytes + g_call_stack_pages * c_call_stack_page_bytes + g_user_stack_pages * c_user_stack_page_bytes ); machine_state state; set< int32_t > break_points; string cmd, next; while( cout << "\n> ", getline( cin, next ) ) { if( next.empty( ) ) continue; string::size_type pos = next.find( ' ' ); if( pos == string::npos ) { cmd = next; next.erase( ); } else { cmd = next.substr( 0, pos ); next.erase( 0, pos + 1 ); } string arg_1, arg_2, arg_3; pos = next.find( ' ' ); arg_1 = next.substr( 0, pos ); if( pos != string::npos ) { arg_2 = next.substr( pos + 1 ); pos = arg_2.find( ' ' ); if( pos != string::npos ) { arg_3 = arg_2.substr( pos + 1 ); arg_2.erase( pos ); } } if( cmd == "?" || cmd == "help" ) { cout << "commands:\n"; cout << "---------\n"; cout << "code <hex byte values> [<[0x]offset>]\n"; cout << "data <hex byte values> [<[0x]offset>]\n"; cout << "run\n"; cout << "cont\n"; cout << "dump {code|data|stacks}\n"; cout << "list\n"; cout << "load <file>\n"; cout << "save <file>\n"; cout << "size [{code|data|call|user} [<pages>]]\n"; cout << "step [<num_steps>]\n"; cout << "break <[0x]value>\n"; cout << "reset\n"; cout << "state\n"; cout << "balance [<amount>]\n"; cout << "function <[+]#> [<[0x]value1[,[0x]value2[,...]]>] [loop]\n"; cout << "functions\n"; cout << "help\n"; cout << "exit" << endl; } else if( ( cmd == "code" || cmd == "data" ) && arg_1.size( ) && ( arg_1.size( ) % 2 == 0 ) ) { int32_t offset = 0; if( !arg_2.empty( ) ) { if( arg_2.size( ) > 2 && arg_2.find( "0x" ) == 0 ) { istringstream isstr( arg_2.substr( 2 ) ); isstr >> hex >> offset; } else offset = atoi( arg_2.c_str( ) ); } int8_t* p_c = cmd == "code" ? ap_code.get( ) : ap_data.get( ) + offset; if( arg_2.empty( ) ) { if( cmd == "code" ) memset( p_c, 0, g_code_pages * c_code_page_bytes ); else memset( p_c, 0, g_data_pages * c_data_page_bytes ); } for( size_t i = 0; i < arg_1.size( ); i += 2 ) { unsigned int value; istringstream isstr( arg_1.substr( i, 2 ) ); isstr >> hex >> value; *( p_c + ( i / 2 ) ) = ( int8_t )value; } if( cmd == "code" ) reset_machine( state, ap_code.get( ), g_code_pages * c_code_page_bytes, ap_data.get( ), g_data_pages * c_data_page_bytes, g_call_stack_pages * c_call_stack_page_bytes, g_user_stack_pages * c_user_stack_page_bytes ); } else if( cmd == "run" || cmd == "cont" ) { if( cmd == "run" ) reset_machine( state, ap_code.get( ), g_code_pages * c_code_page_bytes, ap_data.get( ), g_data_pages * c_data_page_bytes, g_call_stack_pages * c_call_stack_page_bytes, g_user_stack_pages * c_user_stack_page_bytes ); while( true ) { if( !check_has_balance( ) ) break; int rc = process_op( ap_code.get( ), g_code_pages * c_code_page_bytes, ap_data.get( ), g_data_pages * c_data_page_bytes, g_call_stack_pages * c_call_stack_page_bytes, g_user_stack_pages * c_user_stack_page_bytes, false, false, state ); if( !check_has_balance( ) ) break; --g_balance; if( rc >= 0 ) { if( state.stopped ) { cout << "(stopped)\n"; cout << "total steps: " << dec << state.steps << '\n'; state.stopped = false; break; } else if( state.finished ) { cout << "(finished)\n"; cout << "total steps: " << dec << state.steps << '\n'; break; } if( break_points.count( state.pc ) ) { cout << "(break point)\n"; break; } } else { if( rc == -1 ) cout << "error: overflow\n"; else if( rc == -2 ) cout << "error: invalid code\n"; else cout << "unexpected error\n"; break; } } } else if( cmd == "dump" && ( next == "code" || next == "data" || next == "stacks" ) ) { if( next == "code" ) dump_bytes( ap_code.get( ), g_code_pages * c_code_page_bytes ); else if( next == "data" ) dump_bytes( ap_data.get( ), g_data_pages * c_data_page_bytes ); else dump_bytes( ap_data.get( ) + g_data_pages * c_data_page_bytes, g_call_stack_pages * c_call_stack_page_bytes + g_user_stack_pages * c_user_stack_page_bytes ); } else if( cmd == "list" ) list_code( state, ap_code.get( ), g_code_pages * c_code_page_bytes, ap_data.get( ), g_data_pages * c_data_page_bytes, g_call_stack_pages * c_call_stack_page_bytes, g_user_stack_pages * c_user_stack_page_bytes ); else if( cmd == "load" && !arg_1.empty( ) ) { ifstream inpf( arg_1.c_str( ), ios::in | ios::binary ); if( !inpf ) cout << "error: unable to open '" << arg_1 << "' for input" << endl; else { inpf.read( ( char* )&g_val, sizeof( g_val ) ); inpf.read( ( char* )&g_val1, sizeof( g_val1 ) ); inpf.read( ( char* )&g_balance, sizeof( g_balance ) ); inpf.read( ( char* )&g_first_call, sizeof( g_first_call ) ); inpf.read( ( char* )&g_increment_func, sizeof( g_increment_func ) ); inpf.read( ( char* )&state.pc, sizeof( state.pc ) ); inpf.read( ( char* )&state.cs, sizeof( state.cs ) ); inpf.read( ( char* )&state.us, sizeof( state.us ) ); inpf.read( ( char* )&state.pce, sizeof( state.pce ) ); inpf.read( ( char* )&state.pcs, sizeof( state.pcs ) ); inpf.read( ( char* )&state.steps, sizeof( state.steps ) ); inpf.read( ( char* )&state.a1, sizeof( state.a1 ) ); inpf.read( ( char* )&state.a2, sizeof( state.a2 ) ); inpf.read( ( char* )&state.a3, sizeof( state.a3 ) ); inpf.read( ( char* )&state.a4, sizeof( state.a4 ) ); inpf.read( ( char* )&state.b1, sizeof( state.b1 ) ); inpf.read( ( char* )&state.b2, sizeof( state.b2 ) ); inpf.read( ( char* )&state.b3, sizeof( state.b3 ) ); inpf.read( ( char* )&state.b4, sizeof( state.b4 ) ); inpf.read( ( char* )&g_code_pages, sizeof( g_code_pages ) ); ap_code.reset( new int8_t[ g_code_pages * c_code_page_bytes ] ); inpf.read( ( char* )ap_code.get( ), g_code_pages * c_code_page_bytes ); inpf.read( ( char* )&g_data_pages, sizeof( g_data_pages ) ); inpf.read( ( char* )&g_call_stack_pages, sizeof( g_call_stack_pages ) ); inpf.read( ( char* )&g_user_stack_pages, sizeof( g_user_stack_pages ) ); ap_data.reset( new int8_t[ g_data_pages * c_data_page_bytes + g_call_stack_pages * c_call_stack_page_bytes + g_user_stack_pages * c_user_stack_page_bytes ] ); inpf.read( ( char* )ap_data.get( ), g_data_pages * c_data_page_bytes + g_call_stack_pages * c_call_stack_page_bytes + g_user_stack_pages * c_user_stack_page_bytes ); g_function_data.clear( ); size_t size; inpf.read( ( char* )&size, sizeof( size_t ) ); for( size_t i = 0; i < size; i++ ) { int32_t func; inpf.read( ( char* )&func, sizeof( int32_t ) ); bool loop; inpf.read( ( char* )&loop, sizeof( bool ) ); size_t offset; inpf.read( ( char* )&offset, sizeof( size_t ) ); g_function_data[ func ].loop = loop; g_function_data[ func ].offset = offset; size_t dsize; inpf.read( ( char* )&dsize, sizeof( size_t ) ); for( size_t j = 0; j < dsize; j++ ) { int64_t next; inpf.read( ( char* )&next, sizeof( int64_t ) ); g_function_data[ func ].data.push_back( next ); } } inpf.close( ); list_code( state, ap_code.get( ), g_code_pages * c_code_page_bytes, ap_data.get( ), g_data_pages * c_data_page_bytes, g_call_stack_pages * c_call_stack_page_bytes, g_user_stack_pages * c_user_stack_page_bytes, true ); } } else if( cmd == "save" && !arg_1.empty( ) ) { ofstream outf( arg_1.c_str( ), ios::out | ios::binary ); if( !outf ) cout << "error: unable to open '" << arg_1 << "' for output" << endl; else { outf.write( ( const char* )&g_val, sizeof( g_val ) ); outf.write( ( const char* )&g_val1, sizeof( g_val1 ) ); outf.write( ( const char* )&g_balance, sizeof( g_balance ) ); outf.write( ( const char* )&g_first_call, sizeof( g_first_call ) ); outf.write( ( const char* )&g_increment_func, sizeof( g_increment_func ) ); outf.write( ( const char* )&state.pc, sizeof( state.pc ) ); outf.write( ( const char* )&state.cs, sizeof( state.cs ) ); outf.write( ( const char* )&state.us, sizeof( state.us ) ); outf.write( ( const char* )&state.pce, sizeof( state.pce ) ); outf.write( ( const char* )&state.pcs, sizeof( state.pcs ) ); outf.write( ( const char* )&state.steps, sizeof( state.steps ) ); outf.write( ( const char* )&state.a1, sizeof( state.a1 ) ); outf.write( ( const char* )&state.a2, sizeof( state.a2 ) ); outf.write( ( const char* )&state.a3, sizeof( state.a3 ) ); outf.write( ( const char* )&state.a4, sizeof( state.a4 ) ); outf.write( ( const char* )&state.b1, sizeof( state.b1 ) ); outf.write( ( const char* )&state.b2, sizeof( state.b2 ) ); outf.write( ( const char* )&state.b3, sizeof( state.b3 ) ); outf.write( ( const char* )&state.b4, sizeof( state.b4 ) ); outf.write( ( const char* )&g_code_pages, sizeof( g_code_pages ) ); outf.write( ( const char* )ap_code.get( ), g_code_pages * c_code_page_bytes ); outf.write( ( const char* )&g_data_pages, sizeof( g_data_pages ) ); outf.write( ( const char* )&g_call_stack_pages, sizeof( g_call_stack_pages ) ); outf.write( ( const char* )&g_user_stack_pages, sizeof( g_user_stack_pages ) ); outf.write( ( const char* )ap_data.get( ), g_data_pages * c_data_page_bytes + g_call_stack_pages * c_call_stack_page_bytes + g_user_stack_pages * c_user_stack_page_bytes ); size_t size = g_function_data.size( ); outf.write( ( const char* )&size, sizeof( size_t ) ); for( map< int32_t, function_data >::iterator i = g_function_data.begin( ); i != g_function_data.end( ); ++i ) { outf.write( ( const char* )&i->first, sizeof( int32_t ) ); outf.write( ( const char* )&i->second.loop, sizeof( bool ) ); outf.write( ( const char* )&i->second.offset, sizeof( size_t ) ); size_t dsize = i->second.data.size( ); outf.write( ( const char* )&dsize, sizeof( size_t ) ); for( size_t j = 0; j < dsize; j++ ) outf.write( ( const char* )&i->second.data[ j ], sizeof( int64_t ) ); } outf.close( ); } } else if( cmd == "size" ) { if( arg_1.empty( ) || arg_2.empty( ) ) { if( arg_1.empty( ) || arg_1 == "code" ) cout << "code (" << g_code_pages << " * " << c_code_page_bytes << ") = " << ( g_code_pages * c_code_page_bytes ) << " bytes\n"; if( arg_1.empty( ) || arg_1 == "data" ) cout << "data (" << g_data_pages << " * " << c_data_page_bytes << ") = " << ( g_data_pages * c_data_page_bytes ) << " bytes\n"; if( arg_1.empty( ) || arg_1 == "call" ) cout << "call (" << g_call_stack_pages << " * " << c_call_stack_page_bytes << ") = " << ( g_call_stack_pages * c_call_stack_page_bytes ) << " bytes\n"; if( arg_1.empty( ) || arg_1 == "user" ) cout << "user (" << g_user_stack_pages << " * " << c_user_stack_page_bytes << ") = " << ( g_user_stack_pages * c_user_stack_page_bytes ) << " bytes\n"; } else { int pages = atoi( arg_2.c_str( ) ); if( pages <= 0 ) throw runtime_error( "invalid # pages value: " + arg_2 ); if( arg_1 == "code" ) { g_code_pages = pages; ap_code.reset( new int8_t[ g_code_pages * c_code_page_bytes ] ); memset( ap_code.get( ), 0, g_code_pages * c_code_page_bytes ); } else { if( arg_1 == "data" ) g_data_pages = pages; else if( arg_1 == "call" ) g_call_stack_pages = pages; else if( arg_1 == "user" ) g_user_stack_pages = pages; else throw runtime_error( "unexpected arg_1 '" + arg_1 + "' for 'size' command" ); ap_data.reset( new int8_t[ g_data_pages * c_data_page_bytes + g_call_stack_pages * c_call_stack_page_bytes + g_user_stack_pages * c_user_stack_page_bytes ] ); memset( ap_data.get( ), 0, g_data_pages * c_data_page_bytes + g_call_stack_pages * c_call_stack_page_bytes + g_user_stack_pages * c_user_stack_page_bytes ); } } } else if( cmd == "step" ) { int32_t steps = 0; int32_t num_steps = 0; if( !arg_1.empty( ) ) num_steps = atoi( arg_1.c_str( ) ); if( state.finished ) reset_machine( state, ap_code.get( ), g_code_pages * c_code_page_bytes, ap_data.get( ), g_data_pages * c_data_page_bytes, g_call_stack_pages * c_call_stack_page_bytes, g_user_stack_pages * c_user_stack_page_bytes ); while( true ) { if( !check_has_balance( ) ) break; int rc = process_op( ap_code.get( ), g_code_pages * c_code_page_bytes, ap_data.get( ), g_data_pages * c_data_page_bytes, g_call_stack_pages * c_call_stack_page_bytes, g_user_stack_pages * c_user_stack_page_bytes, false, false, state ); if( !check_has_balance( ) ) break; --g_balance; if( rc >= 0 ) { ++steps; if( state.stopped || state.finished || num_steps && steps >= num_steps ) { if( state.stopped ) cout << "(stopped)\n"; else if( state.finished ) cout << "(finished)\n"; break; } else if( !num_steps ) break; } else { if( rc == -1 ) cout << "error: overflow\n"; else if( rc == -2 ) cout << "error: invalid code\n"; else cout << "unexpected error\n"; break; } } } else if( cmd == "break" ) { if( arg_1.empty( ) ) { for( set< int32_t >::iterator i = break_points.begin( ); i != break_points.end( ); ++i ) cout << *i << '\n'; } else { int32_t bp; if( arg_1.size( ) > 2 && arg_1.find( "0x" ) == 0 ) { istringstream isstr( arg_1.substr( 2 ) ); isstr >> hex >> bp; } else bp = atoi( arg_1.c_str( ) ); if( break_points.count( bp ) ) break_points.erase( bp ); else break_points.insert( bp ); } } else if( cmd == "reset" ) reset_machine( state, ap_code.get( ), g_code_pages * c_code_page_bytes, ap_data.get( ), g_data_pages * c_data_page_bytes, g_call_stack_pages * c_call_stack_page_bytes, g_user_stack_pages * c_user_stack_page_bytes ); else if( cmd == "state" ) dump_state( state ); else if( cmd == "balance" ) { if( arg_1.empty( ) ) cout << dec << g_balance << '\n'; else g_balance = atoi( arg_1.c_str( ) ); } else if( cmd == "function" && !arg_1.empty( ) ) { bool is_increment_func = false; if( arg_1[ 0 ] == '+' ) { is_increment_func = true; arg_1.erase( 0, 1 ); } int32_t func = atoi( arg_1.c_str( ) ); if( is_increment_func ) g_increment_func = func; if( ( !is_increment_func || !arg_2.empty( ) ) && g_function_data.count( func ) ) g_function_data.erase( func ); if( !arg_2.empty( ) ) { while( true ) { string::size_type pos = arg_2.find( ',' ); string next( arg_2.substr( 0, pos ) ); int64_t val; if( next.size( ) > 2 && next.find( "0x" ) == 0 ) { istringstream isstr( next ); isstr >> hex >> val; } else val = atoi( next.c_str( ) ); g_function_data[ func ].data.push_back( val ); if( pos == string::npos ) break; arg_2.erase( 0, pos + 1 ); } if( arg_3 == "true" ) g_function_data[ func ].loop = true; } } else if( cmd == "functions" ) { for( map< int32_t, function_data >::iterator i = g_function_data.begin( ); i != g_function_data.end( ); ++i ) { if( i->first == g_increment_func ) cout << '+'; else cout << ' '; cout << dec << setw( 3 ) << setfill( '0' ) << i->first; for( size_t j = 0; j < i->second.data.size( ); j++ ) cout << ( j == 0 ? ' ' : ',' ) << "0x" << hex << setw( 16 ) << i->second.data[ j ]; if( i->second.loop ) cout << " true\n"; else cout << " false\n"; } } else if( cmd == "quit" || cmd == "exit" ) break; else cout << "invalid command: " << cmd << endl; } } </pre> </div> </div> <div style="visibility: visible;" id="footer"> <p> <div class="footer-icon"><a target="_blank" href="//ciyam.org/"><img src="logo-gryscl-128.png" /></a></div> © 2012-2015 CIYAM Developers </p> </div> </body> </html>