6201 lines
210 KiB
C++
Executable File
6201 lines
210 KiB
C++
Executable File
//#define RCBASIC_DEBUG 1
|
|
|
|
#include "rc_os_defines.h"
|
|
|
|
#ifdef RC_WEB
|
|
#include <emscripten.h>
|
|
#endif
|
|
|
|
#ifdef RC_IOS
|
|
#define RC_GETCWD
|
|
#include <sys/param.h>
|
|
#endif
|
|
|
|
#ifdef RC_MAC
|
|
#define RC_GETCWD
|
|
#include <sys/param.h>
|
|
#endif
|
|
|
|
#ifdef RC_ANDROID
|
|
#define RC_GETCWD
|
|
#endif
|
|
|
|
#ifdef RC_WINDOWS
|
|
#include<windows.h>
|
|
#define _UNICODE
|
|
#endif // RC_WINDOWS
|
|
|
|
|
|
#ifdef RC_ANDROID
|
|
#include <jni.h>
|
|
#include <sys/param.h>
|
|
#include <algorithm>
|
|
#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_ERROR, "native-activity", __VA_ARGS__))
|
|
#endif // RC_ANDROID
|
|
|
|
#include <iostream>
|
|
#include <inttypes.h>
|
|
#include <fstream>
|
|
#ifdef RC_ANDROID
|
|
#include "SDL.h"
|
|
#else
|
|
#include <SDL2/SDL.h>
|
|
#endif
|
|
#include <math.h>
|
|
#include <vector>
|
|
#include <stack>
|
|
#include <limits>
|
|
#include <iomanip>
|
|
#include "rc_defines.h"
|
|
#include "rc_stdlib.h"
|
|
#include "rc_media.h"
|
|
#include "rc_matrix.h"
|
|
#include "rc_process.h"
|
|
#include "rc_geometry.h"
|
|
|
|
using namespace std;
|
|
|
|
#define LESS_FLAG 0
|
|
#define LESS_EQUAL_FLAG 1
|
|
#define GREATER_FLAG 2
|
|
#define GREATER_EQUAL_FLAG 3
|
|
#define EQUAL_FLAG 4
|
|
#define NOT_EQUAL_FLAG 5
|
|
|
|
#define CODE_SEGMENT 0
|
|
#define DATA_SEGMENT 1
|
|
|
|
#define RC_UDT_TYPE_NUM 0
|
|
#define RC_UDT_TYPE_STR 1
|
|
#define RC_UDT_TYPE_USR 2
|
|
|
|
|
|
bool CMP_FLAG_EQUAL = false;
|
|
bool CMP_FLAG_LESS = false;
|
|
bool CMP_FLAG_LESS_EQUAL = false;
|
|
bool CMP_FLAG_GREATER = false;
|
|
bool CMP_FLAG_GREATER_EQUAL = false;
|
|
bool CMP_FLAG_NOT_EQUAL = false;
|
|
|
|
string rcbasic_runtime_path = "";
|
|
|
|
struct n_value
|
|
{
|
|
vector<double> value;
|
|
void * ref_parent; // This will be set by the obj_get instructions (ie. obj_get and obj_usr_get)
|
|
};
|
|
|
|
struct s_value
|
|
{
|
|
vector<string> value;
|
|
void * ref_parent; // This will be set by the obj_get instructions (ie. obj_get and obj_usr_get)
|
|
};
|
|
|
|
struct rc_vm_n
|
|
{
|
|
double value;
|
|
n_value * r; //reference
|
|
uint64_t r_index;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
uint64_t dbg_var_index;
|
|
#endif // RCBASIC_DEBUG
|
|
};
|
|
|
|
struct rc_vm_s
|
|
{
|
|
string value;
|
|
s_value * r;
|
|
uint64_t r_index;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
uint64_t dbg_var_index;
|
|
#endif // RCBASIC_DEBUG
|
|
};
|
|
|
|
struct rc_numId
|
|
{
|
|
n_value nid_value;
|
|
int dimensions;
|
|
uint64_t dim[3];
|
|
uint64_t byref_offset;
|
|
|
|
n_value * nref;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
bool is_debug_var;
|
|
uint64_t dbg_var_index;
|
|
#endif // RCBASIC_DEBUG
|
|
};
|
|
|
|
struct rc_strId
|
|
{
|
|
s_value sid_value;
|
|
int dimensions;
|
|
uint64_t dim[3];
|
|
uint64_t byref_offset;
|
|
|
|
s_value * sref;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
bool is_debug_var;
|
|
uint64_t dbg_var_index;
|
|
#endif // RCBASIC_DEBUG
|
|
};
|
|
|
|
struct rc_udtFieldSize
|
|
{
|
|
uint64_t dim[3];
|
|
};
|
|
|
|
struct rc_udtDefinition
|
|
{
|
|
int num_fields;
|
|
vector<int> field_type; // 0 - num, 1 - str, 2 - UDT
|
|
vector<int> field_type_index; //if field type is UDT
|
|
vector<int> field_dimensions;
|
|
vector<rc_udtFieldSize> field_size;
|
|
};
|
|
|
|
vector<rc_udtDefinition> rc_types;
|
|
|
|
struct rc_usrId
|
|
{
|
|
vector<rc_numId> num_var;
|
|
vector<rc_strId> str_var;
|
|
vector<rc_usrId> uid_value;
|
|
int dimensions;
|
|
uint64_t dim[3];
|
|
uint64_t byref_offset;
|
|
int udt_index; //index of the type definition in rc_types
|
|
|
|
rc_usrId * var_ref;
|
|
uint64_t var_ref_index;
|
|
|
|
rc_usrId* byref_ptr;
|
|
|
|
bool preset_init = false;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
bool is_debug_var;
|
|
uint64_t dbg_var_index;
|
|
#endif // RCBASIC_DEBUG
|
|
};
|
|
|
|
struct rc_loop
|
|
{
|
|
rc_numId * counter;
|
|
double f_end;
|
|
double f_step;
|
|
bool isNegative;
|
|
uint64_t counter_offset;
|
|
#ifdef RCBASIC_DEBUG
|
|
uint64_t counter_dim[3];
|
|
#endif // RCBASIC_DEBUG
|
|
};
|
|
|
|
uint64_t for_offset_index[3];
|
|
int for_offset_dimensions = 0;
|
|
|
|
union rc_double
|
|
{
|
|
double f;
|
|
unsigned char data[sizeof(double)];
|
|
};
|
|
|
|
union rc_int
|
|
{
|
|
uint64_t i;
|
|
unsigned char data[sizeof(uint64_t)];
|
|
};
|
|
|
|
struct addr_entry
|
|
{
|
|
uint64_t ptr_id;
|
|
void * ptr_addr;
|
|
int type;
|
|
};
|
|
|
|
stack<addr_entry> byref_addr_table;
|
|
stack<uint64_t> byref_var_byref_offset;
|
|
|
|
uint64_t n_count = 0;
|
|
uint64_t s_count = 0;
|
|
uint64_t u_count = 0;
|
|
uint64_t n_stack_size = 0;
|
|
uint64_t s_stack_size = 0;
|
|
uint64_t u_stack_size = 0;
|
|
uint64_t loop_stack_size = 0;
|
|
uint64_t numID_count = 0;
|
|
uint64_t strID_count = 0;
|
|
uint64_t usrID_count = 0;
|
|
uint64_t code_segment_size = 0;
|
|
uint64_t data_segment_size = 0;
|
|
|
|
struct n_obj_struct
|
|
{
|
|
n_value * obj_val;
|
|
uint64_t index;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
uint64_t nid;
|
|
#endif // RCBASIC_DEBUG
|
|
};
|
|
|
|
struct s_obj_struct
|
|
{
|
|
s_value * obj_val;
|
|
uint64_t index;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
uint64_t sid;
|
|
#endif // RCBASIC_DEBUG
|
|
};
|
|
|
|
struct u_obj_struct
|
|
{
|
|
rc_usrId * obj_ref;
|
|
|
|
rc_numId * num_ref;
|
|
rc_strId * str_ref;
|
|
|
|
uint64_t index;
|
|
};
|
|
|
|
n_obj_struct num_object;
|
|
s_obj_struct str_object;
|
|
u_obj_struct usr_object;
|
|
|
|
rc_vm_n * vm_n;
|
|
rc_vm_s * vm_s;
|
|
rc_usrId * vm_u;
|
|
|
|
stack<rc_vm_n> n_stack;
|
|
stack<rc_vm_s> s_stack;
|
|
stack<rc_usrId> u_stack;
|
|
stack<rc_loop> loop_stack;
|
|
|
|
int current_n_stack_count = 0;
|
|
int current_s_stack_count = 0;
|
|
int current_u_stack_count = 0;
|
|
int current_loop_stack_count = 0;
|
|
|
|
rc_numId * num_var;
|
|
rc_strId * str_var;
|
|
rc_usrId * usr_var;
|
|
|
|
unsigned char ** segment;
|
|
|
|
int current_segment = CODE_SEGMENT;
|
|
uint64_t current_address = 0;
|
|
|
|
stack<uint64_t> gosub_return_addr;
|
|
|
|
rc_int readint_val;
|
|
rc_double readdouble_val;
|
|
|
|
vector<uint64_t> arr_ref_id(2);
|
|
|
|
bool redim_toplevel_flag = false;
|
|
|
|
int rcbasic_exit_code = 0;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
#define RCBASIC_DEBUG_VAR_NUM 0
|
|
#define RCBASIC_DEBUG_VAR_ARR_NUM 1
|
|
#define RCBASIC_DEBUG_VAR_BYREF_NUM 2
|
|
#define RCBASIC_DEBUG_VAR_STR 3
|
|
#define RCBASIC_DEBUG_VAR_ARR_STR 4
|
|
#define RCBASIC_DEBUG_VAR_BYREF_STR 5
|
|
|
|
#define RCBASIC_DEBUG_ACCESS_GET 0
|
|
#define RCBASIC_DEBUG_ACCESS_SET 1
|
|
|
|
struct rcbasic_debug_access_status
|
|
{
|
|
int type;
|
|
int dimensions;
|
|
int dim[3];
|
|
double num_val;
|
|
string str_val;
|
|
int reg;
|
|
bool is_error = false;
|
|
};
|
|
|
|
struct rcbasic_debug_vars
|
|
{
|
|
int type;
|
|
string scope;
|
|
string name;
|
|
int index;
|
|
vector<rcbasic_debug_access_status> usage_data;
|
|
};
|
|
|
|
vector<rcbasic_debug_vars> dbg_vars;
|
|
vector<string> dbg_files;
|
|
|
|
uint64_t current_src_line = 1;
|
|
uint64_t current_src_file = 0;
|
|
|
|
#define DBG_DIV_BY_ZERO "Divide By Zero"
|
|
#define DBG_NEGATIVE_INDEX "Negative Array Index"
|
|
#define DBG_INDEX_EXCEEDS_SIZE "Array Index is Greater than Array Size"
|
|
#define DBG_DIM_LEQ_ZERO "Array Size must be greater than Zero"
|
|
#define DBG_REDIM_LEQ_ZERO "Array Size must be greater than Zero"
|
|
|
|
bool dbg_error_found = false;
|
|
string dbg_error_message = "";
|
|
|
|
|
|
void loadDebugData(string sym_file, string inc_file)
|
|
{
|
|
fstream f(sym_file, fstream::in);
|
|
|
|
string f_line;
|
|
|
|
string type_str = "";
|
|
rcbasic_debug_vars tmp;
|
|
|
|
while(!f.eof())
|
|
{
|
|
getline(f, f_line);
|
|
|
|
type_str = f_line.substr(0, f_line.find_first_of(" "));
|
|
|
|
if(type_str.compare("N")==0)
|
|
{
|
|
tmp.type = RCBASIC_DEBUG_VAR_NUM;
|
|
}
|
|
else if(type_str.compare("AN")==0)
|
|
{
|
|
tmp.type = RCBASIC_DEBUG_VAR_ARR_NUM;
|
|
}
|
|
else if(type_str.compare("BN")==0)
|
|
{
|
|
tmp.type = RCBASIC_DEBUG_VAR_BYREF_NUM;
|
|
}
|
|
else if(type_str.compare("S")==0)
|
|
{
|
|
tmp.type = RCBASIC_DEBUG_VAR_STR;
|
|
}
|
|
else if(type_str.compare("AS")==0)
|
|
{
|
|
tmp.type = RCBASIC_DEBUG_VAR_ARR_STR;
|
|
}
|
|
else if(type_str.compare("BS")==0)
|
|
{
|
|
tmp.type = RCBASIC_DEBUG_VAR_BYREF_STR;
|
|
}
|
|
|
|
f_line = f_line.substr(f_line.find_first_of(" ")+1);
|
|
tmp.scope = f_line.substr(0, f_line.find_first_of(" "));
|
|
|
|
f_line = f_line.substr(f_line.find_first_of(" ")+1);
|
|
tmp.name = f_line.substr(0, f_line.find_first_of(" "));
|
|
|
|
f_line = f_line.substr(f_line.find_first_of(" ")+1);
|
|
tmp.index = atoi(f_line.c_str());
|
|
|
|
switch(tmp.type)
|
|
{
|
|
case RCBASIC_DEBUG_VAR_NUM:
|
|
case RCBASIC_DEBUG_VAR_ARR_NUM:
|
|
case RCBASIC_DEBUG_VAR_BYREF_NUM:
|
|
num_var[tmp.index].dbg_var_index = dbg_vars.size();
|
|
num_var[tmp.index].is_debug_var = true;
|
|
break;
|
|
case RCBASIC_DEBUG_VAR_STR:
|
|
case RCBASIC_DEBUG_VAR_ARR_STR:
|
|
case RCBASIC_DEBUG_VAR_BYREF_STR:
|
|
str_var[tmp.index].dbg_var_index = dbg_vars.size();
|
|
str_var[tmp.index].is_debug_var = true;
|
|
break;
|
|
}
|
|
|
|
dbg_vars.push_back(tmp);
|
|
}
|
|
|
|
f.close();
|
|
|
|
f.open(inc_file, fstream::in);
|
|
|
|
while(!f.eof())
|
|
{
|
|
getline(f, f_line);
|
|
if(f_line.find_first_not_of(" ")!=string::npos)
|
|
dbg_files.push_back(f_line);
|
|
}
|
|
|
|
f.close();
|
|
}
|
|
|
|
string dbg_format_string(string dbg_str_val)
|
|
{
|
|
string rtn = dbg_str_val;
|
|
rtn = rc_intern_replace(rtn, "\n", "\\n");
|
|
rtn = rc_intern_replace(rtn, "\r", "\\r");
|
|
rtn = rc_intern_replace(rtn, "\t", "\\t");
|
|
return rtn;
|
|
}
|
|
|
|
void output_debug_message()
|
|
{
|
|
//cout << "output debug messages" << endl;
|
|
|
|
if(rc_intern_fileExist("rcbasic_dbg.sp") && (!dbg_error_found))
|
|
{
|
|
//if(rc_intern_fileExist("rcbasic.dbgm"))
|
|
// rc_intern_fileDelete("rcbasic.dbgm");
|
|
|
|
/*if(rc_intern_fileExist("rcbasic_dbg.rt"))
|
|
{
|
|
while(rc_intern_fileExist("rcbasic_dbg.rt"))
|
|
{
|
|
rc_intern_fileDelete("rcbasic_dbg.rt"); //keep trying to delete file
|
|
}
|
|
|
|
fstream f("rcbasic_dbg.cl", fstream::out); //generate this file to let the client know it has ownership
|
|
f.close();
|
|
}*/
|
|
for(int i = 0; i < dbg_vars.size(); i++)
|
|
{
|
|
dbg_vars[i].usage_data.clear();
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
fstream f("rcbasic.dbgm", fstream::out | fstream::trunc);
|
|
|
|
f << "SRC " << dbg_files[current_src_file] << endl;
|
|
f << "LN " << current_src_line << endl;
|
|
|
|
for(int i = 0; i < dbg_vars.size(); i++)
|
|
{
|
|
for(int usage = 0; usage < dbg_vars[i].usage_data.size(); usage++)
|
|
{
|
|
f << ((dbg_vars[i].type < RCBASIC_DEBUG_VAR_STR) ? "N" : "S") << " "
|
|
<< i << " " << dbg_vars[i].usage_data[usage].type << " "
|
|
<< (dbg_vars[i].usage_data[usage].is_error ? "E" : "G") << " "
|
|
<< dbg_vars[i].usage_data[usage].dimensions << " "
|
|
<< dbg_vars[i].usage_data[usage].dim[0] << " "
|
|
<< dbg_vars[i].usage_data[usage].dim[1] << " "
|
|
<< dbg_vars[i].usage_data[usage].dim[2] << " "
|
|
<< ((dbg_vars[i].type < RCBASIC_DEBUG_VAR_STR) ? "VAL=" + rc_intern_str(dbg_vars[i].usage_data[usage].num_val) : "VAL=" + dbg_format_string(dbg_vars[i].usage_data[usage].str_val))
|
|
<< endl;
|
|
}
|
|
dbg_vars[i].usage_data.clear();
|
|
//f << ((dbg_vars[i].type==0) ? " N " : " S ") << dbg_vars[i].name << " " << ((dbg_vars[i].type==0) ? num_var[dbg_vars[i].index].
|
|
}
|
|
|
|
if(dbg_error_found)
|
|
{
|
|
f << "E " << dbg_error_message << endl;
|
|
}
|
|
|
|
f.close();
|
|
|
|
|
|
|
|
f.open("rcbasic_dbg.cl", fstream::out); //generate this file to let the client know it has ownership
|
|
f.close();
|
|
|
|
while(!rc_intern_fileExist("rcbasic_dbg.rt")){} //wait for client to generate this file so we know its done reading the previous output
|
|
|
|
while(rc_intern_fileExist("rcbasic_dbg.rt"))
|
|
{
|
|
rc_intern_fileDelete("rcbasic_dbg.rt"); //keep trying to delete file
|
|
}
|
|
|
|
}
|
|
|
|
#endif // RCBASIC_DEBUG
|
|
|
|
//needed by internal functions so i am declaring it here
|
|
void lval_151(int n1);
|
|
void lval_152(uint64_t nid);
|
|
void lval_153(uint64_t lval_addr);
|
|
void lval_154(int s1);
|
|
void lval_155(uint64_t sid);
|
|
void pop_ptr_137(uint64_t n);
|
|
|
|
uint64_t rcbasic_readInt()
|
|
{
|
|
uint64_t i;
|
|
SDL_RWread(rc_fstream[0], &i, sizeof(uint64_t), 1);
|
|
return i;
|
|
}
|
|
|
|
|
|
bool rcbasic_load(string filename)
|
|
{
|
|
char rc[5];
|
|
|
|
rc_fstream[0] = SDL_RWFromFile(filename.c_str(), "rb");
|
|
|
|
if(!rc_fstream[0])
|
|
{
|
|
filename += ".cbc";
|
|
rc_fstream[0] = SDL_RWFromFile(filename.c_str(), "rb");
|
|
if(!rc_fstream[0])
|
|
return false;
|
|
}
|
|
|
|
SDL_RWread(rc_fstream[0], rc, 5, 1);
|
|
|
|
if(! (rc[0]=='R' && rc[1] =='C' && rc[2]=='4') )
|
|
{
|
|
string rcs = rc;
|
|
cout << "This program was not built for this version of the runtime: " << rcs << endl;
|
|
return false;
|
|
}
|
|
|
|
//--------- type definition header -------------------
|
|
uint64_t num_types = rcbasic_readInt();
|
|
|
|
rc_udtDefinition utype;
|
|
rc_udtFieldSize null_size;
|
|
|
|
for(int i = 0; i < num_types; i++)
|
|
{
|
|
utype.num_fields = rcbasic_readInt();
|
|
|
|
//clear field vectors
|
|
utype.field_type.clear();
|
|
utype.field_type_index.clear();
|
|
utype.field_dimensions.clear();
|
|
utype.field_size.clear();
|
|
|
|
for(int members = 0; members < utype.num_fields; members++)
|
|
{
|
|
utype.field_type.push_back(rcbasic_readInt());
|
|
utype.field_type_index.push_back(rcbasic_readInt());
|
|
utype.field_dimensions.push_back(rcbasic_readInt());
|
|
utype.field_size.push_back(null_size);
|
|
}
|
|
|
|
//debug
|
|
//cout << "Type #" << i << endl;
|
|
//for(int n = 0; n < utype.num_fields; n++)
|
|
// cout << " Field #" << n << ": " << utype.field_type[n] << ", " << utype.field_type_index[n] << ", " << utype.field_dimensions[n] << endl;
|
|
//cout << endl;
|
|
|
|
rc_types.push_back(utype);
|
|
}
|
|
|
|
// -------- end type definition header ---------------
|
|
|
|
n_count = rcbasic_readInt();
|
|
s_count = rcbasic_readInt();
|
|
u_count = rcbasic_readInt();
|
|
|
|
n_stack_size = rcbasic_readInt();
|
|
s_stack_size = rcbasic_readInt();
|
|
u_stack_size = rcbasic_readInt();
|
|
|
|
loop_stack_size = rcbasic_readInt();
|
|
|
|
numID_count = rcbasic_readInt();
|
|
strID_count = rcbasic_readInt();
|
|
usrID_count = rcbasic_readInt();
|
|
|
|
code_segment_size = rcbasic_readInt();
|
|
data_segment_size = rcbasic_readInt();
|
|
|
|
vm_n = new rc_vm_n[n_count];
|
|
vm_s = new rc_vm_s[s_count];
|
|
vm_u = new rc_usrId[u_count];
|
|
|
|
|
|
num_var = new rc_numId[numID_count];
|
|
for(int i = 0; i < numID_count; i++)
|
|
{
|
|
//num_var[i].nid_value = new n_value;
|
|
num_var[i].nid_value.value.resize(1);
|
|
num_var[i].dimensions = 0;
|
|
num_var[i].byref_offset = 0;
|
|
num_var[i].nref = &num_var[i].nid_value;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
num_var[i].is_debug_var = false;
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
|
|
str_var = new rc_strId[strID_count];
|
|
for(int i = 0; i < strID_count; i++)
|
|
{
|
|
//str_var[i].sid_value = new s_value;
|
|
str_var[i].sid_value.value.resize(1);
|
|
str_var[i].dimensions = 0;
|
|
str_var[i].byref_offset = 0;
|
|
str_var[i].sref = &str_var[i].sid_value;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
str_var[i].is_debug_var = false;
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
|
|
//cout << "usrID_count = " << usrID_count << endl;
|
|
usr_var = new rc_usrId[usrID_count]; // this will have all of its members allocated by the dim_type instructions
|
|
|
|
|
|
segment = new unsigned char*[2];
|
|
segment[CODE_SEGMENT] = new unsigned char[code_segment_size];
|
|
segment[DATA_SEGMENT] = new unsigned char[data_segment_size];
|
|
|
|
SDL_RWread(rc_fstream[0], segment[CODE_SEGMENT], code_segment_size, 1);
|
|
SDL_RWread(rc_fstream[0], segment[DATA_SEGMENT], data_segment_size, 1);
|
|
|
|
SDL_RWclose(rc_fstream[0]);
|
|
|
|
rc_fstream[0] = NULL;
|
|
|
|
//cout << "DEBUG: Program has been loaded" << endl;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool rc_checkEvent()
|
|
{
|
|
for(int i = 0; i < MAX_WINDOWS; i++)
|
|
if(rc_win[i]!=NULL)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
void rc_events()
|
|
{
|
|
//rc_textinput_flag = false;
|
|
cycleVideo();
|
|
if(rc_checkEvent())
|
|
{
|
|
rc_fingers_pressed.clear();
|
|
rc_inkey = 0;
|
|
rc_mouseX = -1;
|
|
rc_mouseY = -1;
|
|
rc_global_mouseX = -1;
|
|
rc_global_mouseY = -1;
|
|
rc_mwheelx = 0;
|
|
rc_mwheely = 0;
|
|
for(int i = 0; i < MAX_WINDOWS; i++)
|
|
rc_win_event[i] = 0;
|
|
while(rc_getEvents()){}
|
|
keyState = SDL_GetKeyboardState(NULL);
|
|
SDL_GetMouseState(&rc_mouseX, &rc_mouseY);
|
|
SDL_GetGlobalMouseState(&rc_global_mouseX, &rc_global_mouseY);
|
|
//rc_getEvents();
|
|
#ifndef RC_WINDOWS
|
|
SDL_PumpEvents();
|
|
#endif // RC_WINDOWS
|
|
//SDL_FlushEvents(SDL_FIRSTEVENT, SDL_LASTEVENT);//
|
|
}
|
|
}
|
|
|
|
uint64_t readInt()
|
|
{
|
|
for(int i = 0; i < sizeof(uint64_t); i++)
|
|
{
|
|
readint_val.data[i] = segment[current_segment][current_address];
|
|
current_address++;
|
|
}
|
|
return readint_val.i;
|
|
}
|
|
|
|
double readDouble()
|
|
{
|
|
for(int i = 0; i < sizeof(double); i++)
|
|
{
|
|
readdouble_val.data[i] = segment[current_segment][current_address];
|
|
current_address++;
|
|
}
|
|
return readdouble_val.f;
|
|
}
|
|
|
|
void dbg_1(uint32_t dbg_fn, uint64_t arg1, uint64_t arg2)
|
|
{
|
|
#ifdef RCBASIC_DEBUG
|
|
output_debug_message();
|
|
|
|
switch(dbg_fn)
|
|
{
|
|
case 0:
|
|
current_src_file = arg1;
|
|
current_src_line = arg2;
|
|
break;
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
|
|
void mov_32(int n1, int n2)
|
|
{
|
|
vm_n[n1].value = vm_n[n2].value;
|
|
}
|
|
|
|
void mov_33(int n1, double val)
|
|
{
|
|
vm_n[n1].value = val;
|
|
//cout << "n" << n1 << " = " << vm_n[n1].value << endl;
|
|
}
|
|
|
|
void mov_34(int n1, uint64_t nid)
|
|
{
|
|
uint64_t byref_offset = num_var[nid].byref_offset;
|
|
vm_n[n1].value = num_var[nid].nref[0].value[byref_offset];
|
|
vm_n[n1].r = num_var[nid].nref;
|
|
vm_n[n1].r_index = byref_offset;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
if(!num_var[nid].is_debug_var)
|
|
return;
|
|
rcbasic_debug_access_status tmp_stat;
|
|
tmp_stat.type = RCBASIC_DEBUG_ACCESS_GET;
|
|
tmp_stat.dimensions = num_var[nid].dimensions;
|
|
tmp_stat.dim[0] = byref_offset;
|
|
tmp_stat.num_val = vm_n[n1].value;
|
|
dbg_vars[num_var[nid].dbg_var_index].usage_data.push_back(tmp_stat);
|
|
#endif // RCBASIC_DEBUG
|
|
|
|
//cout << "n" << n1 << " = " << vm_n[n1].value << endl;
|
|
}
|
|
|
|
void mov_35(uint64_t nid, int n1)
|
|
{
|
|
uint64_t byref_offset = num_var[nid].byref_offset;
|
|
num_var[nid].nref[0].value[byref_offset] = vm_n[n1].value;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
if(!num_var[nid].is_debug_var)
|
|
return;
|
|
rcbasic_debug_access_status tmp_stat;
|
|
tmp_stat.type = RCBASIC_DEBUG_ACCESS_SET;
|
|
tmp_stat.dimensions = num_var[nid].dimensions;
|
|
tmp_stat.dim[0] = byref_offset;
|
|
tmp_stat.num_val = vm_n[n1].value;
|
|
dbg_vars[num_var[nid].dbg_var_index].usage_data.push_back(tmp_stat);
|
|
#endif // RCBASIC_DEBUG
|
|
|
|
//cout << "n" << n1 << " = " << vm_n[n1].value << endl;
|
|
//cout << "nvar[" << nid << "] = " << num_var[nid].nid_value[0].value[0] << endl;
|
|
}
|
|
|
|
void movS_36(int s1, int s2)
|
|
{
|
|
vm_s[s1].value = vm_s[s2].value;
|
|
}
|
|
|
|
void movS_37(int s1, uint64_t str_addr)
|
|
{
|
|
vm_s[s1].value.clear();
|
|
char c = segment[DATA_SEGMENT][str_addr];
|
|
uint64_t i = str_addr;
|
|
while(c != '\0')
|
|
{
|
|
vm_s[s1].value.push_back(c);
|
|
i++;
|
|
c = segment[DATA_SEGMENT][i];
|
|
}
|
|
}
|
|
|
|
void movS_38(int s1, uint64_t sid)
|
|
{
|
|
uint64_t byref_offset = str_var[sid].byref_offset;
|
|
vm_s[s1].value = str_var[sid].sref[0].value[byref_offset];
|
|
vm_s[s1].r = str_var[sid].sref;
|
|
vm_s[s1].r_index = byref_offset;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
if(!str_var[sid].is_debug_var)
|
|
return;
|
|
rcbasic_debug_access_status tmp_stat;
|
|
tmp_stat.type = RCBASIC_DEBUG_ACCESS_GET;
|
|
tmp_stat.dimensions = str_var[sid].dimensions;
|
|
tmp_stat.dim[0] = byref_offset;
|
|
tmp_stat.str_val = vm_s[s1].value;
|
|
dbg_vars[str_var[sid].dbg_var_index].usage_data.push_back(tmp_stat);
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
|
|
void movS_39(uint64_t sid, int s1)
|
|
{
|
|
uint64_t byref_offset = str_var[sid].byref_offset;
|
|
str_var[sid].sref[0].value[byref_offset] = vm_s[s1].value;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
if(!str_var[sid].is_debug_var)
|
|
return;
|
|
rcbasic_debug_access_status tmp_stat;
|
|
tmp_stat.type = RCBASIC_DEBUG_ACCESS_SET;
|
|
tmp_stat.dimensions = str_var[sid].dimensions;
|
|
tmp_stat.dim[0] = byref_offset;
|
|
tmp_stat.str_val = vm_s[s1].value;
|
|
dbg_vars[str_var[sid].dbg_var_index].usage_data.push_back(tmp_stat);
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
|
|
void mov_r_40(int n1, int n2)
|
|
{
|
|
vm_n[n1].r[0].value[ vm_n[n1].r_index ] = vm_n[n2].value;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
for(int i = 0; i < dbg_vars[vm_n[n1].dbg_var_index].usage_data.size(); i++)
|
|
{
|
|
if(dbg_vars[vm_n[n1].dbg_var_index].usage_data[i].reg==n1)
|
|
{
|
|
dbg_vars[vm_n[n1].dbg_var_index].usage_data[i].type = RCBASIC_DEBUG_ACCESS_SET;
|
|
dbg_vars[vm_n[n1].dbg_var_index].usage_data[i].str_val = vm_n[n2].value;
|
|
break;
|
|
}
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
|
|
void mov_rS_41(int s1, int s2)
|
|
{
|
|
vm_s[s1].r[0].value[ vm_s[s1].r_index ] = vm_s[s2].value;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
for(int i = 0; i < dbg_vars[vm_s[s1].dbg_var_index].usage_data.size(); i++)
|
|
{
|
|
if(dbg_vars[vm_s[s1].dbg_var_index].usage_data[i].reg==s1)
|
|
{
|
|
dbg_vars[vm_s[s1].dbg_var_index].usage_data[i].type = RCBASIC_DEBUG_ACCESS_SET;
|
|
dbg_vars[vm_s[s1].dbg_var_index].usage_data[i].str_val = vm_s[s2].value;
|
|
break;
|
|
}
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
|
|
void mov_type_42(int u1, int u2)
|
|
{
|
|
vm_u[u1].var_ref[0] = vm_u[u2];
|
|
vm_u[u1].var_ref_index = 0;
|
|
|
|
//if(u2 == 3)
|
|
//{
|
|
// cout << "\nSetting value = " << vm_u[u1].var_ref[0].num_var[0].nid_value.value[0] << endl << endl;
|
|
//}
|
|
}
|
|
|
|
void addS_43(int s1, int s2)
|
|
{
|
|
vm_s[s1].value += vm_s[s2].value;
|
|
}
|
|
|
|
void add_44(int n1, int n2)
|
|
{
|
|
vm_n[n1].value += vm_n[n2].value;
|
|
}
|
|
|
|
void sub_45(int n1, int n2)
|
|
{
|
|
vm_n[n1].value -= vm_n[n2].value;
|
|
}
|
|
|
|
void mul_46(int n1, int n2)
|
|
{
|
|
vm_n[n1].value *= vm_n[n2].value;
|
|
}
|
|
|
|
void div_47(int n1, int n2)
|
|
{
|
|
#ifdef RCBASIC_DEBUG
|
|
if(vm_n[n2].value == 0)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_DIV_BY_ZERO;
|
|
return;
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
vm_n[n1].value /= vm_n[n2].value;
|
|
}
|
|
|
|
void pow_48(int n1, int n2)
|
|
{
|
|
vm_n[n1].value = pow(vm_n[n1].value, vm_n[n2].value);
|
|
}
|
|
|
|
void mod_49(int n1, int n2)
|
|
{
|
|
vm_n[n1].value = (int64_t)(vm_n[n1].value) % (int64_t)(vm_n[n2].value);
|
|
}
|
|
|
|
void shl_50(int n1, int n2)
|
|
{
|
|
vm_n[n1].value = (int64_t)(vm_n[n1].value) << (int64_t)(vm_n[n2].value);
|
|
}
|
|
|
|
void shr_51(int n1, int n2)
|
|
{
|
|
vm_n[n1].value = (int64_t)(vm_n[n1].value) >> (int64_t)(vm_n[n2].value);
|
|
}
|
|
|
|
void and_52(int n1, int n2)
|
|
{
|
|
vm_n[n1].value = (int64_t)(vm_n[n1].value) && (int64_t)(vm_n[n2].value);
|
|
}
|
|
|
|
void or_53(int n1, int n2)
|
|
{
|
|
vm_n[n1].value = (int64_t)(vm_n[n1].value) || (int64_t)(vm_n[n2].value);
|
|
}
|
|
|
|
void xor_54(int n1, int n2)
|
|
{
|
|
vm_n[n1].value = !((int64_t)(vm_n[n1].value)) != !((int64_t)(vm_n[n2].value));
|
|
}
|
|
|
|
void not_55(int n1)
|
|
{
|
|
vm_n[n1].value = !((int64_t)vm_n[n1].value);
|
|
}
|
|
|
|
void cmp_56(int n1, int n2)
|
|
{
|
|
CMP_FLAG_EQUAL = (vm_n[n1].value == vm_n[n2].value);
|
|
CMP_FLAG_GREATER = (vm_n[n1].value > vm_n[n2].value);
|
|
CMP_FLAG_GREATER_EQUAL = (vm_n[n1].value >= vm_n[n2].value);
|
|
CMP_FLAG_LESS = (vm_n[n1].value < vm_n[n2].value);
|
|
CMP_FLAG_LESS_EQUAL = (vm_n[n1].value <= vm_n[n2].value);
|
|
CMP_FLAG_NOT_EQUAL = (vm_n[n1].value != vm_n[n2].value);
|
|
}
|
|
|
|
void cmpS_57(int s1, int s2)
|
|
{
|
|
int str_cmp = vm_s[s1].value.compare(vm_s[s2].value);
|
|
CMP_FLAG_EQUAL = (str_cmp==0);
|
|
CMP_FLAG_NOT_EQUAL = (str_cmp!=0);
|
|
CMP_FLAG_GREATER = (str_cmp>0);
|
|
CMP_FLAG_GREATER_EQUAL = (CMP_FLAG_EQUAL || CMP_FLAG_GREATER);
|
|
CMP_FLAG_LESS = (str_cmp<0);
|
|
CMP_FLAG_LESS_EQUAL = (CMP_FLAG_EQUAL || CMP_FLAG_LESS);
|
|
}
|
|
|
|
void cmp_u_58(int n1, int n2)
|
|
{
|
|
}
|
|
|
|
void jmp_59(int n1)
|
|
{
|
|
current_address = (uint64_t)vm_n[n1].value;
|
|
}
|
|
|
|
void jmp_60(uint64_t jmp_addr)
|
|
{
|
|
current_address = jmp_addr;
|
|
}
|
|
|
|
void je_61(int n1)
|
|
{
|
|
if(CMP_FLAG_EQUAL)
|
|
current_address = (uint64_t)vm_n[n1].value;
|
|
}
|
|
|
|
void je_62(uint64_t jmp_addr)
|
|
{
|
|
if(CMP_FLAG_EQUAL)
|
|
current_address = jmp_addr;
|
|
}
|
|
|
|
void jne_63(int n1)
|
|
{
|
|
if(CMP_FLAG_NOT_EQUAL)
|
|
current_address = (uint64_t)vm_n[n1].value;
|
|
}
|
|
|
|
void jne_64(uint64_t jmp_addr)
|
|
{
|
|
if(CMP_FLAG_NOT_EQUAL)
|
|
current_address = jmp_addr;
|
|
}
|
|
|
|
void jg_65(int n1)
|
|
{
|
|
if(CMP_FLAG_GREATER)
|
|
current_address = (uint64_t)vm_n[n1].value;
|
|
}
|
|
|
|
void jg_66(uint64_t jmp_addr)
|
|
{
|
|
if(CMP_FLAG_GREATER)
|
|
current_address = jmp_addr;
|
|
}
|
|
|
|
void jge_67(int n1)
|
|
{
|
|
if(CMP_FLAG_GREATER_EQUAL)
|
|
current_address = (uint64_t)vm_n[n1].value;
|
|
}
|
|
|
|
void jge_68(uint64_t jmp_addr)
|
|
{
|
|
if(CMP_FLAG_GREATER_EQUAL)
|
|
current_address = jmp_addr;
|
|
}
|
|
|
|
void jl_69(int n1)
|
|
{
|
|
if(CMP_FLAG_LESS)
|
|
current_address = (uint64_t)vm_n[n1].value;
|
|
}
|
|
|
|
void jl_70(uint64_t jmp_addr)
|
|
{
|
|
if(CMP_FLAG_LESS)
|
|
current_address = jmp_addr;
|
|
}
|
|
|
|
void jle_71(int n1)
|
|
{
|
|
if(CMP_FLAG_LESS_EQUAL)
|
|
current_address = (uint64_t)vm_n[n1].value;
|
|
}
|
|
|
|
void jle_72(uint64_t jmp_addr)
|
|
{
|
|
if(CMP_FLAG_LESS_EQUAL)
|
|
current_address = jmp_addr;
|
|
}
|
|
|
|
void obj_num_73(uint64_t nid)
|
|
{
|
|
num_object.obj_val = num_var[nid].nref;
|
|
uint64_t byref_offset = num_var[nid].byref_offset;
|
|
num_object.index = byref_offset;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
if(!num_var[nid].is_debug_var)
|
|
return;
|
|
|
|
uint64_t num_var_size = 1;
|
|
switch(num_var[nid].dimensions)
|
|
{
|
|
case 3:
|
|
num_var_size *= num_var[nid].dim[2];
|
|
case 2:
|
|
num_var_size *= num_var[nid].dim[1];
|
|
case 1:
|
|
num_var_size *= num_var[nid].dim[0];
|
|
}
|
|
|
|
num_object.nid = nid;
|
|
rcbasic_debug_access_status tmp_stat;
|
|
tmp_stat.type = RCBASIC_DEBUG_ACCESS_GET;
|
|
tmp_stat.dimensions = num_var[nid].dimensions;
|
|
|
|
if(num_object.index >= num_var_size && dbg_vars[num_var[nid].dbg_var_index].type != RCBASIC_DEBUG_VAR_BYREF_NUM)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_INDEX_EXCEEDS_SIZE;
|
|
tmp_stat.is_error = true;
|
|
}
|
|
else
|
|
tmp_stat.num_val = num_var[nid].nid_value[0].value[num_object.index];
|
|
dbg_vars[num_var[nid].dbg_var_index].usage_data.push_back(tmp_stat);
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
|
|
void obj_num1_74(uint64_t nid, int n1)
|
|
{
|
|
num_object.obj_val = num_var[nid].nref;
|
|
uint64_t byref_offset = num_var[nid].byref_offset;
|
|
num_object.index = (uint64_t)vm_n[n1].value + byref_offset;
|
|
//cout << "obj_num index = " << num_object.index << endl;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
if(!num_var[nid].is_debug_var)
|
|
return;
|
|
|
|
uint64_t num_var_size = 1;
|
|
switch(num_var[nid].dimensions)
|
|
{
|
|
case 3:
|
|
num_var_size *= num_var[nid].dim[2];
|
|
case 2:
|
|
num_var_size *= num_var[nid].dim[1];
|
|
case 1:
|
|
num_var_size *= num_var[nid].dim[0];
|
|
}
|
|
|
|
num_object.nid = nid;
|
|
rcbasic_debug_access_status tmp_stat;
|
|
tmp_stat.type = RCBASIC_DEBUG_ACCESS_GET;
|
|
tmp_stat.dimensions = num_var[nid].dimensions;
|
|
tmp_stat.dim[0] = vm_n[n1].value;
|
|
|
|
if(num_object.index >= num_var_size && dbg_vars[num_var[nid].dbg_var_index].type != RCBASIC_DEBUG_VAR_BYREF_NUM)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_INDEX_EXCEEDS_SIZE;
|
|
tmp_stat.is_error = true;
|
|
}
|
|
else
|
|
tmp_stat.num_val = num_var[nid].nid_value[0].value[num_object.index];
|
|
dbg_vars[num_var[nid].dbg_var_index].usage_data.push_back(tmp_stat);
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
|
|
void obj_num2_75(uint64_t nid, int n1, int n2)
|
|
{
|
|
uint64_t arr_pos = (uint64_t)vm_n[n1].value * num_var[nid].dim[1] + (uint64_t)vm_n[n2].value;
|
|
num_object.obj_val = num_var[nid].nref;
|
|
uint64_t byref_offset = num_var[nid].byref_offset;
|
|
num_object.index = arr_pos + byref_offset;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
if(!num_var[nid].is_debug_var)
|
|
return;
|
|
|
|
uint64_t num_var_size = 1;
|
|
switch(num_var[nid].dimensions)
|
|
{
|
|
case 3:
|
|
num_var_size *= num_var[nid].dim[2];
|
|
case 2:
|
|
num_var_size *= num_var[nid].dim[1];
|
|
case 1:
|
|
num_var_size *= num_var[nid].dim[0];
|
|
}
|
|
|
|
num_object.nid = nid;
|
|
rcbasic_debug_access_status tmp_stat;
|
|
tmp_stat.type = RCBASIC_DEBUG_ACCESS_GET;
|
|
tmp_stat.dimensions = num_var[nid].dimensions;
|
|
tmp_stat.dim[0] = vm_n[n1].value;
|
|
tmp_stat.dim[1] = vm_n[n2].value;
|
|
|
|
if(num_object.index >= num_var_size && dbg_vars[num_var[nid].dbg_var_index].type != RCBASIC_DEBUG_VAR_BYREF_NUM)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_INDEX_EXCEEDS_SIZE;
|
|
tmp_stat.is_error = true;
|
|
}
|
|
else
|
|
tmp_stat.num_val = num_var[nid].nid_value[0].value[num_object.index];
|
|
dbg_vars[num_var[nid].dbg_var_index].usage_data.push_back(tmp_stat);
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
|
|
void obj_num3_76(uint64_t nid, int n1, int n2, int n3)
|
|
{
|
|
uint64_t arr_pos = ( (uint64_t)vm_n[n1].value * num_var[nid].dim[1] * num_var[nid].dim[2] ) + ((uint64_t)vm_n[n2].value * num_var[nid].dim[2]) + (uint64_t)vm_n[n3].value;
|
|
num_object.obj_val = num_var[nid].nref;
|
|
uint64_t byref_offset = num_var[nid].byref_offset;
|
|
num_object.index = arr_pos + byref_offset;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
if(!num_var[nid].is_debug_var)
|
|
return;
|
|
|
|
uint64_t num_var_size = 1;
|
|
switch(num_var[nid].dimensions)
|
|
{
|
|
case 3:
|
|
num_var_size *= num_var[nid].dim[2];
|
|
case 2:
|
|
num_var_size *= num_var[nid].dim[1];
|
|
case 1:
|
|
num_var_size *= num_var[nid].dim[0];
|
|
}
|
|
|
|
num_object.nid = nid;
|
|
rcbasic_debug_access_status tmp_stat;
|
|
tmp_stat.type = RCBASIC_DEBUG_ACCESS_GET;
|
|
tmp_stat.dimensions = num_var[nid].dimensions;
|
|
tmp_stat.dim[0] = vm_n[n1].value;
|
|
tmp_stat.dim[1] = vm_n[n2].value;
|
|
tmp_stat.dim[2] = vm_n[n3].value;
|
|
|
|
if(num_object.index >= num_var_size && dbg_vars[num_var[nid].dbg_var_index].type != RCBASIC_DEBUG_VAR_BYREF_NUM)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_INDEX_EXCEEDS_SIZE;
|
|
tmp_stat.is_error = true;
|
|
}
|
|
else
|
|
tmp_stat.num_val = num_var[nid].nid_value[0].value[num_object.index];
|
|
dbg_vars[num_var[nid].dbg_var_index].usage_data.push_back(tmp_stat);
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
|
|
void obj_str_77(uint64_t sid)
|
|
{
|
|
str_object.obj_val = str_var[sid].sref;
|
|
uint64_t byref_offset = str_var[sid].byref_offset;
|
|
str_object.index = byref_offset;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
if(!str_var[sid].is_debug_var)
|
|
return;
|
|
|
|
uint64_t str_var_size = 1;
|
|
switch(str_var[sid].dimensions)
|
|
{
|
|
case 3:
|
|
str_var_size *= str_var[sid].dim[2];
|
|
case 2:
|
|
str_var_size *= str_var[sid].dim[1];
|
|
case 1:
|
|
str_var_size *= str_var[sid].dim[0];
|
|
}
|
|
|
|
str_object.sid = sid;
|
|
rcbasic_debug_access_status tmp_stat;
|
|
tmp_stat.type = RCBASIC_DEBUG_ACCESS_GET;
|
|
tmp_stat.dimensions = str_var[sid].dimensions;
|
|
tmp_stat.dim[0] = byref_offset;
|
|
if(str_object.index >= str_var_size && dbg_vars[str_var[sid].dbg_var_index].type != RCBASIC_DEBUG_VAR_BYREF_STR)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_INDEX_EXCEEDS_SIZE;
|
|
tmp_stat.is_error = true;
|
|
}
|
|
else
|
|
tmp_stat.str_val = str_var[sid].sid_value[0].value[str_object.index];
|
|
dbg_vars[str_var[sid].dbg_var_index].usage_data.push_back(tmp_stat);
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
|
|
void obj_str1_78(uint64_t sid, int n1)
|
|
{
|
|
str_object.obj_val = str_var[sid].sref;
|
|
uint64_t byref_offset = str_var[sid].byref_offset;
|
|
str_object.index = (uint64_t)vm_n[n1].value + byref_offset;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
if(!str_var[sid].is_debug_var)
|
|
return;
|
|
|
|
uint64_t str_var_size = 1;
|
|
switch(str_var[sid].dimensions)
|
|
{
|
|
case 3:
|
|
str_var_size *= str_var[sid].dim[2];
|
|
case 2:
|
|
str_var_size *= str_var[sid].dim[1];
|
|
case 1:
|
|
str_var_size *= str_var[sid].dim[0];
|
|
}
|
|
str_object.sid = sid;
|
|
rcbasic_debug_access_status tmp_stat;
|
|
tmp_stat.type = RCBASIC_DEBUG_ACCESS_GET;
|
|
tmp_stat.dimensions = str_var[sid].dimensions;
|
|
tmp_stat.dim[0] = vm_n[n1].value;
|
|
if(str_object.index >= str_var_size && dbg_vars[str_var[sid].dbg_var_index].type != RCBASIC_DEBUG_VAR_BYREF_STR)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_INDEX_EXCEEDS_SIZE;
|
|
tmp_stat.is_error = true;
|
|
}
|
|
else
|
|
tmp_stat.str_val = str_var[sid].sid_value[0].value[str_object.index];
|
|
dbg_vars[str_var[sid].dbg_var_index].usage_data.push_back(tmp_stat);
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
|
|
void obj_str2_79(uint64_t sid, int n1, int n2)
|
|
{
|
|
uint64_t arr_pos = (uint64_t)vm_n[n1].value * str_var[sid].dim[1] + (uint64_t)vm_n[n2].value;
|
|
str_object.obj_val = str_var[sid].sref;
|
|
uint64_t byref_offset = str_var[sid].byref_offset;
|
|
str_object.index = arr_pos + byref_offset;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
if(!str_var[sid].is_debug_var)
|
|
return;
|
|
|
|
uint64_t str_var_size = 1;
|
|
switch(str_var[sid].dimensions)
|
|
{
|
|
case 3:
|
|
str_var_size *= str_var[sid].dim[2];
|
|
case 2:
|
|
str_var_size *= str_var[sid].dim[1];
|
|
case 1:
|
|
str_var_size *= str_var[sid].dim[0];
|
|
}
|
|
|
|
str_object.sid = sid;
|
|
rcbasic_debug_access_status tmp_stat;
|
|
tmp_stat.type = RCBASIC_DEBUG_ACCESS_GET;
|
|
tmp_stat.dimensions = str_var[sid].dimensions;
|
|
tmp_stat.dim[0] = vm_n[n1].value;
|
|
tmp_stat.dim[1] = vm_n[n2].value;
|
|
|
|
if(str_object.index >= str_var_size && dbg_vars[str_var[sid].dbg_var_index].type != RCBASIC_DEBUG_VAR_BYREF_STR)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_INDEX_EXCEEDS_SIZE;
|
|
tmp_stat.is_error = true;
|
|
}
|
|
else
|
|
tmp_stat.str_val = str_var[sid].sid_value[0].value[str_object.index];
|
|
dbg_vars[str_var[sid].dbg_var_index].usage_data.push_back(tmp_stat);
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
|
|
void obj_str3_80(uint64_t sid, int n1, int n2, int n3)
|
|
{
|
|
uint64_t arr_pos = ( (uint64_t)vm_n[n1].value * str_var[sid].dim[1] * str_var[sid].dim[2] ) + ((uint64_t)vm_n[n2].value * str_var[sid].dim[2]) + (uint64_t)vm_n[n3].value;
|
|
str_object.obj_val = str_var[sid].sref;
|
|
uint64_t byref_offset = str_var[sid].byref_offset;
|
|
str_object.index = arr_pos + byref_offset;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
if(!str_var[sid].is_debug_var)
|
|
return;
|
|
|
|
uint64_t str_var_size = 1;
|
|
switch(str_var[sid].dimensions)
|
|
{
|
|
case 3:
|
|
str_var_size *= str_var[sid].dim[2];
|
|
case 2:
|
|
str_var_size *= str_var[sid].dim[1];
|
|
case 1:
|
|
str_var_size *= str_var[sid].dim[0];
|
|
}
|
|
|
|
str_object.sid = sid;
|
|
rcbasic_debug_access_status tmp_stat;
|
|
tmp_stat.type = RCBASIC_DEBUG_ACCESS_GET;
|
|
tmp_stat.dimensions = str_var[sid].dimensions;
|
|
tmp_stat.dim[0] = vm_n[n1].value;
|
|
tmp_stat.dim[1] = vm_n[n2].value;
|
|
tmp_stat.dim[2] = vm_n[n3].value;
|
|
|
|
if(str_object.index >= str_var_size && dbg_vars[str_var[sid].dbg_var_index].type != RCBASIC_DEBUG_VAR_BYREF_STR)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_INDEX_EXCEEDS_SIZE;
|
|
tmp_stat.is_error = true;
|
|
}
|
|
else
|
|
tmp_stat.str_val = str_var[sid].sid_value[0].value[str_object.index];
|
|
dbg_vars[str_var[sid].dbg_var_index].usage_data.push_back(tmp_stat);
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
|
|
void obj_usr_81(uint64_t uid)
|
|
{
|
|
//cout << "obj_usr " << uid << ": size = " << usr_object.obj_ref->uid_value[uid].uid_value.size() << endl;
|
|
usr_object.index = 0;
|
|
|
|
rc_usrId* tmp_usr_id = &usr_object.obj_ref->uid_value[uid];
|
|
|
|
usr_object.obj_ref = &usr_object.obj_ref->uid_value[uid].uid_value[0];
|
|
|
|
usr_object.obj_ref->byref_ptr = tmp_usr_id;
|
|
//usr_object.obj_ref->byref_ptr = &usr_object.obj_ref->uid_value[uid];
|
|
}
|
|
|
|
void obj_usr1_82(uint64_t uid, int n1)
|
|
{
|
|
//cout << "obj_usr2 " << uid << " " << (uint64_t)vm_n[n1].value << " " << (uint64_t)vm_n[n2].value << ": size = " << usr_object.obj_ref->uid_value.size() << endl;
|
|
//rc_usrId* tmp_usr_id = &usr_object.obj_ref->uid_value[uid];
|
|
//usr_object.index = (uint64_t)vm_n[n1].value;;
|
|
//cout << "\n\nuid =" << uid << ", index = (" << usr_object.index << ") old_index = " << usr_object.index << endl << endl;
|
|
//cout << "\n\nusr index = " << usr_object.obj_ref->uid_value[uid].uid_value[usr_object.index].str_var.size() << endl << endl;
|
|
|
|
|
|
//cout << "obj_usr1 " << uid << " " << (uint64_t)vm_n[n1].value << endl;
|
|
//cout << " ---dbg[uid]: " << usr_object.obj_ref->uid_value[uid].uid_value[1].num_var[0].nid_value.value[0] << endl;
|
|
//cout << " ---dbg[str]: " << usr_object.obj_ref->uid_value[uid].uid_value[0].str_var.size() << endl;
|
|
usr_object.index = (uint64_t)vm_n[n1].value;
|
|
|
|
rc_usrId* tmp_usr_id = &usr_object.obj_ref->uid_value[uid];
|
|
|
|
usr_object.obj_ref = &usr_object.obj_ref->uid_value[uid].uid_value[usr_object.index];
|
|
|
|
usr_object.obj_ref->byref_ptr = tmp_usr_id;
|
|
//usr_object.obj_ref->byref_ptr = &usr_object.obj_ref->uid_value[uid];
|
|
}
|
|
|
|
void obj_usr2_83(uint64_t uid, int n1, int n2)
|
|
{
|
|
//cout << "obj_usr2 " << uid << " " << (uint64_t)vm_n[n1].value << " " << (uint64_t)vm_n[n2].value << ": size = " << usr_object.obj_ref->uid_value.size() << endl;
|
|
//rc_usrId* tmp_usr_id = &usr_object.obj_ref->uid_value[uid];
|
|
//usr_object.index = (uint64_t)vm_n[n1].value * usr_object.obj_ref->uid_value[uid].dim[1] + (uint64_t)vm_n[n2].value;
|
|
//cout << "\n\nuid =" << uid << ", index = (" << usr_object.index << ") old_index = " << usr_object.index << endl << endl;
|
|
//cout << "\n\nusr index = " << usr_object.obj_ref->uid_value[uid].uid_value.size() << endl << endl;
|
|
|
|
usr_object.index = (uint64_t)vm_n[n1].value * usr_object.obj_ref->uid_value[uid].dim[1] + (uint64_t)vm_n[n2].value;
|
|
|
|
rc_usrId* tmp_usr_id = &usr_object.obj_ref->uid_value[uid];
|
|
|
|
usr_object.obj_ref = &usr_object.obj_ref->uid_value[uid].uid_value[usr_object.index];
|
|
|
|
usr_object.obj_ref->byref_ptr = tmp_usr_id;
|
|
//usr_object.obj_ref->byref_ptr = &usr_object.obj_ref->uid_value[uid];
|
|
}
|
|
|
|
void obj_usr3_84(uint64_t uid, int n1, int n2, int n3)
|
|
{
|
|
//rc_usrId* tmp_usr_id = &usr_object.obj_ref->uid_value[uid];
|
|
|
|
//cout << "obj_usr3 " << uid << " " << (uint64_t)vm_n[n1].value << " " << (uint64_t)vm_n[n2].value << " " << (uint64_t)vm_n[n3].value << endl;
|
|
usr_object.index = ( (uint64_t)vm_n[n1].value * usr_object.obj_ref->uid_value[uid].dim[1] * usr_object.obj_ref->uid_value[uid].dim[2] ) + ((uint64_t)vm_n[n2].value * usr_object.obj_ref->uid_value[uid].dim[2]) + (uint64_t)vm_n[n3].value;;
|
|
|
|
//----test
|
|
rc_usrId* tmp_usr_id = &usr_object.obj_ref->uid_value[uid];
|
|
//------------------------------------------
|
|
|
|
usr_object.obj_ref = &usr_object.obj_ref->uid_value[uid].uid_value[usr_object.index];
|
|
|
|
usr_object.obj_ref->byref_ptr = tmp_usr_id;
|
|
|
|
//usr_object.obj_ref->byref_ptr = &usr_object.obj_ref->uid_value[uid];
|
|
}
|
|
|
|
void obj_get_85(int n1)
|
|
{
|
|
//cout << "var index = " << num_object.index << endl;
|
|
//cout << "store in n" << n1 << endl;
|
|
vm_n[n1].value = num_object.obj_val[0].value[num_object.index];
|
|
//cout << "t1" << endl;
|
|
vm_n[n1].r = num_object.obj_val;
|
|
//cout << "t2" << endl;
|
|
vm_n[n1].r_index = num_object.index;
|
|
//cout << "t3" << endl;
|
|
|
|
num_object.obj_val->ref_parent = num_object.obj_val;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
if(!num_var[num_object.nid].is_debug_var)
|
|
return;
|
|
|
|
int usage_size = dbg_vars[num_var[num_object.nid].dbg_var_index].usage_data.size();
|
|
dbg_vars[num_var[num_object.nid].dbg_var_index].usage_data[usage_size-1].reg = n1;
|
|
vm_n[n1].dbg_var_index = num_var[num_object.nid].dbg_var_index;
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
|
|
void obj_getS_86(int s1)
|
|
{
|
|
vm_s[s1].value = str_object.obj_val[0].value[str_object.index];
|
|
vm_s[s1].r = str_object.obj_val;
|
|
vm_s[s1].r_index = str_object.index;
|
|
|
|
str_object.obj_val->ref_parent = str_object.obj_val;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
if(!str_var[str_object.sid].is_debug_var)
|
|
return;
|
|
|
|
int usage_size = dbg_vars[str_var[str_object.sid].dbg_var_index].usage_data.size();
|
|
dbg_vars[str_var[str_object.sid].dbg_var_index].usage_data[usage_size-1].reg = s1;
|
|
vm_s[s1].dbg_var_index = str_var[str_object.sid].dbg_var_index;
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
|
|
void obj_set_87(int n1)
|
|
{
|
|
}
|
|
|
|
void obj_setS_88(int s1)
|
|
{
|
|
}
|
|
|
|
void clear_obj_89()
|
|
{
|
|
}
|
|
|
|
bool rc_dim_type(rc_usrId* parent, uint64_t udt_index, int num_dim, uint64_t d1, uint64_t d2, uint64_t d3, uint64_t start_index = 0)
|
|
{
|
|
uint64_t dim_size = 0;
|
|
switch(num_dim)
|
|
{
|
|
case 0:
|
|
dim_size = 1;
|
|
break;
|
|
case 1:
|
|
dim_size = d1;
|
|
break;
|
|
case 2:
|
|
dim_size = d1 * d2;
|
|
break;
|
|
case 3:
|
|
dim_size = d1 * d2 * d3;
|
|
break;
|
|
}
|
|
|
|
parent->dimensions = num_dim;
|
|
parent->dim[0] = d1;
|
|
parent->dim[1] = d2;
|
|
parent->dim[2] = d3;
|
|
|
|
parent->byref_offset = 0;
|
|
parent->uid_value.resize(dim_size);
|
|
|
|
parent->var_ref = parent;
|
|
parent->var_ref_index = 0;
|
|
|
|
rc_usrId* p_obj;
|
|
|
|
uint64_t field_size = 0;
|
|
|
|
//cout << "starting field: " << udt_index << " " << num_dim << " " << d1 << " " << d2 << " " << d3 << ": " << parent->uid_value.size() << endl;
|
|
|
|
for(uint64_t i = start_index; i < dim_size; i++)
|
|
{
|
|
p_obj = &parent->uid_value[i];
|
|
|
|
for(int field = 0; field < rc_types[udt_index].num_fields; field++)
|
|
{
|
|
field_size = 1;
|
|
switch(rc_types[udt_index].field_dimensions[field])
|
|
{
|
|
case 3:
|
|
field_size *= rc_types[udt_index].field_size[field].dim[2];
|
|
case 2:
|
|
field_size *= rc_types[udt_index].field_size[field].dim[1];
|
|
case 1:
|
|
field_size *= rc_types[udt_index].field_size[field].dim[0];
|
|
break;
|
|
}
|
|
|
|
switch(rc_types[udt_index].field_type[field])
|
|
{
|
|
case RC_UDT_TYPE_NUM:
|
|
{
|
|
rc_numId tmp_num_var;
|
|
//tmp_num_var.nid_value = new n_value;
|
|
tmp_num_var.nid_value.value.resize(field_size);
|
|
tmp_num_var.dimensions = rc_types[udt_index].field_dimensions[field];
|
|
tmp_num_var.dim[0] = rc_types[udt_index].field_size[field].dim[0];
|
|
tmp_num_var.dim[1] = rc_types[udt_index].field_size[field].dim[1];
|
|
tmp_num_var.dim[2] = rc_types[udt_index].field_size[field].dim[2];
|
|
p_obj->num_var.push_back(tmp_num_var);
|
|
uint64_t nv_index = p_obj->num_var.size()-1;
|
|
p_obj->num_var[nv_index].nref = &p_obj->num_var[nv_index].nid_value;
|
|
}
|
|
break;
|
|
case RC_UDT_TYPE_STR:
|
|
{
|
|
rc_strId tmp_str_var;
|
|
//tmp_str_var.sid_value = new s_value;
|
|
tmp_str_var.sid_value.value.resize(field_size);
|
|
tmp_str_var.dimensions = rc_types[udt_index].field_dimensions[field];
|
|
tmp_str_var.dim[0] = rc_types[udt_index].field_size[field].dim[0];
|
|
tmp_str_var.dim[1] = rc_types[udt_index].field_size[field].dim[1];
|
|
tmp_str_var.dim[2] = rc_types[udt_index].field_size[field].dim[2];
|
|
p_obj->str_var.push_back(tmp_str_var);
|
|
uint64_t sv_index = p_obj->str_var.size()-1;
|
|
p_obj->str_var[sv_index].sref = &p_obj->str_var[sv_index].sid_value;
|
|
}
|
|
break;
|
|
case RC_UDT_TYPE_USR:
|
|
{
|
|
//WIP: p_obj is just going to get resized everytime this is called. So instead I need to create a type object to add and run rc_dim_type on that
|
|
rc_usrId usr_field;
|
|
rc_dim_type(&usr_field, rc_types[udt_index].field_type_index[field], rc_types[udt_index].field_dimensions[field],
|
|
rc_types[udt_index].field_size[field].dim[0],
|
|
rc_types[udt_index].field_size[field].dim[1],
|
|
rc_types[udt_index].field_size[field].dim[2]);
|
|
p_obj->uid_value.push_back(usr_field);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool rc_free_type(rc_usrId* parent)
|
|
{
|
|
uint64_t dim_size = parent->uid_value.size();
|
|
|
|
|
|
rc_usrId* p_obj;
|
|
|
|
uint64_t field_size = 0;
|
|
|
|
for(uint64_t i = 0; i < dim_size; i++)
|
|
{
|
|
p_obj = &parent->uid_value[i];
|
|
|
|
for(uint64_t n_field = 0; n_field < p_obj->num_var.size(); n_field++)
|
|
{
|
|
p_obj->num_var[n_field].nid_value.value.clear();
|
|
p_obj->num_var[n_field].nid_value.value.shrink_to_fit();
|
|
//delete p_obj->num_var[n_field].nid_value;
|
|
}
|
|
|
|
for(uint64_t s_field = 0; s_field < p_obj->str_var.size(); s_field++)
|
|
{
|
|
p_obj->str_var[s_field].sid_value.value.clear();
|
|
p_obj->str_var[s_field].sid_value.value.shrink_to_fit();
|
|
//delete p_obj->str_var[s_field].sid_value;
|
|
}
|
|
|
|
for(uint64_t u_field = 0; u_field < p_obj->uid_value.size(); u_field++)
|
|
{
|
|
rc_free_type(&p_obj->uid_value[u_field]);
|
|
p_obj->uid_value[u_field].uid_value.clear();
|
|
p_obj->uid_value[u_field].uid_value.shrink_to_fit();
|
|
}
|
|
}
|
|
|
|
parent->uid_value.clear();
|
|
parent->uid_value.shrink_to_fit();
|
|
|
|
return true;
|
|
}
|
|
|
|
void dim_type_90(uint64_t uid, uint64_t udt_index)
|
|
{
|
|
//cout << "DimType " << uid << " " << udt_index << endl;
|
|
rc_free_type(&usr_var[uid]);
|
|
//cout << "Freed memory" << endl;
|
|
rc_dim_type( &usr_var[uid], udt_index, 0, 0, 0, 0 );
|
|
//cout << "DimType End" << endl;
|
|
}
|
|
|
|
void dim_type1_91(uint64_t uid, uint64_t udt_index, int n1)
|
|
{
|
|
//cout << "DimType1 " << uid << " " << udt_index << " " << (uint64_t)vm_n[n1].value << endl;
|
|
rc_free_type(&usr_var[uid]);
|
|
rc_dim_type( &usr_var[uid], udt_index, 1, (uint64_t)vm_n[n1].value, 0, 0 );
|
|
//cout << "DimType End" << endl;
|
|
}
|
|
|
|
void dim_type2_92(uint64_t uid, uint64_t udt_index, int n1, int n2)
|
|
{
|
|
//cout << "DimType2 " << uid << " " << udt_index << " " << (uint64_t)vm_n[n1].value << " " << (uint64_t)vm_n[n2].value << endl;
|
|
rc_free_type(&usr_var[uid]);
|
|
rc_dim_type( &usr_var[uid], udt_index, 2, (uint64_t)vm_n[n1].value, (uint64_t)vm_n[n2].value, 0 );
|
|
//cout << "DimType End" << endl;
|
|
}
|
|
|
|
void dim_type3_93(uint64_t uid, uint64_t udt_index, int n1, int n2, int n3)
|
|
{
|
|
//cout << "DimType3 " << uid << " " << udt_index << " " << (uint64_t)vm_n[n1].value << " " << (uint64_t)vm_n[n2].value << " " << (uint64_t)vm_n[n3].value << endl;
|
|
rc_free_type(&usr_var[uid]);
|
|
rc_dim_type( &usr_var[uid], udt_index, 3, (uint64_t)vm_n[n1].value, (uint64_t)vm_n[n2].value, (uint64_t)vm_n[n3].value );
|
|
//cout << "DimType End" << endl;
|
|
}
|
|
|
|
void dim_num1_94(uint64_t nid, int n1)
|
|
{
|
|
#ifdef RCBASIC_DEBUG
|
|
if(vm_n[n1].value <= 0)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_DIM_LEQ_ZERO;
|
|
return;
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
num_var[nid].nid_value.value.resize((uint64_t)vm_n[n1].value);
|
|
num_var[nid].nref = &num_var[nid].nid_value;
|
|
num_var[nid].dimensions = 1;
|
|
num_var[nid].dim[0] = (uint64_t)vm_n[n1].value;
|
|
num_var[nid].dim[1] = 0;
|
|
num_var[nid].dim[2] = 0;
|
|
}
|
|
|
|
void dim_num2_95(uint64_t nid, int n1, int n2)
|
|
{
|
|
#ifdef RCBASIC_DEBUG
|
|
if(vm_n[n1].value <= 0 || vm_n[n2].value <= 0)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_DIM_LEQ_ZERO;
|
|
return;
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
num_var[nid].nid_value.value.resize((uint64_t)vm_n[n1].value * (uint64_t)vm_n[n2].value);
|
|
num_var[nid].nref = &num_var[nid].nid_value;
|
|
num_var[nid].dimensions = 2;
|
|
num_var[nid].dim[0] = (uint64_t)vm_n[n1].value;
|
|
num_var[nid].dim[1] = (uint64_t)vm_n[n2].value;
|
|
num_var[nid].dim[2] = 0;
|
|
}
|
|
|
|
void dim_num3_96(uint64_t nid, int n1, int n2, int n3)
|
|
{
|
|
#ifdef RCBASIC_DEBUG
|
|
if(vm_n[n1].value <= 0 || vm_n[n2].value <= 0 || vm_n[n3].value <= 0)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_DIM_LEQ_ZERO;
|
|
return;
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
num_var[nid].nid_value.value.resize((uint64_t)vm_n[n1].value * (uint64_t)vm_n[n2].value * (uint64_t)vm_n[n3].value);
|
|
num_var[nid].nref = &num_var[nid].nid_value;
|
|
num_var[nid].dimensions = 3;
|
|
num_var[nid].dim[0] = (uint64_t)vm_n[n1].value;
|
|
num_var[nid].dim[1] = (uint64_t)vm_n[n2].value;
|
|
num_var[nid].dim[2] = (uint64_t)vm_n[n3].value;
|
|
}
|
|
|
|
void dim_str1_97(uint64_t sid, int n1)
|
|
{
|
|
#ifdef RCBASIC_DEBUG
|
|
if(vm_n[n1].value <= 0)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_DIM_LEQ_ZERO;
|
|
return;
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
str_var[sid].sid_value.value.resize((uint64_t)vm_n[n1].value);
|
|
str_var[sid].sref = &str_var[sid].sid_value;
|
|
str_var[sid].dimensions = 1;
|
|
str_var[sid].dim[0] = (uint64_t)vm_n[n1].value;
|
|
str_var[sid].dim[1] = 0;
|
|
str_var[sid].dim[2] = 0;
|
|
}
|
|
|
|
void dim_str2_98(uint64_t sid, int n1, int n2)
|
|
{
|
|
#ifdef RCBASIC_DEBUG
|
|
if(vm_n[n1].value <= 0 || vm_n[n2].value <= 0)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_DIM_LEQ_ZERO;
|
|
return;
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
str_var[sid].sid_value.value.resize((uint64_t)vm_n[n1].value * (uint64_t)vm_n[n2].value);
|
|
str_var[sid].sref = &str_var[sid].sid_value;
|
|
str_var[sid].dimensions = 2;
|
|
str_var[sid].dim[0] = (uint64_t)vm_n[n1].value;
|
|
str_var[sid].dim[1] = (uint64_t)vm_n[n2].value;
|
|
str_var[sid].dim[2] = 0;
|
|
}
|
|
|
|
void dim_str3_99(uint64_t sid, int n1, int n2, int n3)
|
|
{
|
|
#ifdef RCBASIC_DEBUG
|
|
if(vm_n[n1].value <= 0 || vm_n[n2].value <= 0 || vm_n[n3].value <= 0)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_DIM_LEQ_ZERO;
|
|
return;
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
str_var[sid].sid_value.value.resize((uint64_t)vm_n[n1].value * (uint64_t)vm_n[n2].value * (uint64_t)vm_n[n3].value);
|
|
str_var[sid].sref = &str_var[sid].sid_value;
|
|
str_var[sid].dimensions = 3;
|
|
str_var[sid].dim[0] = (uint64_t)vm_n[n1].value;
|
|
str_var[sid].dim[1] = (uint64_t)vm_n[n2].value;
|
|
str_var[sid].dim[2] = (uint64_t)vm_n[n3].value;
|
|
}
|
|
|
|
void delete_100(uint64_t nid)
|
|
{
|
|
num_var[nid].nid_value.value.clear();
|
|
num_var[nid].nid_value.value.shrink_to_fit();
|
|
num_var[nid].dimensions = 0;
|
|
num_var[nid].dim[0] = 0;
|
|
num_var[nid].dim[1] = 0;
|
|
num_var[nid].dim[2] = 0;
|
|
}
|
|
|
|
void deleteS_101(uint64_t sid)
|
|
{
|
|
str_var[sid].sid_value.value.clear();
|
|
str_var[sid].sid_value.value.shrink_to_fit();
|
|
str_var[sid].dimensions = 0;
|
|
str_var[sid].dim[0] = 0;
|
|
str_var[sid].dim[1] = 0;
|
|
str_var[sid].dim[2] = 0;
|
|
}
|
|
|
|
void push_102(int n1)
|
|
{
|
|
//n_stack[current_n_stack_count] = vm_n[n1].value;
|
|
//current_n_stack_count++;
|
|
n_stack.push(vm_n[n1]);
|
|
}
|
|
|
|
void push_103(uint64_t nid)
|
|
{
|
|
//n_stack[current_n_stack_count] = num_var[nid].value[0];
|
|
//current_n_stack_count++;
|
|
rc_vm_n n;
|
|
uint64_t byref_offset = num_var[nid].byref_offset;
|
|
n.value = num_var[nid].nref[0].value[byref_offset];
|
|
n.r_index = byref_offset;
|
|
n_stack.push(n);
|
|
}
|
|
|
|
void pushS_104(int s1)
|
|
{
|
|
//s_stack[current_s_stack_count] = vm_s[s1].value;
|
|
//current_s_stack_count++;
|
|
s_stack.push(vm_s[s1]);
|
|
}
|
|
|
|
void pushS_105(uint64_t sid)
|
|
{
|
|
//s_stack[current_s_stack_count] = str_var[sid].value[0];
|
|
//current_s_stack_count++;
|
|
rc_vm_s s;
|
|
uint64_t byref_offset = str_var[sid].byref_offset;
|
|
s.value = str_var[sid].sref[0].value[byref_offset];
|
|
s.r_index = byref_offset;
|
|
s_stack.push(s);
|
|
}
|
|
|
|
void push_emptyS_106()
|
|
{
|
|
rc_vm_s s_empty;
|
|
s_empty.value = "";
|
|
//s_stack[current_s_stack_count] = "";
|
|
//current_s_stack_count++;
|
|
s_stack.push(s_empty);
|
|
}
|
|
|
|
void pop_107(int n1)
|
|
{
|
|
//current_n_stack_count--;
|
|
//vm_n[n1].value = n_stack[current_n_stack_count];
|
|
vm_n[n1].value = n_stack.top().value;
|
|
vm_n[n1].r = n_stack.top().r;
|
|
vm_n[n1].r_index = n_stack.top().r_index;
|
|
n_stack.pop();
|
|
}
|
|
|
|
void pop_108(uint64_t nid)
|
|
{
|
|
//current_n_stack_count--;
|
|
//num_var[nid].value[0] = n_stack[current_n_stack_count];
|
|
uint64_t byref_offset = n_stack.top().r_index;
|
|
num_var[nid].nref[0].value[byref_offset] = n_stack.top().value;
|
|
num_var[nid].byref_offset = byref_offset;
|
|
n_stack.pop();
|
|
}
|
|
|
|
void popS_109(int s1)
|
|
{
|
|
//current_s_stack_count--;
|
|
//vm_s[s1].value = s_stack[current_s_stack_count];
|
|
vm_s[s1].value = s_stack.top().value;
|
|
vm_s[s1].r = s_stack.top().r;
|
|
vm_s[s1].r_index = s_stack.top().r_index;
|
|
s_stack.pop();
|
|
}
|
|
|
|
void popS_110(uint64_t sid)
|
|
{
|
|
//current_s_stack_count--;
|
|
//str_var[sid].value[0] = s_stack[current_s_stack_count];
|
|
uint64_t byref_offset = s_stack.top().r_index;
|
|
str_var[sid].sref[0].value[byref_offset] = s_stack.top().value;
|
|
str_var[sid].byref_offset = byref_offset;
|
|
s_stack.pop();
|
|
}
|
|
|
|
void get_stack_size_111(int n1)
|
|
{
|
|
vm_n[n1].value = n_stack.size();
|
|
}
|
|
|
|
void get_stack_sizeS_112(int n1)
|
|
{
|
|
vm_n[n1].value = s_stack.size();
|
|
}
|
|
|
|
void clear_stack_113()
|
|
{
|
|
//current_n_stack_count = 0;
|
|
n_stack.empty();
|
|
}
|
|
|
|
void clear_stackS_114()
|
|
{
|
|
//current_s_stack_count = 0;
|
|
s_stack.empty();
|
|
}
|
|
|
|
void while_115(int n1, uint64_t jmp_addr)
|
|
{
|
|
if(vm_n[n1].value == 0)
|
|
current_address = jmp_addr;
|
|
//rc_events();
|
|
}
|
|
|
|
void wend_116(uint64_t jmp_addr)
|
|
{
|
|
current_address = jmp_addr;
|
|
}
|
|
|
|
void for_117(uint64_t nid, int n1, int n2, int n3)
|
|
{
|
|
rc_loop for_loop;
|
|
for_loop.counter = &num_var[nid];
|
|
for_loop.f_end = vm_n[n2].value;
|
|
for_loop.f_step = vm_n[n3].value;
|
|
|
|
switch(for_offset_dimensions)
|
|
{
|
|
case 1:
|
|
for_loop.counter_offset = for_offset_index[0];
|
|
break;
|
|
case 2:
|
|
for_loop.counter_offset = for_offset_index[0] * num_var[nid].dim[1] + for_offset_index[1];
|
|
break;
|
|
case 3:
|
|
for_loop.counter_offset = ( for_offset_index[0] * num_var[nid].dim[1] * num_var[nid].dim[2] ) + (for_offset_index[1] * num_var[nid].dim[2]) + for_offset_index[2];
|
|
break;
|
|
default:
|
|
for_loop.counter_offset = 0;
|
|
}
|
|
|
|
uint64_t byref_offset = num_var[nid].byref_offset;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
uint64_t nv_size = 1;
|
|
uint64_t dbg_index = num_var[nid].dbg_var_index;
|
|
rcbasic_debug_access_status tmp_stat;
|
|
for_loop.counter_dim[0] = for_offset_index[0];
|
|
for_loop.counter_dim[1] = for_offset_index[1];
|
|
for_loop.counter_dim[2] = for_offset_index[2];
|
|
|
|
switch(num_var[nid].dimensions)
|
|
{
|
|
case 3: nv_size *= num_var[nid].dim[2];
|
|
case 2: nv_size *= num_var[nid].dim[1];
|
|
case 1: nv_size *= num_var[nid].dim[0];
|
|
break;
|
|
}
|
|
|
|
if(num_var[nid].is_debug_var)
|
|
{
|
|
tmp_stat.dimensions = num_var[nid].dimensions;
|
|
tmp_stat.dim[0] = for_offset_index[0];
|
|
tmp_stat.dim[1] = for_offset_index[1];
|
|
tmp_stat.dim[2] = for_offset_index[2];
|
|
tmp_stat.num_val = vm_n[n1].value;
|
|
tmp_stat.reg = -1;
|
|
tmp_stat.type = RCBASIC_DEBUG_ACCESS_SET;
|
|
}
|
|
|
|
if((byref_offset + for_loop.counter_offset) >= nv_size && num_var[nid].is_debug_var)
|
|
{
|
|
if(dbg_vars[num_var[nid].dbg_var_index].type != RCBASIC_DEBUG_VAR_BYREF_NUM)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_INDEX_EXCEEDS_SIZE;
|
|
|
|
if(num_var[nid].is_debug_var)
|
|
tmp_stat.is_error = true;
|
|
|
|
dbg_vars[dbg_index].usage_data.push_back(tmp_stat);
|
|
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dbg_vars[dbg_index].usage_data.push_back(tmp_stat);
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
|
|
num_var[nid].nref[0].value[byref_offset + for_loop.counter_offset] = vm_n[n1].value;
|
|
|
|
|
|
//These 3 lines reads the line value passed by the compiler
|
|
//This line value is the address of the end of the loop
|
|
unsigned rcbasic_cmd = segment[current_segment][current_address];
|
|
current_address++;
|
|
uint64_t for_end_addr = readInt();
|
|
|
|
//cout << "next_addr: " << next_addr << endl;
|
|
|
|
if( vm_n[n2].value < vm_n[n1].value )
|
|
{
|
|
for_loop.isNegative = true;
|
|
|
|
if(for_loop.f_step > 0)
|
|
{
|
|
current_address = for_end_addr;
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for_loop.isNegative = false;
|
|
|
|
if(for_loop.f_step < 0)
|
|
{
|
|
current_address = for_end_addr;
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
loop_stack.push(for_loop);
|
|
//current_loop_stack_count++;
|
|
//cout << "nid = " << nid << " --> " << (uint64_t)(&num_var[nid].nid_value[0].value[0]) << endl;
|
|
//cout << "nid_value = " << num_var[nid].nid_value[0].value[0] << endl;
|
|
//cout << "id[10] = " << num_var[10].nid_value[0].value[0] << " --> " << (uint64_t)(&num_var[10].nid_value[0].value[0]) << endl;
|
|
//cout << "id[11] = " << num_var[11].nid_value[0].value[0] << " --> " << (uint64_t)(&num_var[11].nid_value[0].value[0]) << endl;
|
|
//cin.get();
|
|
}
|
|
|
|
void next_118(uint64_t f_addr)
|
|
{
|
|
//int l_index = current_loop_stack_count-1;
|
|
uint64_t byref_offset = loop_stack.top().counter[0].byref_offset + loop_stack.top().counter_offset;
|
|
double next_step = loop_stack.top().counter[0].nref[0].value[byref_offset] + loop_stack.top().f_step;
|
|
if(loop_stack.top().isNegative && next_step <= loop_stack.top().counter[0].nref[0].value[byref_offset] && next_step >= loop_stack.top().f_end)
|
|
{
|
|
loop_stack.top().counter[0].nref[0].value[byref_offset] += loop_stack.top().f_step;
|
|
current_address = f_addr;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
if(loop_stack.top().counter[0].is_debug_var)
|
|
{
|
|
rcbasic_debug_access_status tmp_stat;
|
|
tmp_stat.dimensions = loop_stack.top().counter[0].dimensions;
|
|
tmp_stat.dim[0] = loop_stack.top().counter_dim[0];
|
|
tmp_stat.dim[1] = loop_stack.top().counter_dim[1];
|
|
tmp_stat.dim[2] = loop_stack.top().counter_dim[2];
|
|
tmp_stat.type = RCBASIC_DEBUG_ACCESS_SET;
|
|
tmp_stat.num_val = loop_stack.top().counter[0].nid_value[0].value[byref_offset];
|
|
dbg_vars[loop_stack.top().counter[0].dbg_var_index].usage_data.push_back(tmp_stat);
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
else if( (!loop_stack.top().isNegative) && next_step >= loop_stack.top().counter[0].nref[0].value[byref_offset] && next_step <= loop_stack.top().f_end)
|
|
{
|
|
loop_stack.top().counter[0].nref[0].value[byref_offset] += loop_stack.top().f_step;
|
|
current_address = f_addr;
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
if(loop_stack.top().counter[0].is_debug_var)
|
|
{
|
|
rcbasic_debug_access_status tmp_stat;
|
|
tmp_stat.dimensions = loop_stack.top().counter[0].dimensions;
|
|
tmp_stat.dim[0] = loop_stack.top().counter_dim[0];
|
|
tmp_stat.dim[1] = loop_stack.top().counter_dim[1];
|
|
tmp_stat.dim[2] = loop_stack.top().counter_dim[2];
|
|
tmp_stat.type = RCBASIC_DEBUG_ACCESS_SET;
|
|
tmp_stat.num_val = loop_stack.top().counter[0].nid_value[0].value[byref_offset];
|
|
dbg_vars[loop_stack.top().counter[0].dbg_var_index].usage_data.push_back(tmp_stat);
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
}
|
|
else
|
|
{
|
|
loop_stack.pop();
|
|
//current_loop_stack_count--;
|
|
}
|
|
//cout << "id[10] = " << num_var[10].nid_value[0].value[0] << " --> " << (uint64_t)(&num_var[10].nid_value[0].value[0]) << endl;
|
|
//cout << "id[11] = " << num_var[11].nid_value[0].value[0] << " --> " << (uint64_t)(&num_var[11].nid_value[0].value[0]) << endl;
|
|
//cin.get();
|
|
//there is no point in trying to poll events in a for loop so i disabled it
|
|
//rc_events();
|
|
}
|
|
|
|
void do_119() //I realized that I didn't need this so its here so I can keep numbered order from my initial design
|
|
{
|
|
}
|
|
|
|
void loop_120(uint64_t jmp_addr) //not actually used
|
|
{
|
|
current_address = jmp_addr;
|
|
//rc_events();
|
|
}
|
|
|
|
void loop_while_121(int n1, uint64_t jmp_addr)
|
|
{
|
|
if(vm_n[n1].value != 0)
|
|
current_address = jmp_addr;
|
|
//rc_events();
|
|
}
|
|
|
|
void loop_until_122(int n1, uint64_t jmp_addr)
|
|
{
|
|
if(vm_n[n1].value == 0)
|
|
current_address = jmp_addr;
|
|
//rc_events();
|
|
}
|
|
|
|
void pop_loop_stack_123()
|
|
{
|
|
loop_stack.pop();
|
|
}
|
|
|
|
void gosub_124(uint64_t sub_addr)
|
|
{
|
|
//cout << "gosub" << endl;
|
|
gosub_return_addr.push(current_segment);
|
|
gosub_return_addr.push(current_address);
|
|
current_segment = DATA_SEGMENT;
|
|
current_address = sub_addr;
|
|
//cout << "sub: " << sub_addr << endl;
|
|
}
|
|
|
|
void return_125()
|
|
{
|
|
//cout << "\nvar 0 = " << num_var[0].value[0] << endl;
|
|
//cout << "var1 = " << num_var[1].value[0] << endl;
|
|
//cout << "current address = " << current_segment << " : " << current_address << endl;
|
|
current_address = gosub_return_addr.top();
|
|
gosub_return_addr.pop();
|
|
current_segment = gosub_return_addr.top();
|
|
gosub_return_addr.pop();
|
|
//cout << "return to: " << current_segment << " : " << current_address << endl;
|
|
}
|
|
|
|
addr_entry byref_id;
|
|
|
|
#define BYREF_TYPE_NUM 0
|
|
#define BYREF_TYPE_STR 1
|
|
#define BYREF_TYPE_USR 2
|
|
|
|
void ptr_126(uint64_t nid, int n1)
|
|
{
|
|
byref_id.ptr_id = nid;
|
|
byref_id.ptr_addr = num_var[nid].nref;
|
|
byref_id.type = BYREF_TYPE_NUM;
|
|
byref_addr_table.push(byref_id);
|
|
byref_var_byref_offset.push(num_var[nid].byref_offset);
|
|
num_var[nid].nref = vm_n[n1].r;
|
|
num_var[nid].byref_offset = vm_n[n1].r_index;
|
|
num_var[nid].nid_value.ref_parent = vm_n[n1].r->ref_parent;
|
|
}
|
|
|
|
void ptrS_127(uint64_t sid, int s1)
|
|
{
|
|
byref_id.ptr_id = sid;
|
|
byref_id.ptr_addr = str_var[sid].sref;
|
|
byref_id.type = BYREF_TYPE_STR;
|
|
byref_addr_table.push(byref_id);
|
|
byref_var_byref_offset.push(str_var[sid].byref_offset);
|
|
str_var[sid].sref = vm_s[s1].r;
|
|
str_var[sid].byref_offset = vm_s[s1].r_index;
|
|
str_var[sid].sid_value.ref_parent = vm_s[s1].r->ref_parent;
|
|
}
|
|
|
|
void rc_print_num(double n)
|
|
{
|
|
stringstream s;
|
|
s << fixed << n;
|
|
string s_out = s.str();
|
|
int s_decimal = s_out.find_first_of(".");
|
|
if(s_decimal != string::npos)
|
|
{
|
|
int trail_end = s_out.length();
|
|
for(int i = s_decimal; i < s_out.length(); i++)
|
|
{
|
|
if(s_out[i] != '0')
|
|
trail_end = i+1;
|
|
}
|
|
s_out = s_out.substr(0, trail_end);
|
|
if(s_out.substr(s_out.length()-1,1).compare(".")==0)
|
|
s_out = s_out.substr(0, s_out.length()-1);
|
|
}
|
|
cout << s_out;
|
|
}
|
|
|
|
void print_128(int n1)
|
|
{
|
|
rc_print_num(vm_n[n1].value);
|
|
}
|
|
|
|
void printS_129(int s1)
|
|
{
|
|
cout << vm_s[s1].value;
|
|
}
|
|
|
|
void rc_push_num(double n_val)
|
|
{
|
|
rc_vm_n n;
|
|
n.value = n_val;
|
|
n_stack.push(n);
|
|
//current_n_stack_count++;
|
|
}
|
|
|
|
void rc_push_str(string s_val)
|
|
{
|
|
rc_vm_s s;
|
|
s.value = s_val;
|
|
s_stack.push(s);
|
|
//current_s_stack_count++;
|
|
}
|
|
|
|
uint64_t rc_string_array_dim(rc_strId* s_var)
|
|
{
|
|
rc_strId* s = (rc_strId*)s_var->sid_value.ref_parent;
|
|
return s->dimensions;
|
|
}
|
|
|
|
uint64_t rc_string_array_size(rc_strId* s_var, int d_num)
|
|
{
|
|
switch(d_num)
|
|
{
|
|
case 1:
|
|
return s_var->dim[0];
|
|
break;
|
|
case 2:
|
|
return s_var->dim[1];
|
|
break;
|
|
case 3:
|
|
return s_var->dim[2];
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
uint64_t rc_number_array_dim(rc_numId* n_var)
|
|
{
|
|
rc_numId* n = (rc_numId*)n_var->nid_value.ref_parent;
|
|
return n->dimensions;
|
|
}
|
|
|
|
uint64_t rc_type_array_dim(rc_usrId* u_var)
|
|
{
|
|
return u_var->dimensions;
|
|
}
|
|
|
|
uint64_t rc_type_array_size(rc_usrId* u_var, int d_num)
|
|
{
|
|
switch(d_num)
|
|
{
|
|
case 1:
|
|
return u_var->dim[0];
|
|
break;
|
|
case 2:
|
|
return u_var->dim[1];
|
|
break;
|
|
case 3:
|
|
return u_var->dim[2];
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void rc_type_array_copy(rc_usrId* src, rc_usrId* dst)
|
|
{
|
|
//cout << "Copy Type" << endl;
|
|
rc_usrId* parent = dst;
|
|
|
|
//cout << "freed up" << endl;
|
|
|
|
//parent[0] = src[0];
|
|
|
|
//cout << "done" << endl;
|
|
|
|
//return;
|
|
|
|
|
|
//cout << "db[1]" << endl;
|
|
parent->dimensions = src->dimensions;
|
|
//cout << "db[2]" << endl;
|
|
parent->dim[0] = src->dim[0];
|
|
parent->dim[1] = src->dim[1];
|
|
parent->dim[2] = src->dim[2];
|
|
//cout << "db[3]" << endl;
|
|
|
|
parent->byref_offset = 0;
|
|
//cout << "db[4]" << endl;
|
|
parent->uid_value.resize(src->uid_value.size());
|
|
//cout << "db[5]" << endl;
|
|
|
|
parent->var_ref = parent;
|
|
parent->var_ref_index = 0;
|
|
|
|
|
|
|
|
rc_usrId* p_obj;
|
|
|
|
uint64_t field_size = 0;
|
|
|
|
rc_usrId* s_obj;
|
|
//cout << "starting field: " << endl;
|
|
|
|
for(uint64_t i = 0; i < src->uid_value.size(); i++)
|
|
{
|
|
s_obj = &src->uid_value[i];
|
|
p_obj = &parent->uid_value[i];
|
|
|
|
p_obj->byref_offset = 0;
|
|
p_obj->byref_ptr = parent;
|
|
p_obj->dim[0] = s_obj->dim[0];
|
|
p_obj->dim[1] = s_obj->dim[1];
|
|
p_obj->dim[2] = s_obj->dim[2];
|
|
p_obj->dimensions = s_obj->dimensions;
|
|
p_obj->preset_init = s_obj->preset_init;
|
|
p_obj->udt_index = s_obj->udt_index;
|
|
p_obj->var_ref = p_obj;
|
|
p_obj->var_ref_index = 0;
|
|
|
|
//cout << "num" << endl;
|
|
p_obj->num_var.resize(s_obj->num_var.size());
|
|
for(int nfield = 0; nfield < s_obj->num_var.size(); nfield++)
|
|
{
|
|
p_obj->num_var[nfield] = s_obj->num_var[nfield];
|
|
}
|
|
|
|
//cout << "str" << endl;
|
|
p_obj->str_var.resize(s_obj->str_var.size());
|
|
for(int sfield = 0; sfield < s_obj->str_var.size(); sfield++)
|
|
{
|
|
p_obj->str_var[sfield] = s_obj->str_var[sfield];
|
|
}
|
|
|
|
//cout << "copy uid field" << endl;
|
|
p_obj->uid_value.resize(s_obj->uid_value.size());
|
|
for(int ufield = 0; ufield < s_obj->uid_value.size(); ufield++)
|
|
{
|
|
rc_type_array_copy(s_obj, p_obj);
|
|
}
|
|
}
|
|
|
|
//cout << "done" << endl;
|
|
|
|
}
|
|
|
|
void rc_type_array_fill(rc_usrId* src, rc_usrId* fdata)
|
|
{
|
|
rc_usrId* p_obj;
|
|
|
|
for(int i = 0; i < src->uid_value.size(); i++)
|
|
{
|
|
p_obj = &src->uid_value[i];
|
|
p_obj[0] = fdata[0];
|
|
}
|
|
|
|
}
|
|
|
|
|
|
uint64_t rc_number_array_size(rc_numId* n_var, int d_num)
|
|
{
|
|
switch(d_num)
|
|
{
|
|
case 1:
|
|
return n_var->dim[0];
|
|
break;
|
|
case 2:
|
|
return n_var->dim[1];
|
|
break;
|
|
case 3:
|
|
return n_var->dim[2];
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void rc_number_array_copy(rc_numId* n_var, rc_numId* d_var)
|
|
{
|
|
uint64_t src_dim, src_dim_size[3];
|
|
rc_numId* src = (rc_numId*)n_var->nid_value.ref_parent;
|
|
src_dim = rc_number_array_dim( src );
|
|
src_dim_size[0] = rc_number_array_size( src, 1);
|
|
src_dim_size[1] = rc_number_array_size( src, 2);
|
|
src_dim_size[2] = rc_number_array_size( src, 3);
|
|
|
|
rc_numId* dst = (rc_numId*)d_var->nid_value.ref_parent;
|
|
|
|
uint64_t total_size = 0;
|
|
|
|
switch(src_dim)
|
|
{
|
|
case 1:
|
|
total_size = src_dim_size[0];
|
|
dst->nref[0].value.resize(total_size);
|
|
//dst->dimensions = 1;
|
|
dst->dim[0] = src_dim_size[0];
|
|
dst->dim[1] = 0;
|
|
dst->dim[2] = 0;
|
|
break;
|
|
case 2:
|
|
total_size = src_dim_size[0] * src_dim_size[1];
|
|
dst->nref[0].value.resize(total_size);
|
|
//dst->dimensions = 2;
|
|
dst->dim[0] = src_dim_size[0];
|
|
dst->dim[1] = src_dim_size[1];
|
|
dst->dim[2] = 0;
|
|
break;
|
|
case 3:
|
|
total_size = src_dim_size[0] * src_dim_size[1] * src_dim_size[2];
|
|
dst->nref[0].value.resize(total_size);
|
|
//dst->dimensions = 3;
|
|
dst->dim[0] = src_dim_size[0];
|
|
dst->dim[1] = src_dim_size[1];
|
|
dst->dim[2] = src_dim_size[2];
|
|
break;
|
|
}
|
|
|
|
int si = n_var->byref_offset;
|
|
int di = d_var->byref_offset;
|
|
|
|
//cout << "debug: " << si << ", " << di << endl;
|
|
|
|
for(; di < total_size; di++)
|
|
{
|
|
dst->nref[0].value[di] = src->nref[0].value[si];
|
|
|
|
si++;
|
|
}
|
|
}
|
|
|
|
void rc_string_array_copy(rc_strId* s_var, rc_strId* d_var)
|
|
{
|
|
uint64_t src_dim, src_dim_size[3];
|
|
rc_strId* src = (rc_strId*)s_var->sid_value.ref_parent;
|
|
src_dim = rc_string_array_dim( src );
|
|
src_dim_size[0] = rc_string_array_size( src, 1);
|
|
src_dim_size[1] = rc_string_array_size( src, 2);
|
|
src_dim_size[2] = rc_string_array_size( src, 3);
|
|
|
|
rc_strId* dst = (rc_strId*)d_var->sid_value.ref_parent;
|
|
|
|
uint64_t total_size = 0;
|
|
|
|
switch(src_dim)
|
|
{
|
|
case 1:
|
|
total_size = src_dim_size[0];
|
|
dst->sref[0].value.resize(total_size);
|
|
//dst->dimensions = 1;
|
|
dst->dim[0] = src_dim_size[0];
|
|
dst->dim[1] = 0;
|
|
dst->dim[2] = 0;
|
|
break;
|
|
case 2:
|
|
total_size = src_dim_size[0] * src_dim_size[1];
|
|
dst->sref[0].value.resize(total_size);
|
|
//dst->dimensions = 2;
|
|
dst->dim[0] = src_dim_size[0];
|
|
dst->dim[1] = src_dim_size[1];
|
|
dst->dim[2] = 0;
|
|
break;
|
|
case 3:
|
|
total_size = src_dim_size[0] * src_dim_size[1] * src_dim_size[2];
|
|
dst->sref[0].value.resize(total_size);
|
|
//dst->dimensions = 3;
|
|
dst->dim[0] = src_dim_size[0];
|
|
dst->dim[1] = src_dim_size[1];
|
|
dst->dim[2] = src_dim_size[2];
|
|
break;
|
|
}
|
|
|
|
int si = s_var->byref_offset;
|
|
int di = d_var->byref_offset;
|
|
|
|
//cout << "debug: " << si << ", " << di << endl;
|
|
|
|
for(; di < total_size; di++)
|
|
{
|
|
dst->sref[0].value[di] = src->sref[0].value[si];
|
|
|
|
si++;
|
|
}
|
|
}
|
|
|
|
void rc_number_array_fill(rc_numId* n_var, double n)
|
|
{
|
|
uint64_t src_dim, src_dim_size[3];
|
|
rc_numId* src = (rc_numId*)n_var->nid_value.ref_parent;
|
|
src_dim = rc_number_array_dim( src );
|
|
src_dim_size[0] = rc_number_array_size( src, 1);
|
|
src_dim_size[1] = rc_number_array_size( src, 2);
|
|
src_dim_size[2] = rc_number_array_size( src, 3);
|
|
|
|
uint64_t total_size = 0;
|
|
|
|
switch(src_dim)
|
|
{
|
|
case 1:
|
|
total_size = src_dim_size[0];
|
|
break;
|
|
case 2:
|
|
total_size = src_dim_size[0] * src_dim_size[1];
|
|
break;
|
|
case 3:
|
|
total_size = src_dim_size[0] * src_dim_size[1] * src_dim_size[2];
|
|
break;
|
|
}
|
|
|
|
//cout << "cp 1: " << src->sid_value.value.size() << " " << s_var->byref_offset << endl;
|
|
|
|
for(int i = n_var->byref_offset; i < total_size; i++)
|
|
{
|
|
src->nref[0].value[i] = n;
|
|
}
|
|
}
|
|
|
|
|
|
void rc_string_array_fill(rc_strId* s_var, string s)
|
|
{
|
|
uint64_t src_dim, src_dim_size[3];
|
|
rc_strId* src = (rc_strId*)s_var->sid_value.ref_parent;
|
|
src_dim = rc_string_array_dim( src );
|
|
src_dim_size[0] = rc_string_array_size( src, 1);
|
|
src_dim_size[1] = rc_string_array_size( src, 2);
|
|
src_dim_size[2] = rc_string_array_size( src, 3);
|
|
|
|
uint64_t total_size = 0;
|
|
|
|
switch(src_dim)
|
|
{
|
|
case 1:
|
|
total_size = src_dim_size[0];
|
|
break;
|
|
case 2:
|
|
total_size = src_dim_size[0] * src_dim_size[1];
|
|
break;
|
|
case 3:
|
|
total_size = src_dim_size[0] * src_dim_size[1] * src_dim_size[2];
|
|
break;
|
|
}
|
|
|
|
//cout << "cp 1: " << src->sid_value.value.size() << " " << s_var->byref_offset << endl;
|
|
|
|
for(int i = s_var->byref_offset; i < total_size; i++)
|
|
{
|
|
src->sref[0].value[i] = s;
|
|
}
|
|
}
|
|
|
|
void func_130(uint64_t fn)
|
|
{
|
|
//need to setup a switch statement for all buitlin fucntions here
|
|
switch(fn)
|
|
{
|
|
case FN_FPrint:
|
|
//cout << "gosub addr size: " << gosub_return_addr.size() << endl;
|
|
//cout << "for stack size: " << loop_stack.size() << endl;
|
|
//cout << "byref addr table: " << byref_addr_table.size() << endl << endl;
|
|
rc_fprint( FPRINT_TXT$ );
|
|
break;
|
|
case FN_Input$:
|
|
rc_push_str( rc_input(INPUT$_PROMPT$) );
|
|
break;
|
|
case FN_StringArrayDim:
|
|
rc_push_num( rc_string_array_dim( (rc_strId*) str_var[0].sid_value.ref_parent ) );
|
|
arr_ref_id.clear();
|
|
break;
|
|
case FN_NumberArrayDim:
|
|
rc_push_num( rc_number_array_dim( (rc_numId*)num_var[0].nid_value.ref_parent ) );
|
|
arr_ref_id.clear();
|
|
break;
|
|
case FN_StringArraySize:
|
|
rc_push_num( rc_string_array_size( (rc_strId*) str_var[0].sid_value.ref_parent, STRINGARRAYSIZE_ARRAY_DIM));
|
|
arr_ref_id.clear();
|
|
break;
|
|
case FN_NumberArraySize:
|
|
rc_push_num( rc_number_array_size( (rc_numId*)num_var[0].nid_value.ref_parent, NUMBERARRAYSIZE_ARRAY_DIM));
|
|
arr_ref_id.clear();
|
|
break;
|
|
case FN_Abs:
|
|
rc_push_num( rc_intern_abs( ABS_N ) );
|
|
break;
|
|
case FN_ACos:
|
|
rc_push_num( rc_intern_aCos( ACOS_N ) );
|
|
break;
|
|
case FN_AndBit:
|
|
rc_push_num( rc_intern_andBit( ANDBIT_A, ANDBIT_B ) );
|
|
break;
|
|
case FN_ASin:
|
|
rc_push_num( rc_intern_aSin( ASIN_N ) );
|
|
break;
|
|
case FN_ATan:
|
|
rc_push_num( rc_intern_aTan( ATAN_N ) );
|
|
break;
|
|
case FN_Bin$:
|
|
rc_push_str( rc_intern_bin( BIN$_N ) );
|
|
break;
|
|
case FN_CInt32:
|
|
rc_push_num( rc_intern_cint32( CINT32_I ));
|
|
break;
|
|
case FN_CInt64:
|
|
rc_push_num( rc_intern_cint64( CINT64_I ));
|
|
break;
|
|
case FN_Cos:
|
|
rc_push_num( rc_intern_cos( COS_N ) );
|
|
break;
|
|
case FN_Degrees:
|
|
rc_push_num( rc_intern_degrees(DEGREES_R));
|
|
break;
|
|
case FN_Exp:
|
|
rc_push_num( rc_intern_exp( EXP_N ) );
|
|
break;
|
|
case FN_Frac:
|
|
rc_push_num( rc_intern_frac( FRAC_N ) );
|
|
break;
|
|
case FN_Hex$:
|
|
rc_push_str( rc_intern_hex( HEX$_N ) );
|
|
break;
|
|
case FN_HexVal:
|
|
rc_push_num( rc_intern_hexInt( HEXVAL_N$ ) );
|
|
break;
|
|
case FN_Int:
|
|
rc_push_num( rc_intern_int( INT_N ) );
|
|
break;
|
|
case FN_Log:
|
|
rc_push_num( rc_intern_log( LOG_N ) );
|
|
break;
|
|
case FN_Max:
|
|
rc_push_num( rc_intern_max( MAX_A, MAX_B ) );
|
|
break;
|
|
case FN_Min:
|
|
rc_push_num( rc_intern_min( MIN_A, MIN_B ) );
|
|
break;
|
|
case FN_OrBit:
|
|
rc_push_num( rc_intern_orBit( ORBIT_A, ORBIT_B ) );
|
|
break;
|
|
case FN_Radians:
|
|
rc_push_num( rc_intern_radians(RADIANS_D));
|
|
break;
|
|
case FN_Randomize:
|
|
rc_push_num( rc_intern_randomize( RANDOMIZE_N ) );
|
|
break;
|
|
case FN_Rand:
|
|
rc_push_num( rc_intern_rand( RAND_N ) );
|
|
break;
|
|
case FN_Round:
|
|
rc_push_num( rc_intern_round( ROUND_N ) );
|
|
break;
|
|
case FN_Sign:
|
|
rc_push_num( rc_intern_sign( SIGN_N ) );
|
|
break;
|
|
case FN_Sin:
|
|
rc_push_num( rc_intern_sin( SIN_N ) );
|
|
break;
|
|
case FN_Sqrt:
|
|
rc_push_num( rc_intern_sqrt( SQRT_N ) );
|
|
break;
|
|
case FN_Tan:
|
|
rc_push_num( rc_intern_tan( TAN_N ) );
|
|
break;
|
|
case FN_XOrBit:
|
|
rc_push_num( rc_intern_xorbit( XORBIT_A, XORBIT_B ) );
|
|
break;
|
|
case FN_Asc:
|
|
rc_push_num( rc_intern_asc( ASC_C$ ) );
|
|
break;
|
|
case FN_Chr$:
|
|
rc_push_str( rc_intern_chr( CHR$_N ) );
|
|
break;
|
|
case FN_Insert$:
|
|
rc_push_str( rc_intern_insert( INSERT$_SRC$, INSERT$_TGT$, INSERT$_POS ) );
|
|
break;
|
|
case FN_InStr:
|
|
rc_push_num( rc_intern_instr( INSTR_SRC$, INSTR_SUBSTR$ ) );
|
|
break;
|
|
case FN_LCase$:
|
|
rc_push_str( rc_intern_lcase( LCASE$_SRC$ ) );
|
|
break;
|
|
case FN_Left$:
|
|
rc_push_str( rc_intern_left( LEFT$_SRC$, LEFT$_N ) );
|
|
break;
|
|
case FN_Len:
|
|
rc_push_num( rc_intern_length( LEN_SRC$ ) );
|
|
break;
|
|
case FN_Length:
|
|
rc_push_num( rc_intern_length( LENGTH_SRC$ ) );
|
|
break;
|
|
case FN_LTrim$:
|
|
rc_push_str( rc_intern_ltrim( LTRIM$_SRC$ ) );
|
|
break;
|
|
case FN_Mid$:
|
|
rc_push_str( rc_intern_mid( MID$_SRC$, MID$_START, MID$_N ) );
|
|
break;
|
|
case FN_ReplaceSubstr$:
|
|
rc_push_str( rc_intern_replaceSubstr( REPLACESUBSTR$_SRC$, REPLACESUBSTR$_RPC$, REPLACESUBSTR$_POS) );
|
|
break;
|
|
case FN_Replace$:
|
|
rc_push_str( rc_intern_replace( REPLACE$_SRC$, REPLACE$_TGT$, REPLACE$_RPC$ ) );
|
|
break;
|
|
case FN_Reverse$:
|
|
rc_push_str( rc_intern_reverse( REVERSE$_SRC$ ) );
|
|
break;
|
|
case FN_Right$:
|
|
rc_push_str( rc_intern_right( RIGHT$_SRC$, RIGHT$_N ) );
|
|
break;
|
|
case FN_RTrim$:
|
|
rc_push_str( rc_intern_rtrim( RTRIM$_SRC$ ) );
|
|
break;
|
|
case FN_StringFill$:
|
|
rc_push_str( rc_intern_stringfill( STRINGFILL$_SRC$, STRINGFILL$_N ) );
|
|
break;
|
|
case FN_Str$:
|
|
rc_push_str( rc_intern_str( STR$_N ) );
|
|
break;
|
|
case FN_Str_F$:
|
|
rc_push_str( rc_intern_str_f( STR_F$_N ) );
|
|
break;
|
|
case FN_Str_S$:
|
|
rc_push_str( rc_intern_str_s( STR_S$_N ) );
|
|
break;
|
|
case FN_Tally:
|
|
rc_push_num( rc_intern_tally( TALLY_SRC$, TALLY_SUBSTR$ ) );
|
|
break;
|
|
case FN_Trim$:
|
|
rc_push_str( rc_intern_trim( TRIM$_SRC$ ) );
|
|
break;
|
|
case FN_UCase$:
|
|
rc_push_str( rc_intern_ucase( UCASE$_SRC$ ) );
|
|
break;
|
|
case FN_Val:
|
|
rc_push_num( rc_intern_val( VAL_N$ ) );
|
|
break;
|
|
case FN_Stack_N: //Sub Procedure
|
|
if(STACK_N_N >= 0 && STACK_N_N <= (MAX_USER_STACKS-1))
|
|
rc_user_active_n_stack = STACK_N_N;
|
|
else
|
|
cout << "Stack_N Error: Exceeds available stacks" << endl;
|
|
break;
|
|
case FN_Stack_S: //Sub Procedure
|
|
if(STACK_S_N >= 0 && STACK_S_N <= (MAX_USER_STACKS-1))
|
|
rc_user_active_s_stack = STACK_S_N;
|
|
else
|
|
cout << "Stack_S Error: Exceeds available stacks" << endl;
|
|
break;
|
|
case FN_Push_N:
|
|
rc_intern_push_n( PUSH_N_N );
|
|
break;
|
|
case FN_Pop_N:
|
|
rc_push_num( rc_intern_pop_n() );
|
|
break;
|
|
case FN_Push_S:
|
|
rc_intern_push_s( PUSH_S_S$ );
|
|
break;
|
|
case FN_Pop_S$:
|
|
rc_push_str( rc_intern_pop_s() );
|
|
break;
|
|
case FN_Stack_Size_N:
|
|
rc_push_num( rc_intern_n_stack_size() );
|
|
break;
|
|
case FN_Stack_Size_S:
|
|
rc_push_num( rc_intern_s_stack_size() );
|
|
break;
|
|
case FN_FileOpen:
|
|
rc_push_num( rc_intern_fileOpen( FILEOPEN_STREAM, FILEOPEN_FILENAME$, FILEOPEN_MODE ) );
|
|
break;
|
|
case FN_FileClose:
|
|
rc_intern_fileClose( FILECLOSE_STREAM );
|
|
break;
|
|
case FN_ReadByte:
|
|
rc_push_num( rc_intern_fileReadByte( READBYTE_STREAM ) );
|
|
break;
|
|
case FN_WriteByte:
|
|
rc_intern_fileWriteByte( WRITEBYTE_STREAM, WRITEBYTE_BYTE );
|
|
break;
|
|
case FN_ReadLine$:
|
|
rc_push_str( rc_intern_fileReadLine( READLINE$_STREAM ) );
|
|
break;
|
|
case FN_Write:
|
|
rc_intern_fileWrite( WRITE_STREAM, WRITE_TXT$ );
|
|
break;
|
|
case FN_WriteLine:
|
|
rc_intern_fileWriteLine( WRITELINE_STREAM, WRITELINE_TXT$ );
|
|
break;
|
|
case FN_CopyFile:
|
|
rc_intern_fileCopy( COPYFILE_SRC$, COPYFILE_DST$ );
|
|
break;
|
|
case FN_RemoveFile:
|
|
rc_push_num( rc_intern_fileDelete( REMOVEFILE_FILENAME$ ) );
|
|
break;
|
|
case FN_FileExists:
|
|
rc_push_num( rc_intern_fileExist( FILEEXISTS_FILENAME$ ) );
|
|
break;
|
|
case FN_MoveFile:
|
|
rc_push_num( rc_intern_fileMove( MOVEFILE_SRC$, MOVEFILE_DST$ ) );
|
|
break;
|
|
case FN_RenameFile:
|
|
rc_push_num( rc_intern_fileRename( RENAMEFILE_SRC$, RENAMEFILE_DST$ ) );
|
|
break;
|
|
case FN_FileLength:
|
|
rc_push_num( rc_intern_fileLength( FILELENGTH_FILENAME$ ) );
|
|
break;
|
|
case FN_Tell:
|
|
rc_push_num( rc_intern_fileTell( TELL_STREAM ) );
|
|
break;
|
|
case FN_Seek:
|
|
rc_push_num( rc_intern_fileSeek( SEEK_STREAM, SEEK_POS ) );
|
|
break;
|
|
case FN_EOF:
|
|
rc_push_num( rc_intern_eof( EOF_STREAM ) );
|
|
break;
|
|
case FN_FreeFile:
|
|
rc_push_num( rc_intern_freeFile() );
|
|
break;
|
|
case FN_ChangeDir:
|
|
rc_intern_dirChange( CHANGEDIR_P$ );
|
|
break;
|
|
case FN_DirExists:
|
|
rc_push_num( rc_intern_dirExist( DIREXISTS_P$ ) );
|
|
break;
|
|
case FN_DirFirst$:
|
|
rc_push_str( rc_intern_dirFirst() );
|
|
break;
|
|
case FN_Dir$:
|
|
rc_push_str( rc_intern_dir() );
|
|
break;
|
|
case FN_DirNext$:
|
|
rc_push_str( rc_intern_dirNext() );
|
|
break;
|
|
case FN_MakeDir:
|
|
rc_push_num( rc_intern_dirCreate( MAKEDIR_P$ ) );
|
|
break;
|
|
case FN_RemoveDir:
|
|
rc_push_num( rc_intern_dirDelete( REMOVEDIR_P$ ) );
|
|
break;
|
|
case FN_Date$:
|
|
rc_push_str( rc_intern_date() );
|
|
break;
|
|
case FN_Easter$:
|
|
rc_push_str( rc_intern_easter(EASTER$_YEAR) );
|
|
break;
|
|
case FN_Ticks:
|
|
rc_push_num( rc_intern_ticks() );
|
|
break;
|
|
case FN_Time$:
|
|
rc_push_str( rc_intern_time() );
|
|
break;
|
|
case FN_Timer:
|
|
rc_push_num( rc_intern_timer() );
|
|
break;
|
|
case FN_Wait:
|
|
rc_intern_wait( WAIT_M_SEC );
|
|
break;
|
|
case FN_WindowOpen: //Sub Procedure
|
|
rc_media_openWindow_hw( WINDOWOPEN_WIN, WINDOWOPEN_TITLE$, WINDOWOPEN_X, WINDOWOPEN_Y, WINDOWOPEN_W, WINDOWOPEN_H, WINDOWOPEN_FLAG, WINDOWOPEN_VSYNC);
|
|
break;
|
|
case FN_WindowClose: //Sub Procedure
|
|
rc_media_closeWindow_hw( WINDOWCLOSE_WIN );
|
|
break;
|
|
case FN_RaiseWindow: //Sub Procedure
|
|
rc_media_raiseWindow( RAISEWINDOW_WIN );
|
|
break;
|
|
case FN_Window: //Sub Procedure
|
|
rc_media_setActiveWindow( WINDOW_WIN );
|
|
break;
|
|
case FN_Update: //Sub Procedure
|
|
//cout << "update call" << endl;
|
|
rc_events();
|
|
rc_media_updateWindow_hw();
|
|
#ifdef RC_WEB
|
|
emscripten_sleep(0);
|
|
#else
|
|
SDL_Delay(0);
|
|
#endif // RC_WEB
|
|
break;
|
|
case FN_Cls: //Sub Procedure
|
|
rc_media_cls();
|
|
break;
|
|
case FN_SetClearColor:
|
|
rc_media_setClearColor( SETCLEARCOLOR_C );
|
|
break;
|
|
case FN_ShowWindow: //Sub Procedure
|
|
rc_media_showWindow( SHOWWINDOW_WIN );
|
|
break;
|
|
case FN_HideWindow: //Sub Procedure
|
|
rc_media_hideWindow( HIDEWINDOW_WIN );
|
|
break;
|
|
case FN_SetWindowTitle: //Sub Procedure
|
|
rc_media_setWindowTitle( SETWINDOWTITLE_WIN, SETWINDOWTITLE_TITLE$ );
|
|
break;
|
|
case FN_WindowTitle$: //String Function
|
|
rc_push_str( rc_media_getWindowTitle( WINDOWTITLE$_WIN ));
|
|
break;
|
|
case FN_SetWindowPosition: //Sub Procedure
|
|
rc_media_setWindowPosition( SETWINDOWPOSITION_WIN, SETWINDOWPOSITION_X, SETWINDOWPOSITION_Y );
|
|
break;
|
|
case FN_GetWindowPosition: //Sub Procedure
|
|
rc_media_getWindowPosition( SETWINDOWPOSITION_WIN, &SETWINDOWPOSITION_X, &SETWINDOWPOSITION_Y );
|
|
break;
|
|
case FN_SetWindowSize: //Sub Procedure
|
|
rc_media_setWindowSize( SETWINDOWSIZE_WIN, SETWINDOWSIZE_W, SETWINDOWSIZE_H );
|
|
break;
|
|
case FN_GetWindowSize: //Sub Procedure
|
|
rc_media_getWindowSize( GETWINDOWSIZE_WIN, &GETWINDOWSIZE_W, &GETWINDOWSIZE_H);
|
|
break;
|
|
case FN_SetWindowMinSize: //Sub Procedure
|
|
rc_media_setWindowMinSize( SETWINDOWMINSIZE_WIN, SETWINDOWMINSIZE_W, SETWINDOWMINSIZE_H );
|
|
break;
|
|
case FN_GetWindowMinSize: //Sub Procedure
|
|
rc_media_getWindowMinSize( GETWINDOWMINSIZE_WIN, &GETWINDOWMINSIZE_W, &GETWINDOWMINSIZE_H );
|
|
break;
|
|
case FN_SetWindowMaxSize: //Sub Procedure
|
|
rc_media_setWindowMaxSize( SETWINDOWMAXSIZE_WIN, SETWINDOWMAXSIZE_W, SETWINDOWMAXSIZE_H );
|
|
break;
|
|
case FN_GetWindowMaxSize: //Sub Procedure
|
|
rc_media_getWindowMaxSize( GETWINDOWMAXSIZE_WIN, &GETWINDOWMAXSIZE_W, &GETWINDOWMAXSIZE_H );
|
|
break;
|
|
case FN_WindowIsFullscreen: //Number Function
|
|
rc_push_num( rc_media_windowIsFullscreen( WINDOWISFULLSCREEN_WIN ) );
|
|
break;
|
|
case FN_WindowIsVisible: //Number Function
|
|
rc_push_num( rc_media_windowIsVisible( WINDOWISVISIBLE_WIN ) );
|
|
break;
|
|
case FN_WindowIsBordered: //Number Function
|
|
rc_push_num( rc_media_windowIsBordered( WINDOWISBORDERED_WIN ) );
|
|
break;
|
|
case FN_WindowIsResizable: //Number Function
|
|
rc_push_num( rc_media_windowIsResizable( WINDOWISRESIZABLE_WIN ) );
|
|
break;
|
|
case FN_WindowIsMinimized: //Number Function
|
|
rc_push_num( rc_media_windowIsMinimized( WINDOWISMINIMIZED_WIN ) );
|
|
break;
|
|
case FN_WindowIsMaximized: //Number Function
|
|
rc_push_num( rc_media_windowIsMaximized( WINDOWISMAXIMIZED_WIN ) );
|
|
break;
|
|
case FN_WindowHasInputFocus: //Number Function
|
|
rc_push_num( rc_media_windowHasInputFocus( WINDOWHASINPUTFOCUS_WIN ) );
|
|
break;
|
|
case FN_WindowHasMouseFocus: //Number Function
|
|
rc_push_num( rc_media_windowHasMouseFocus( WINDOWHASMOUSEFOCUS_WIN ) );
|
|
break;
|
|
case FN_SetWindowFullscreen: //Sub Procedure
|
|
rc_media_setWindowFullscreen( SETWINDOWFULLSCREEN_WIN, SETWINDOWFULLSCREEN_FLAG );
|
|
rc_media_cls();
|
|
break;
|
|
case FN_MaximizeWindow: //Sub Procedure
|
|
rc_media_maximizeWindow( MAXIMIZEWINDOW_WIN );
|
|
break;
|
|
case FN_MinimizeWindow: //Sub Procedure
|
|
rc_media_minimizeWindow( MINIMIZEWINDOW_WIN );
|
|
break;
|
|
case FN_SetWindowBorder: //Sub Procedure
|
|
rc_media_setWindowBordered( SETWINDOWBORDER_WIN, SETWINDOWBORDER_FLAG );
|
|
break;
|
|
case FN_WindowClip: //Sub Procedure
|
|
rc_media_getWindowClip_hw( WINDOWCLIP_SLOT, WINDOWCLIP_X, WINDOWCLIP_Y, WINDOWCLIP_W, WINDOWCLIP_H );
|
|
break;
|
|
case FN_WindowExists: //Number Function
|
|
rc_push_num( rc_media_windowExists( WINDOWEXISTS_WIN ) );
|
|
break;
|
|
case FN_NumWindows: //Number Function
|
|
rc_push_num( rc_media_numWindows() );
|
|
break;
|
|
case FN_WindowEvent_Close: //Number Function
|
|
rc_push_num( rc_media_windowEvent_Close( WINDOWEVENT_CLOSE_WIN ) );
|
|
break;
|
|
case FN_WindowEvent_Maximize: //Number Function
|
|
rc_push_num( rc_media_windowEvent_Maximize( WINDOWEVENT_MAXIMIZE_WIN ) );
|
|
break;
|
|
case FN_WindowEvent_Minimize: //Number Function
|
|
rc_push_num( rc_media_windowEvent_Minimize( WINDOWEVENT_MINIMIZE_WIN ) );
|
|
break;
|
|
case FN_ActiveWindow:
|
|
rc_push_num(rc_active_window);
|
|
break;
|
|
case FN_SetWindowIcon:
|
|
rc_media_setWindowIcon( SETWINDOWICON_WIN, SETWINDOWICON_SLOT );
|
|
break;
|
|
case FN_FPS:
|
|
rc_push_num(rc_fps[rc_active_window]);
|
|
break;
|
|
case FN_CanvasOpen: //Sub Procedure
|
|
rc_media_openScreen_hw( CANVASOPEN_C_NUM, CANVASOPEN_W, CANVASOPEN_H, CANVASOPEN_VIEWPORT_X, CANVASOPEN_VIEWPORT_Y, CANVASOPEN_VIEWPORT_W, CANVASOPEN_VIEWPORT_H, CANVASOPEN_MODE);
|
|
break;
|
|
case FN_CanvasClose: //Sub Procedure
|
|
rc_media_closeScreen_hw( CANVASCLOSE_C_NUM );
|
|
break;
|
|
case FN_SetCanvasVisible: //Sub Procedure
|
|
rc_media_setScreenVisible( SETCANVASVISIBLE_C_NUM, SETCANVASVISIBLE_FLAG );
|
|
break;
|
|
case FN_CanvasIsVisible: //Number Function
|
|
rc_push_num( rc_media_screenIsVisible( CANVASISVISIBLE_C_NUM ) );
|
|
break;
|
|
case FN_SetCanvasViewport: //Sub Procedure
|
|
rc_media_setScreenViewport( SETCANVASVIEWPORT_CNUM, SETCANVASVIEWPORT_X, SETCANVASVIEWPORT_Y, SETCANVASVIEWPORT_W, SETCANVASVIEWPORT_H );
|
|
break;
|
|
case FN_GetCanvasViewport: //Sub Procedure
|
|
rc_media_getScreenViewport( GETCANVASVIEWPORT_C_NUM, &GETCANVASVIEWPORT_X, &GETCANVASVIEWPORT_Y, &GETCANVASVIEWPORT_W, &GETCANVASVIEWPORT_H );
|
|
break;
|
|
case FN_Canvas: //Sub Procedure
|
|
rc_media_screen_hw( CANVAS_C_NUM );
|
|
break;
|
|
case FN_SetCanvasOffset: //Sub Procedure
|
|
rc_media_screenOffset( SETCANVASOFFSET_C_NUM, SETCANVASOFFSET_X, SETCANVASOFFSET_Y );
|
|
break;
|
|
case FN_GetCanvasOffset: //Sub Procedure
|
|
rc_media_getScreenOffset( GETCANVASOFFSET_C_NUM, &GETCANVASOFFSET_X, &GETCANVASOFFSET_Y );
|
|
break;
|
|
case FN_GetCanvasSize: //Sub Procedure
|
|
rc_media_getScreenSize( GETCANVASSIZE_C_NUM, &GETCANVASSIZE_W, &GETCANVASSIZE_H );
|
|
break;
|
|
case FN_ClearCanvas: //Sub Procedure
|
|
rc_media_clearScreen_hw();
|
|
break;
|
|
case FN_SetCanvasAlpha: //Sub Procedure
|
|
rc_media_setScreenAlpha_hw( SETCANVASALPHA_C_NUM, SETCANVASALPHA_A );
|
|
break;
|
|
case FN_CanvasAlpha:
|
|
rc_push_num(rc_media_ScreenAlpha_hw(CANVASALPHA_C_NUM));
|
|
break;
|
|
case FN_SetCanvasBlendMode:
|
|
rc_push_num(rc_media_setScreenBlendMode_hw(SETCANVASBLENDMODE_C_NUM, SETCANVASBLENDMODE_BLEND_MODE));
|
|
break;
|
|
case FN_CanvasBlendMode:
|
|
rc_push_num(rc_media_screenBlendMode_hw(CANVASBLENDMODE_C_NUM));
|
|
break;
|
|
case FN_SetCanvasColorMod:
|
|
rc_push_num(rc_media_setScreenColorMod_hw(SETCANVASCOLORMOD_C_NUM, SETCANVASCOLORMOD_C));
|
|
break;
|
|
case FN_CanvasColorMod:
|
|
rc_push_num(rc_media_screenColorMod_hw(CANVASCOLORMOD_C_NUM));
|
|
break;
|
|
case FN_CopyCanvas: //Sub Procedure
|
|
rc_media_copyScreen_hw( COPYCANVAS_SRC, COPYCANVAS_X, COPYCANVAS_Y, COPYCANVAS_W, COPYCANVAS_H, COPYCANVAS_DST, COPYCANVAS_DX, COPYCANVAS_DY );
|
|
break;
|
|
case FN_CloneCanvas: //Sub Procedure
|
|
rc_media_cloneScreen_hw( CLONECANVAS_SRC, CLONECANVAS_DST );
|
|
break;
|
|
case FN_SetCanvasZ: //Sub Procedure
|
|
rc_media_setScreenZ( SETCANVASZ_C_NUM, SETCANVASZ_Z );
|
|
break;
|
|
case FN_CanvasZ:
|
|
rc_push_num( rc_media_screenZ( CANVASZ_C_NUM) );
|
|
break;
|
|
case FN_CanvasClip: //Sub Procedure
|
|
rc_media_getScreenClip2_hw( CANVASCLIP_SLOT, CANVASCLIP_X, CANVASCLIP_Y, CANVASCLIP_W, CANVASCLIP_H, CANVASCLIP_FLAG );
|
|
break;
|
|
case FN_ActiveCanvas:
|
|
rc_push_num(rc_active_screen);
|
|
break;
|
|
case FN_Box: //Sub Procedure
|
|
rc_media_box_hw( BOX_X1, BOX_Y1, BOX_X2, BOX_Y2 );
|
|
break;
|
|
case FN_BoxFill: //Sub Procedure
|
|
rc_media_boxFill_hw( BOXFILL_X1, BOXFILL_Y1, BOXFILL_X2, BOXFILL_Y2 );
|
|
break;
|
|
case FN_Circle: //Sub Procedure
|
|
rc_media_circle_hw( CIRCLE_X, CIRCLE_Y, CIRCLE_RADIUS );
|
|
break;
|
|
case FN_CircleFill: //Sub Procedure
|
|
rc_media_circleFill_hw( CIRCLEFILL_X, CIRCLEFILL_Y, CIRCLEFILL_RADIUS );
|
|
break;
|
|
case FN_Ellipse: //Sub Procedure
|
|
rc_media_ellipse_hw( ELLIPSE_X, ELLIPSE_Y, ELLIPSE_RX, ELLIPSE_RY );
|
|
break;
|
|
case FN_EllipseFill: //Sub Procedure
|
|
rc_media_ellipseFill_hw( ELLIPSEFILL_X, ELLIPSEFILL_Y, ELLIPSEFILL_RX, ELLIPSEFILL_RY );
|
|
break;
|
|
case FN_FloodFill: //Sub Procedure
|
|
//cout << "FLOOD_X = " << FLOODFILL_X << endl;
|
|
rc_media_floodFill_hw( FLOODFILL_X, FLOODFILL_Y );
|
|
break;
|
|
case FN_GetPixel: //Number Function
|
|
rc_push_num( rc_media_getPixel_hw( GETPIXEL_X, GETPIXEL_Y ) );
|
|
break;
|
|
case FN_SetColor: //Sub Procedure
|
|
rc_media_ink( SETCOLOR_C );
|
|
break;
|
|
case FN_Line: //Sub Procedure
|
|
rc_media_line_hw( LINE_X1, LINE_Y1, LINE_X2, LINE_Y2 );
|
|
break;
|
|
case FN_Poly: //Sub Procedure
|
|
rc_media_poly( POLY_N, &POLY_X, &POLY_Y );
|
|
break;
|
|
case FN_PolyFill: //Sub Procedure
|
|
rc_media_polyfill( POLYFILL_N, &POLYFILL_X, &POLYFILL_Y );
|
|
break;
|
|
case FN_Rect: //Sub Procedure
|
|
rc_media_rectangle( RECT_X, RECT_Y, RECT_W, RECT_H );
|
|
break;
|
|
case FN_RectFill: //Sub Procedure
|
|
rc_media_rectangleFill( RECTFILL_X, RECTFILL_Y, RECTFILL_W, RECTFILL_H );
|
|
break;
|
|
case FN_RoundRect: //Sub Procedure
|
|
rc_media_roundRect( ROUNDRECT_X, ROUNDRECT_Y, ROUNDRECT_W, ROUNDRECT_H, ROUNDRECT_R);
|
|
break;
|
|
case FN_RoundRectFill: //Sub Procedure
|
|
rc_media_roundRectFill( ROUNDRECTFILL_X, ROUNDRECTFILL_Y, ROUNDRECTFILL_W, ROUNDRECTFILL_H, ROUNDRECTFILL_R );
|
|
break;
|
|
case FN_RGB: //Sub Procedure
|
|
rc_push_num( rc_media_rgb( RGB_R, RGB_G, RGB_B ) );
|
|
break;
|
|
case FN_RGBA: //Sub Procedure
|
|
rc_push_num( rc_media_rgba( RGBA_R, RGBA_G, RGBA_B, RGBA_A ) );
|
|
break;
|
|
case FN_PSet: //Sub Procedure
|
|
rc_media_drawPixel_hw( PSET_X, PSET_Y );
|
|
break;
|
|
case FN_LoadImage: //Sub Procedure
|
|
rc_media_loadImage_hw( LOADIMAGE_SLOT, LOADIMAGE_IMG$ );
|
|
break;
|
|
case FN_LoadImage_Ex: //Sub Procedure
|
|
rc_media_loadImage_ex_hw( LOADIMAGE_EX_SLOT, LOADIMAGE_EX_IMG$, LOADIMAGE_EX_COLKEY );
|
|
break;
|
|
case FN_ImageFromBuffer: //Sub Procedure
|
|
rc_media_createImage_hw( IMAGEFROMBUFFER_SLOT, IMAGEFROMBUFFER_W, IMAGEFROMBUFFER_H, &IMAGEFROMBUFFER_BUFFER );
|
|
break;
|
|
case FN_ImageFromBuffer_Ex: //Sub Procedure
|
|
rc_media_createImage_Ex_hw( IMAGEFROMBUFFER_EX_SLOT, IMAGEFROMBUFFER_EX_W, IMAGEFROMBUFFER_EX_H, &IMAGEFROMBUFFER_EX_BUFFER, IMAGEFROMBUFFER_EX_COLKEY );
|
|
break;
|
|
case FN_BufferFromImage:
|
|
rc_media_bufferFromImage(BUFFERFROMIMAGE_SLOT, &BUFFERFROMIMAGE_BUFFER);
|
|
break;
|
|
case FN_ImageExists: //Number Function
|
|
rc_push_num( rc_media_imageExist_hw( IMAGEEXISTS_SLOT ) );
|
|
break;
|
|
case FN_ColorKey: //Sub Procedure
|
|
rc_media_colorKey_hw( COLORKEY_SLOT, COLORKEY_C );
|
|
break;
|
|
case FN_CopyImage: //Sub Procedure
|
|
rc_media_copyImage_hw( COPYIMAGE_SRC, COPYIMAGE_DST );
|
|
break;
|
|
case FN_DeleteImage: //Sub Procedure
|
|
rc_media_deleteImage_hw( DELETEIMAGE_SLOT );
|
|
break;
|
|
case FN_SetImageAlpha: //Sub Procedure
|
|
rc_media_setImageAlpha_hw( SETIMAGEALPHA_SLOT, SETIMAGEALPHA_A );
|
|
break;
|
|
case FN_ImageAlpha: //Number Function
|
|
rc_push_num( rc_media_getImageAlpha_hw( IMAGEALPHA_SLOT ) );
|
|
break;
|
|
case FN_GetImageSize: //Sub Procedure
|
|
rc_media_getImageSize_hw( GETIMAGESIZE_SLOT, &GETIMAGESIZE_W, &GETIMAGESIZE_H );
|
|
break;
|
|
case FN_SetImageBlendMode:
|
|
rc_push_num(rc_media_setImageBlendMode_hw(SETIMAGEBLENDMODE_SLOT, SETIMAGEBLENDMODE_BLEND_MODE));
|
|
break;
|
|
case FN_ImageBlendMode:
|
|
rc_push_num(rc_media_imageBlendMode_hw(IMAGEBLENDMODE_SLOT));
|
|
break;
|
|
case FN_SetImageColorMod:
|
|
rc_push_num(rc_media_setImageColorMod_hw(SETIMAGECOLORMOD_SLOT, SETIMAGECOLORMOD_C));
|
|
break;
|
|
case FN_ImageColorMod:
|
|
rc_push_num(rc_media_imageColorMod_hw(IMAGECOLORMOD_SLOT));
|
|
break;
|
|
case FN_DrawImage: //Sub Procedure
|
|
rc_media_drawImage_hw( DRAWIMAGE_SLOT, DRAWIMAGE_X, DRAWIMAGE_Y );
|
|
break;
|
|
case FN_DrawImage_Blit: //Sub Procedure
|
|
rc_media_drawImage_Clip_hw( DRAWIMAGE_BLIT_SLOT, DRAWIMAGE_BLIT_X, DRAWIMAGE_BLIT_Y, DRAWIMAGE_BLIT_SRC_X, DRAWIMAGE_BLIT_SRC_Y, DRAWIMAGE_BLIT_SRC_W, DRAWIMAGE_BLIT_SRC_H );
|
|
break;
|
|
case FN_DrawImage_Blit_Ex: //Sub Procedure
|
|
rc_media_drawImage_Blit_hw( DRAWIMAGE_BLIT_EX_SLOT, DRAWIMAGE_BLIT_EX_X, DRAWIMAGE_BLIT_EX_Y, DRAWIMAGE_BLIT_EX_W, DRAWIMAGE_BLIT_EX_H,
|
|
DRAWIMAGE_BLIT_EX_SRC_X, DRAWIMAGE_BLIT_EX_SRC_Y, DRAWIMAGE_BLIT_EX_SRC_W, DRAWIMAGE_BLIT_EX_SRC_H );
|
|
break;
|
|
case FN_DrawImage_Rotate: //Sub Procedure
|
|
rc_media_rotateImage_hw( DRAWIMAGE_ROTATE_SLOT, DRAWIMAGE_ROTATE_X, DRAWIMAGE_ROTATE_Y, DRAWIMAGE_ROTATE_ANGLE );
|
|
break;
|
|
case FN_DrawImage_Rotate_Ex: //Sub Procedure
|
|
rc_media_rotateImageEX_hw( DRAWIMAGE_ROTATE_EX_SLOT, DRAWIMAGE_ROTATE_EX_X, DRAWIMAGE_ROTATE_EX_Y, DRAWIMAGE_ROTATE_EX_SRC_X, DRAWIMAGE_ROTATE_EX_SRC_Y,
|
|
DRAWIMAGE_ROTATE_EX_SRC_W, DRAWIMAGE_ROTATE_EX_SRC_H, DRAWIMAGE_ROTATE_EX_ANGLE );
|
|
break;
|
|
case FN_DrawImage_Zoom: //Sub Procedure
|
|
rc_media_zoomImage_hw( DRAWIMAGE_ZOOM_SLOT, DRAWIMAGE_ZOOM_X, DRAWIMAGE_ZOOM_Y, DRAWIMAGE_ZOOM_ZX, DRAWIMAGE_ZOOM_ZY );
|
|
break;
|
|
case FN_DrawImage_Zoom_Ex: //Sub Procedure
|
|
rc_media_zoomImageEX_hw( DRAWIMAGE_ZOOM_EX_SLOT, DRAWIMAGE_ZOOM_EX_X, DRAWIMAGE_ZOOM_EX_Y, DRAWIMAGE_ZOOM_EX_SRC_X, DRAWIMAGE_ZOOM_EX_SRC_Y,
|
|
DRAWIMAGE_ZOOM_EX_SRC_W, DRAWIMAGE_ZOOM_EX_SRC_H, DRAWIMAGE_ZOOM_EX_ZX, DRAWIMAGE_ZOOM_EX_ZY );
|
|
break;
|
|
case FN_DrawImage_Rotozoom: //Sub Procedure
|
|
rc_media_rotozoomImage_hw( DRAWIMAGE_ROTOZOOM_SLOT, DRAWIMAGE_ROTOZOOM_X, DRAWIMAGE_ROTOZOOM_Y, DRAWIMAGE_ROTOZOOM_ANGLE,
|
|
DRAWIMAGE_ROTOZOOM_ZX, DRAWIMAGE_ROTOZOOM_ZY );
|
|
break;
|
|
case FN_DrawImage_Rotozoom_Ex: //Sub Procedure
|
|
rc_media_rotozoomImageEX_hw( DRAWIMAGE_ROTOZOOM_EX_SLOT, DRAWIMAGE_ROTOZOOM_EX_X, DRAWIMAGE_ROTOZOOM_EX_Y, DRAWIMAGE_ROTOZOOM_EX_SRC_X, DRAWIMAGE_ROTOZOOM_EX_SRC_Y,
|
|
DRAWIMAGE_ROTOZOOM_EX_SRC_W, DRAWIMAGE_ROTOZOOM_EX_SRC_H, DRAWIMAGE_ROTOZOOM_EX_ANGLE, DRAWIMAGE_ROTOZOOM_EX_ZX, DRAWIMAGE_ROTOZOOM_EX_ZY );
|
|
break;
|
|
case FN_DrawImage_Flip:
|
|
rc_media_drawImage_Flip( DRAWIMAGE_FLIP_SLOT, DRAWIMAGE_FLIP_X, DRAWIMAGE_FLIP_Y, DRAWIMAGE_FLIP_H, DRAWIMAGE_FLIP_V );
|
|
break;
|
|
case FN_DrawImage_Flip_Ex:
|
|
rc_media_drawImage_Flip_Ex(DRAWIMAGE_FLIP_EX_SLOT, DRAWIMAGE_FLIP_EX_X, DRAWIMAGE_FLIP_EX_Y, DRAWIMAGE_FLIP_EX_SRC_X, DRAWIMAGE_FLIP_EX_SRC_Y, DRAWIMAGE_FLIP_EX_SRC_W,
|
|
DRAWIMAGE_FLIP_EX_SRC_H, DRAWIMAGE_FLIP_EX_H, DRAWIMAGE_FLIP_EX_V);
|
|
break;
|
|
case FN_InKey: //Number Function
|
|
rc_push_num( rc_media_inkey() );
|
|
break;
|
|
case FN_Key: //Number Function
|
|
rc_push_num( rc_media_key( KEY_KEY_CODE ) );
|
|
break;
|
|
case FN_WaitKey: //Number Function
|
|
rc_push_num( rc_media_waitKey() );
|
|
break;
|
|
case FN_HideMouse: //Sub Procedure
|
|
rc_media_hideMouse();
|
|
break;
|
|
case FN_ShowMouse: //Sub Procedure
|
|
rc_media_showMouse();
|
|
break;
|
|
case FN_MouseIsVisible: //Number Function
|
|
rc_push_num( rc_media_mouseIsVisible() );
|
|
break;
|
|
case FN_GetMouse: //Sub Procedure
|
|
rc_media_getMouse( &GETMOUSE_X, &GETMOUSE_Y, &GETMOUSE_MB1, &GETMOUSE_MB2, &GETMOUSE_MB3 );
|
|
break;
|
|
case FN_MouseX: //Number Function
|
|
rc_push_num( rc_media_mouseX() );
|
|
break;
|
|
case FN_MouseY: //Number Function
|
|
rc_push_num( rc_media_mouseY() );
|
|
break;
|
|
case FN_MouseButton: //Number Function
|
|
rc_push_num( rc_media_mouseButton( MOUSEBUTTON_MB ) );
|
|
break;
|
|
case FN_GetMouseWheel: //Sub Procedure
|
|
rc_media_getMouseWheel( &GETMOUSEWHEEL_X_AXIS, &GETMOUSEWHEEL_Y_AXIS );
|
|
break;
|
|
case FN_MouseWheelX: //Number Function
|
|
rc_push_num( rc_media_mouseWheelX() );
|
|
break;
|
|
case FN_MouseWheelY: //Number Function
|
|
rc_push_num( rc_media_mouseWheelY() );
|
|
break;
|
|
case FN_SoundFromBuffer: //Sub Procedure
|
|
rc_media_createSound( SOUNDFROMBUFFER_SLOT, &SOUNDFROMBUFFER_BUFFER, SOUNDFROMBUFFER_BUFFER_SIZE, SOUNDFROMBUFFER_VOL );
|
|
break;
|
|
case FN_LoadSound: //Sub Procedure
|
|
rc_media_loadSound( LOADSOUND_SLOT, LOADSOUND_SND_FILE$ );
|
|
break;
|
|
case FN_LoadMusic: //Sub Procedure
|
|
rc_media_loadMusic( LOADMUSIC_MUSIC_FILE$ );
|
|
break;
|
|
case FN_PlaySound: //Sub Procedure
|
|
rc_media_playSound( PLAYSOUND_SLOT, PLAYSOUND_CHANNEL, PLAYSOUND_LOOPS );
|
|
break;
|
|
case FN_PlaySoundTimed: //Sub Procedure
|
|
rc_media_playSoundTimed( PLAYSOUNDTIMED_SLOT, PLAYSOUNDTIMED_CHANNEL, PLAYSOUNDTIMED_LOOPS, PLAYSOUNDTIMED_MS );
|
|
break;
|
|
case FN_PlayMusic: //Sub Procedure
|
|
rc_media_playMusic( PLAYMUSIC_MLOOPS );
|
|
break;
|
|
case FN_PauseSound: //Sub Procedure
|
|
rc_media_pauseSound( PAUSESOUND_CHANNEL );
|
|
break;
|
|
case FN_ResumeSound: //Sub Procedure
|
|
rc_media_resumeSound( RESUMESOUND_CHANNEL );
|
|
break;
|
|
case FN_PauseMusic: //Sub Procedure
|
|
rc_media_pauseMusic();
|
|
break;
|
|
case FN_ResumeMusic: //Sub Procedure
|
|
rc_media_resumeMusic();
|
|
break;
|
|
case FN_DeleteSound: //Sub Procedure
|
|
rc_media_deleteSound( DELETESOUND_SLOT );
|
|
break;
|
|
case FN_DeleteMusic: //Sub Procedure
|
|
rc_media_deleteMusic();
|
|
break;
|
|
case FN_FadeMusicIn: //Sub Procedure
|
|
rc_media_fadeMusicIn( FADEMUSICIN_FADE_TIME, FADEMUSICIN_LOOPS );
|
|
break;
|
|
case FN_FadeMusicOut: //Sub Procedure
|
|
rc_media_fadeMusicOut( FADEMUSICOUT_FADE_TIME );
|
|
break;
|
|
case FN_MusicExists: //Number Function
|
|
rc_push_num( rc_media_musicExists() );
|
|
break;
|
|
case FN_SetMusicVolume: //Sub Procedure
|
|
rc_media_setMusicVolume( SETMUSICVOLUME_VOL );
|
|
break;
|
|
case FN_MusicVolume: //Number Function
|
|
rc_push_num( rc_media_getMusicVolume() );
|
|
break;
|
|
case FN_SetMusicPosition: //Sub Procedure
|
|
rc_media_setMusicPosition( SETMUSICPOSITION_POS );
|
|
break;
|
|
case FN_MusicPosition: //Number Function
|
|
rc_push_num( rc_media_getMusicPosition() );
|
|
break;
|
|
case FN_RewindMusic: //Sub Procedure
|
|
rc_media_rewindMusic();
|
|
break;
|
|
case FN_SetSoundChannels: //Sub Procedure
|
|
rc_media_setSoundChannels( SETSOUNDCHANNELS_MAX_CHANNELS );
|
|
break;
|
|
case FN_NumSoundChannels: //Number Function
|
|
rc_push_num( rc_media_getSoundChannels() );
|
|
break;
|
|
case FN_SoundIsEnabled: //Number Function
|
|
rc_push_num( rc_media_soundIsEnabled() );
|
|
break;
|
|
case FN_SoundExists: //Number Function
|
|
rc_push_num( rc_media_soundExists( SOUNDEXISTS_SLOT ) );
|
|
break;
|
|
case FN_SetChannelVolume: //Sub Procedure
|
|
rc_media_setChannelVolume( SETCHANNELVOLUME_CHANNEL, SETCHANNELVOLUME_VOL );
|
|
break;
|
|
case FN_ChannelVolume: //Number Function
|
|
rc_push_num( rc_media_getChannelVolume( CHANNELVOLUME_CHANNEL ) );
|
|
break;
|
|
case FN_SetSoundVolume: //Sub Procedure
|
|
rc_media_setSoundVolume( SETSOUNDVOLUME_SLOT, SETSOUNDVOLUME_VOL );
|
|
break;
|
|
case FN_SoundVolume: //Number Function
|
|
rc_push_num( rc_media_getSoundVolume( SOUNDVOLUME_SLOT ) );
|
|
break;
|
|
case FN_StopMusic: //Sub Procedure
|
|
rc_media_stopMusic();
|
|
break;
|
|
case FN_StopSound: //Sub Procedure
|
|
rc_media_stopSound( STOPSOUND_CHANNEL );
|
|
break;
|
|
case FN_ChannelIsPlaying:
|
|
rc_push_num( rc_media_channelIsPlaying( CHANNELISPLAYING_CHANNEL ));
|
|
break;
|
|
case FN_ChannelIsPaused:
|
|
rc_push_num( rc_media_channelIsPaused( CHANNELISPAUSED_CHANNEL ));
|
|
break;
|
|
case FN_SetChannelDistance:
|
|
rc_push_num( rc_media_setChannelDistance( SETCHANNELDISTANCE_CHANNEL, SETCHANNELDISTANCE_DIST_VALUE ) );
|
|
break;
|
|
case FN_SetChannelPanning:
|
|
rc_push_num( rc_media_setChannelPanning( SETCHANNELPANNING_CHANNEL, SETCHANNELPANNING_LEFT_VALUE, SETCHANNELPANNING_RIGHT_VALUE ) );
|
|
break;
|
|
case FN_NumJoysticks: //Number Function
|
|
rc_push_num( rc_media_numJoysticks() );
|
|
break;
|
|
case FN_NumJoyAxes: //Number Function
|
|
rc_push_num( rc_media_numJoyAxes( NUMJOYAXES_JOY_NUM ) );
|
|
break;
|
|
case FN_NumJoyButtons: //Number Function
|
|
rc_push_num( rc_media_numJoyButtons( NUMJOYBUTTONS_JOY_NUM ) );
|
|
break;
|
|
case FN_NumJoyHats: //Number Function
|
|
rc_push_num( rc_media_numJoyHats( NUMJOYHATS_JOY_NUM ) );
|
|
break;
|
|
case FN_NumJoyTrackBalls: //Number Function
|
|
rc_push_num( rc_media_numJoyTrackBalls( NUMJOYTRACKBALLS_JOY_NUM ) );
|
|
break;
|
|
case FN_JoyAxis: //Number Function
|
|
rc_push_num( rc_media_joyAxis( JOYAXIS_JOY_NUM, JOYAXIS_JOY_AXIS ) );
|
|
break;
|
|
case FN_JoyButton: //Number Function
|
|
rc_push_num( rc_media_joyButton( JOYBUTTON_JOY_NUM, JOYBUTTON_JOY_BUTTON ) );
|
|
break;
|
|
case FN_JoyHat: //Number Function
|
|
rc_push_num( rc_media_joyHat( JOYHAT_JOY_NUM, JOYHAT_JOY_HAT ) );
|
|
break;
|
|
case FN_GetJoyTrackBall: //Sub Procedure
|
|
rc_media_getJoyTrackBall( GETJOYTRACKBALL_JOY_NUM, GETJOYTRACKBALL_BALL, &GETJOYTRACKBALL_DX, &GETJOYTRACKBALL_DY );
|
|
break;
|
|
case FN_JoyName$: //String Function
|
|
rc_push_str( rc_media_joystickName( JOYNAME$_JOY_NUM ) );
|
|
break;
|
|
case FN_JoystickIsConnected: //Number Function
|
|
rc_push_num( rc_media_joystickIsConnected( JOYSTICKISCONNECTED_JOY_NUM ) );
|
|
break;
|
|
case FN_GetCursor: //Sub Procedure
|
|
rc_media_getCursor( &GETCURSOR_X, &GETCURSOR_Y );
|
|
break;
|
|
case FN_PrintS: //Sub Procedure
|
|
rc_media_printS_hw( PRINTS_TXT$ );
|
|
break;
|
|
case FN_InputS$: //String Function
|
|
rc_push_str( rc_media_inputS_hw( INPUTS$_PROMPT$ ) );
|
|
break;
|
|
case FN_ZoneInputS$: //String Function
|
|
rc_push_str( rc_media_ZoneInputS_hw( ZONEINPUTS$_X, ZONEINPUTS$_Y, ZONEINPUTS$_W, ZONEINPUTS$_H ) );
|
|
break;
|
|
case FN_Locate: //Sub Procedure
|
|
rc_media_locate( LOCATE_X, LOCATE_Y );
|
|
break;
|
|
case FN_ReadInput_Start: //Sub Procedure
|
|
rc_media_ReadInput_Start();
|
|
break;
|
|
case FN_ReadInput_Stop: //Sub Procedure
|
|
rc_media_ReadInput_Stop();
|
|
break;
|
|
case FN_ReadInput_Text$: //String Function
|
|
rc_push_str( rc_media_ReadInput_Text() );
|
|
break;
|
|
case FN_ReadInput_SetText: //Sub Procedure
|
|
rc_media_ReadInput_SetText( READINPUT_SETTEXT_TXT$ );
|
|
break;
|
|
case FN_ReadInput_ToggleBackspace: //Sub Procedure
|
|
rc_media_ReadInput_ToggleBackspace( READINPUT_TOGGLEBACKSPACE_FLAG );
|
|
break;
|
|
case FN_LoadFont: //Sub Procedure
|
|
rc_media_LoadFont( LOADFONT_SLOT, LOADFONT_FNT_FILE$, LOADFONT_SIZE );
|
|
break;
|
|
case FN_DeleteFont: //Sub Procedure
|
|
rc_media_DeleteFont( DELETEFONT_SLOT );
|
|
break;
|
|
case FN_FontIsLoaded: //Number Function
|
|
rc_push_num( rc_media_fontIsLoaded( FONTISLOADED_SLOT ) );
|
|
break;
|
|
case FN_Font: //Sub Procedure
|
|
rc_media_font( FONT_SLOT );
|
|
break;
|
|
case FN_SetFontStyle: //Sub Procedure
|
|
rc_media_setFontStyle( SETFONTSTYLE_SLOT, SETFONTSTYLE_STYLE );
|
|
break;
|
|
case FN_DrawText: //Sub Procedure
|
|
rc_media_drawText_hw( DRAWTEXT_TXT$, DRAWTEXT_X, DRAWTEXT_Y );
|
|
break;
|
|
case FN_DrawText_Shaded: //Sub Procedure
|
|
rc_media_drawText_shaded_hw( DRAWTEXT_SHADED_TXT$, DRAWTEXT_SHADED_X, DRAWTEXT_SHADED_Y, DRAWTEXT_SHADED_FG_COLOR, DRAWTEXT_SHADED_BG_COLOR );
|
|
break;
|
|
case FN_DrawText_Blended: //Sub Procedure
|
|
rc_media_drawText_blended_hw( DRAWTEXT_BLENDED_TXT$, DRAWTEXT_BLENDED_X, DRAWTEXT_BLENDED_Y );
|
|
break;
|
|
case FN_RenderText: //Sub Procedure
|
|
rc_media_GetRenderedText_hw( RENDERTEXT_SLOT, RENDERTEXT_TXT$ );
|
|
break;
|
|
case FN_GetTextSize: //Sub Procedure
|
|
rc_media_getTextSize( GETTEXTSIZE_SLOT, GETTEXTSIZE_TXT$, &GETTEXTSIZE_W, &GETTEXTSIZE_H );
|
|
break;
|
|
case FN_TouchPressure: //Number Function
|
|
rc_push_num( rc_media_touchPressure() );
|
|
break;
|
|
case FN_GetTouch: //Sub Procedure
|
|
rc_media_getTouch( &GETTOUCH_STATUS, &GETTOUCH_X, &GETTOUCH_Y, &GETTOUCH_DX, &GETTOUCH_DY );
|
|
break;
|
|
case FN_GetMultiTouch: //Sub Procedure
|
|
rc_media_getMultiTouch( &GETMULTITOUCH_STATUS, &GETMULTITOUCH_X, &GETMULTITOUCH_Y, &GETMULTITOUCH_FINGERS, &GETMULTITOUCH_DIST, &GETMULTITOUCH_THETA );
|
|
break;
|
|
case FN_GetTouchFinger: //Sub Procedure
|
|
rc_media_getTouchFinger( GETTOUCHFINGER_FINGER, &GETTOUCHFINGER_X, &GETTOUCHFINGER_Y, &GETTOUCHFINGER_PRESSURE );
|
|
break;
|
|
case FN_NumFingers: //Number Function
|
|
rc_push_num( rc_media_numFingers() );
|
|
break;
|
|
case FN_CheckSockets:
|
|
rc_push_num( rc_net_checkSockets( CHECKSOCKETS_TIMEOUT_MS ) );
|
|
break;
|
|
case FN_TCP_SocketReady:
|
|
rc_push_num( rc_net_tcp_socketReady( TCP_SOCKETREADY_SOCKET ) );
|
|
break;
|
|
case FN_UDP_SocketReady:
|
|
rc_push_num( rc_net_udp_socketReady( UDP_SOCKETREADY_SOCKET ) );
|
|
break;
|
|
case FN_TCP_SocketOpen: //Number Function
|
|
rc_push_num( rc_net_tcp_openSocket(TCP_SOCKETOPEN_SOCKET, TCP_SOCKETOPEN_HOST$, TCP_SOCKETOPEN_PORT ) );
|
|
break;
|
|
case FN_TCP_SocketClose: //Sub Procedure
|
|
rc_net_tcp_closeSocket( TCP_SOCKETCLOSE_SOCKET );
|
|
break;
|
|
case FN_TCP_RemoteHost: //Number Function
|
|
rc_push_num( rc_net_tcp_remoteHost( TCP_REMOTEHOST_SOCKET ) );
|
|
break;
|
|
case FN_TCP_RemotePort: //Number Function
|
|
rc_push_num( rc_net_tcp_remotePort( TCP_REMOTEPORT_SOCKET ) );
|
|
break;
|
|
case FN_TCP_GetData: //Number Function
|
|
rc_push_num( rc_net_tcp_getData_str( TCP_GETDATA_SOCKET, &TCP_GETDATA_SDATA$, TCP_GETDATA_NUMBYTES ) );
|
|
break;
|
|
case FN_TCP_SendData: //Sub Procedure
|
|
rc_net_tcp_sendData( TCP_SENDDATA_SOCKET, TCP_SENDDATA_SDATA$.c_str(), TCP_SENDDATA_SDATA$.length() );
|
|
break;
|
|
case FN_TCP_AcceptSocket: //Number Function
|
|
rc_push_num( rc_net_tcp_acceptSocket( TCP_ACCEPTSOCKET_SERVER, TCP_ACCEPTSOCKET_CLIENT ) );
|
|
break;
|
|
case FN_UDP_SocketOpen: //Number Function
|
|
rc_push_num( rc_net_udp_openSocket( UDP_SOCKETOPEN_SOCKET, UDP_SOCKETOPEN_PORT ) );
|
|
break;
|
|
case FN_UDP_SocketClose: //Sub Procedure
|
|
rc_push_num(rc_net_udp_closeSocket( UDP_SOCKETCLOSE_SOCKET ));
|
|
break;
|
|
case FN_UDP_GetData: //Number Function
|
|
rc_push_num( rc_net_udp_readStream( UDP_GETDATA_SOCKET, &UDP_GETDATA_SDATA$, &UDP_GETDATA_HOST$, &UDP_GETDATA_PORT ) );
|
|
break;
|
|
case FN_UDP_Length: //Number Function
|
|
rc_push_num( rc_net_udp_len());
|
|
break;
|
|
case FN_UDP_MaxLength: //Number Function
|
|
rc_push_num( rc_net_udp_maxlen() );
|
|
break;
|
|
case FN_UDP_RemoteHost$: //String Function
|
|
rc_push_str( rc_net_udp_getRemoteHost( UDP_REMOTEHOST$_SOCKET ) );
|
|
break;
|
|
case FN_UDP_RemotePort: //Number Function
|
|
rc_push_num( rc_net_udp_getRemotePort( UDP_REMOTEPORT_SOCKET ) );
|
|
break;
|
|
case FN_UDP_SendData: //Sub Procedure
|
|
rc_net_udp_sendData( UDP_SENDDATA_SOCKET, UDP_SENDDATA_HOST$, UDP_SENDDATA_PORT, UDP_SENDDATA_SDATA$ );
|
|
break;
|
|
case FN_LoadVideo: //Sub Procedure
|
|
rc_media_loadVideo( LOADVIDEO_VID$ );
|
|
break;
|
|
case FN_PlayVideo: //Sub Procedure
|
|
rc_media_playVideo( PLAYVIDEO_VLOOPS );
|
|
break;
|
|
case FN_PauseVideo: //Sub Procedure
|
|
rc_media_pauseVideo();
|
|
break;
|
|
case FN_StopVideo: //Sub Procedure
|
|
rc_media_stopVideo();
|
|
break;
|
|
case FN_SetVideoPosition: //Sub Procedure
|
|
rc_media_setVideoPosition( SETVIDEOPOSITION_POS );
|
|
break;
|
|
case FN_ResumeVideo: //Sub Procedure
|
|
rc_media_resumeVideo();
|
|
break;
|
|
case FN_VideoPosition: //Number Function
|
|
rc_push_num( rc_media_videoPosition() );
|
|
break;
|
|
case FN_DeleteVideo: //Sub Procedure
|
|
rc_media_deleteVideo();
|
|
break;
|
|
case FN_VideoIsPlaying: //Number Function
|
|
rc_push_num( rc_media_videoIsPlaying() );
|
|
break;
|
|
case FN_VideoEnd: //Number Function
|
|
rc_push_num( rc_media_videoEnd() );
|
|
break;
|
|
case FN_GetVideoStats: //Sub Procedure
|
|
rc_media_getVideoStats( GETVIDEOSTATS_VFILE$, &GETVIDEOSTATS_VLEN, &GETVIDEOSTATS_VFPS, &GETVIDEOSTATS_FRAME_W, &GETVIDEOSTATS_FRAME_H );
|
|
break;
|
|
case FN_SetVideoDrawRect: //Sub Procedure
|
|
rc_media_setVideoDrawRect( SETVIDEODRAWRECT_X, SETVIDEODRAWRECT_Y, SETVIDEODRAWRECT_W, SETVIDEODRAWRECT_H );
|
|
break;
|
|
case FN_GetVideoDrawRect: //Sub Procedure
|
|
rc_media_getVideoDrawRect( &GETVIDEODRAWRECT_X, &GETVIDEODRAWRECT_Y, &GETVIDEODRAWRECT_W, &GETVIDEODRAWRECT_H );
|
|
break;
|
|
case FN_GetVideoSize: //Sub Procedure
|
|
rc_media_getVideoSize( &GETVIDEOSIZE_W, &GETVIDEOSIZE_H );
|
|
break;
|
|
case FN_VideoExists: //Number Function
|
|
rc_push_num( rc_media_videoExists() );
|
|
break;
|
|
case FN_SetVideoAlpha: //Sub Procedure
|
|
rc_media_setVideoAlpha( SETVIDEOALPHA_A );
|
|
break;
|
|
case FN_System: //Number Function
|
|
rc_push_num( rc_intern_system( SYSTEM_CMD$ ) );
|
|
break;
|
|
case FN_OS$: //String Function
|
|
rc_push_str( rc_intern_OS());
|
|
break;
|
|
case FN_Command$: //String Function
|
|
rc_push_str( rc_intern_command( COMMAND$_ARG ) );
|
|
break;
|
|
case FN_NumCommands: //Number Function
|
|
rc_push_num( rc_intern_numCommands() );
|
|
break;
|
|
case FN_Env$: //String Function
|
|
rc_push_str( rc_intern_env( ENV$_V$ ) );
|
|
break;
|
|
case FN_SetEnv: //Sub Procedure
|
|
rc_intern_setEnv( SETENV_VAR$, SETENV_VALUE$, SETENV_OVERWRITE );
|
|
break;
|
|
case FN_PrefPath$: //String Function
|
|
rc_push_str( rc_intern_prefPath( PREFPATH$_ORG_NAME$, PREFPATH$_APP_NAME$ ) );
|
|
break;
|
|
case FN_ClipboardText$:
|
|
rc_push_str( rc_media_getClipboardText() );
|
|
break;
|
|
case FN_SetClipboardText:
|
|
rc_media_setClipboardText( SETCLIPBOARDTEXT_TXT$ );
|
|
break;
|
|
case FN_HasClipboardText:
|
|
rc_push_num( rc_media_hasClipboardText() );
|
|
break;
|
|
case FN_Android_GetExternalStoragePath$:
|
|
rc_push_str( rc_intern_android_getExternalStoragePath() );
|
|
break;
|
|
case FN_Android_GetExternalStorageState:
|
|
rc_push_num( rc_intern_android_getExternalStorageState() );
|
|
break;
|
|
case FN_Android_GetInternalStoragePath$:
|
|
rc_push_str( rc_intern_android_getInternalStoragePath() );
|
|
break;
|
|
case FN_Android_JNI_Message$:
|
|
rc_push_str( rc_intern_android_jni_message( ANDROID_JNI_MESSAGE$_ARG$ ));
|
|
break;
|
|
case FN_Runtime_Utility_Message$:
|
|
rc_push_str( rc_intern_runtime_utility( RUNTIME_UTILITY_MESSAGE$_ARG$ ));
|
|
break;
|
|
case FN_GetDesktopDisplayMode: //Sub Procedure
|
|
rc_media_getDesktopDisplayMode( GETDESKTOPDISPLAYMODE_INDEX, &GETDESKTOPDISPLAYMODE_W, &GETDESKTOPDISPLAYMODE_H, &GETDESKTOPDISPLAYMODE_FREQ);
|
|
break;
|
|
case FN_DrawImage_Transform: //Sub Procedure
|
|
rc_media_drawImage_Transform(DRAWIMAGE_TRANSFORM_SLOT, DRAWIMAGE_TRANSFORM_X, DRAWIMAGE_TRANSFORM_Y, DRAWIMAGE_TRANSFORM_W, DRAWIMAGE_TRANSFORM_H,
|
|
DRAWIMAGE_TRANSFORM_SRC_X, DRAWIMAGE_TRANSFORM_SRC_Y, DRAWIMAGE_TRANSFORM_W, DRAWIMAGE_TRANSFORM_H, DRAWIMAGE_TRANSFORM_ANGLE,
|
|
DRAWIMAGE_TRANSFORM_CENTER_X, DRAWIMAGE_TRANSFORM_CENTER_Y, DRAWIMAGE_TRANSFORM_FLIP_H, DRAWIMAGE_TRANSFORM_FLIP_V);
|
|
break;
|
|
case FN_GetPowerInfo: //Sub Procedure
|
|
rc_intern_getPowerInfo(&GETPOWERINFO_STATUS, &GETPOWERINFO_SECS, &GETPOWERINFO_PCT);
|
|
break;
|
|
case FN_SystemRam: //Number Function
|
|
rc_push_num( rc_intern_systemRam() );
|
|
break;
|
|
case FN_SetRenderScaleQuality: //Number Function
|
|
rc_push_num( rc_media_setRenderScaleQuality((int)SETRENDERSCALEQUALITY_N) );
|
|
break;
|
|
case FN_EvalJS$: //String Function
|
|
rc_push_str( rc_intern_evalJS( EVALJS$_JS_CODE$) );
|
|
break;
|
|
case FN_GetRenderScaleQuality: //Number Function
|
|
rc_push_num( rc_media_getRenderScaleQuality() );
|
|
break;
|
|
case FN_GetGlobalMouse: //Sub Procedure
|
|
rc_media_getGlobalMouse(&GETGLOBALMOUSE_X, &GETGLOBALMOUSE_Y, &GETGLOBALMOUSE_MB1, &GETGLOBALMOUSE_MB2, &GETGLOBALMOUSE_MB3);
|
|
break;
|
|
case FN_GlobalMouseX: //Number Function
|
|
rc_push_num( rc_media_globalMouseX() );
|
|
break;
|
|
case FN_GlobalMouseY: //Number Function
|
|
rc_push_num( rc_media_globalMouseY() );
|
|
break;
|
|
case FN_GetAccel: //Sub Procedure
|
|
rc_media_getAccel( GETACCEL_ACCEL_NUM, &GETACCEL_X, &GETACCEL_Y, &GETACCEL_Z );
|
|
break;
|
|
case FN_AccelName$: //String Function
|
|
rc_push_str( rc_media_accelName( ACCELNAME$_ACCEL_NUM ) );
|
|
break;
|
|
case FN_NumAccels: //Number Function
|
|
rc_push_num( rc_media_numAccels() );
|
|
break;
|
|
case FN_GetGyro: //Sub Procedure
|
|
rc_media_getGyro( GETGYRO_GYRO_NUM, &GETGYRO_X, &GETGYRO_Y, &GETGYRO_Z );
|
|
break;
|
|
case FN_GyroName$: //String Function
|
|
rc_push_str( rc_media_gyroName( GYRONAME$_GYRO_NUM ));
|
|
break;
|
|
case FN_NumGyros: //Number Function
|
|
rc_push_num( rc_media_numGyros() );
|
|
break;
|
|
case FN_JoyRumblePlay: //Sub Procedure
|
|
rc_media_joyRumblePlay( JOYRUMBLEPLAY_JOY_NUM, JOYRUMBLEPLAY_STRENGTH, JOYRUMBLEPLAY_DURATION );
|
|
break;
|
|
case FN_JoyRumbleStop: //Sub Procedure
|
|
rc_media_joyRumbleStop( JOYRUMBLESTOP_JOY_NUM );
|
|
break;
|
|
case FN_JoystickIsHaptic: //Number Function
|
|
rc_push_num( rc_media_joystickIsHaptic( JOYSTICKISHAPTIC_JOY_NUM ) );
|
|
break;
|
|
case FN_WriteByteBuffer: //Number Function
|
|
rc_push_num( rc_intern_fileWriteByteBuffer( WRITEBYTEBUFFER_STREAM, &WRITEBYTEBUFFER_BUF, WRITEBYTEBUFFER_BUF_SIZE ) );
|
|
break;
|
|
case FN_ReadByteBuffer: //Number Function
|
|
rc_push_num( rc_intern_fileReadByteBuffer( READBYTEBUFFER_STREAM, &READBYTEBUFFER_BUF, READBYTEBUFFER_BUF_SIZE ) );
|
|
break;
|
|
case FN_WindowEvent_Resize: //Number Function
|
|
rc_push_num( rc_media_windowEvent_Resize( WINDOWEVENT_RESIZE_WIN ) );
|
|
break;
|
|
case FN_SetWindowAutoClose: //Sub Procedure
|
|
rc_media_windowEvent_setExitOnClose( SETWINDOWAUTOCLOSE_WIN, SETWINDOWAUTOCLOSE_EXIT_ON_CLOSE );
|
|
break;
|
|
case FN_SetWindowResizable:
|
|
rc_media_setWindowResizable(SETWINDOWRESIZABLE_WIN, SETWINDOWRESIZABLE_FLAG);
|
|
break;
|
|
case FN_SystemReturnStdOut$:
|
|
rc_push_str( rc_intern_sysReturnOutput(SYSTEMRETURNSTDOUT$_CMD$) );
|
|
break;
|
|
case FN_WindowMode:
|
|
rc_push_num( rc_media_windowMode(WINDOWMODE_VISIBLE, WINDOWMODE_FULLSCREEN, WINDOWMODE_RESIZABLE, WINDOWMODE_BORDERLESS, WINDOWMODE_HIGHDPI) );
|
|
break;
|
|
case FN_WindowFlags:
|
|
rc_push_num( rc_media_windowFlags(WINDOWFLAGS_WIN) );
|
|
break;
|
|
case FN_RestoreWindow:
|
|
rc_media_restoreWindow(RESTOREWINDOW_WIN);
|
|
break;
|
|
case FN_UpdateAllWindows:
|
|
rc_events();
|
|
rc_media_updateAllWindow_hw();
|
|
#ifdef RC_WEB
|
|
emscripten_sleep(0);
|
|
#else
|
|
SDL_Delay(0);
|
|
#endif // RC_WEB
|
|
break;
|
|
case FN_QueryAudioSpec:
|
|
rc_push_num( rc_media_queryAudioSpec(&QUERYAUDIOSPEC_FREQ, &QUERYAUDIOSPEC_FORMAT, &QUERYAUDIOSPEC_CHANNELS) );
|
|
break;
|
|
case FN_MusicIsPlaying:
|
|
rc_push_num( rc_media_musicIsPlaying() );
|
|
break;
|
|
case FN_DrawGeometry: //Number Function
|
|
#ifdef RC_WEB
|
|
rc_push_num(0);
|
|
#else
|
|
rc_push_num( rc_media_drawGeometry(DRAWGEOMETRY_SLOT, DRAWGEOMETRY_NUM_VERTICES, &DRAWGEOMETRY_VERTICES, DRAWGEOMETRY_NUM_INDICES, &DRAWGEOMETRY_INDICES) );
|
|
#endif // RC_WEB
|
|
break;
|
|
case FN_Size: //Number Function
|
|
rc_push_num(rc_intern_size(SIZE_S$));
|
|
break;
|
|
case FN_BufferFromString: //Number Function
|
|
rc_push_num(rc_intern_bufferFromString(BUFFERFROMSTRING_S$, &BUFFERFROMSTRING_BUFFER));
|
|
break;
|
|
case FN_StringFromBuffer$: //String Function
|
|
rc_push_str( rc_intern_stringFromBuffer(&STRINGFROMBUFFER$_BUFFER, STRINGFROMBUFFER$_BUFFER_SIZE) );
|
|
break;
|
|
case FN_GrabInput: //Sub Procedure
|
|
rc_media_grabInput(GRABINPUT_FLAG);
|
|
break;
|
|
case FN_GrabbedWindow: //Number Function
|
|
rc_push_num( rc_media_grabbedWindow() );
|
|
break;
|
|
case FN_WarpMouse: //Sub Procedure
|
|
rc_media_warpMouse(WARPMOUSE_X, WARPMOUSEGLOBAL_Y);
|
|
break;
|
|
case FN_WarpMouseGlobal: //Sub Procedure
|
|
rc_media_warpMouseGlobal(WARPMOUSEGLOBAL_X, WARPMOUSEGLOBAL_Y);
|
|
break;
|
|
case FN_SetMouseZone: //Sub Procedure
|
|
rc_media_setMouseZone(SETMOUSEZONE_X, SETMOUSEZONE_Y, SETMOUSEZONE_W, SETMOUSEZONE_H);
|
|
break;
|
|
case FN_ClearMouseZone: //Sub Procedure
|
|
rc_media_clearMouseZone();
|
|
break;
|
|
case FN_SetWindowAlwaysOnTop: //Sub Procedure
|
|
rc_media_setWindowAlwaysOnTop(SETWINDOWALWAYSONTOP_WIN, SETWINDOWALWAYSONTOP_FLAG);
|
|
break;
|
|
case FN_SetMouseRelative: //Sub Procedure
|
|
rc_media_setMouseRelative(SETMOUSERELATIVE_FLAG);
|
|
break;
|
|
case FN_SetWindowVSync: //Sub Procedure
|
|
rc_media_setWindowVSync(SETWINDOWVSYNC_WIN, SETWINDOWVSYNC_FLAG);
|
|
break;
|
|
case FN_OpenURL: //Number Function
|
|
rc_push_num( rc_media_openURL(OPENURL_URL$));
|
|
break;
|
|
case FN_APIVersion$: //String Function
|
|
rc_push_str( rc_media_APIVersion() );
|
|
break;
|
|
case FN_FlashWindow: //Number Function
|
|
rc_push_num( rc_media_flashWindow(FLASHWINDOW_WIN));
|
|
break;
|
|
case FN_MessageBox: //Number Function
|
|
rc_push_num( rc_media_messageBox(MESSAGEBOX_TITLE$, MESSAGEBOX_MSG$));
|
|
break;
|
|
case FN_NumberArrayCopy: //Sub Procedure
|
|
rc_number_array_copy( &num_var[0], &num_var[1]);
|
|
arr_ref_id.clear();
|
|
break;
|
|
case FN_StringArrayCopy: //Sub Procedure
|
|
rc_string_array_copy( &str_var[0], &str_var[1]);
|
|
arr_ref_id.clear();
|
|
break;
|
|
case FN_NumberArrayFill: //Sub Procedure
|
|
rc_number_array_fill( &num_var[0], NUMBERARRAYFILL_FDATA);
|
|
arr_ref_id.clear();
|
|
break;
|
|
case FN_StringArrayFill: //Sub Procedure
|
|
rc_string_array_fill( &str_var[0], STRINGARRAYFILL_FDATA$);
|
|
arr_ref_id.clear();
|
|
break;
|
|
case FN_Runtime$: //String Function
|
|
rc_push_str( rcbasic_runtime_path );
|
|
break;
|
|
|
|
|
|
case FN_DimMatrix: //Sub Procedure
|
|
if(rc_active_matrix_process < 0)
|
|
DimMatrix(DIMMATRIX_M, DIMMATRIX_M_ROWS, DIMMATRIX_M_COLS, DIMMATRIX_PRESERVE_FLAG);
|
|
else
|
|
ProcessQueueMatrixOp(FN_DimMatrix, DIMMATRIX_M, DIMMATRIX_M_ROWS, DIMMATRIX_M_COLS, DIMMATRIX_PRESERVE_FLAG);
|
|
break;
|
|
case FN_AddMatrix: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(AddMatrix(ADDMATRIX_MA, ADDMATRIX_MB, ADDMATRIX_MC));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_AddMatrix, ADDMATRIX_MA, ADDMATRIX_MB, ADDMATRIX_MC);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_AugmentMatrix: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(AugmentMatrix(AUGMENTMATRIX_MA, AUGMENTMATRIX_MB, AUGMENTMATRIX_MC));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_AugmentMatrix, AUGMENTMATRIX_MA, AUGMENTMATRIX_MB, AUGMENTMATRIX_MC);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_CopyMatrix: //Sub Procedure
|
|
if(rc_active_matrix_process < 0)
|
|
CopyMatrix(COPYMATRIX_MA, COPYMATRIX_MB);
|
|
else
|
|
ProcessQueueMatrixOp(FN_CopyMatrix, COPYMATRIX_MA, COPYMATRIX_MB);
|
|
break;
|
|
case FN_InsertMatrixColumns: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(InsertMatrixColumn(INSERTMATRIXCOLUMNS_MA, INSERTMATRIXCOLUMNS_C, INSERTMATRIXCOLUMNS_NUM_COLS));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_InsertMatrixColumns, INSERTMATRIXCOLUMNS_MA, INSERTMATRIXCOLUMNS_C, INSERTMATRIXCOLUMNS_NUM_COLS);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_InsertMatrixRows: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(InsertMatrixRow(INSERTMATRIXROWS_MA, INSERTMATRIXROWS_R, INSERTMATRIXROWS_NUM_ROWS));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_InsertMatrixRows, INSERTMATRIXROWS_MA, INSERTMATRIXROWS_R, INSERTMATRIXROWS_NUM_ROWS);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_MultiplyMatrix: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(MultiplyMatrix(MULTIPLYMATRIX_MA, MULTIPLYMATRIX_MB, MULTIPLYMATRIX_MC));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_MultiplyMatrix, MULTIPLYMATRIX_MA, MULTIPLYMATRIX_MB, MULTIPLYMATRIX_MC);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_CubeMatrix: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(CubeMatrix(CUBEMATRIX_MA, CUBEMATRIX_MB, rc_active_matrix_process));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_CubeMatrix, CUBEMATRIX_MA, CUBEMATRIX_MB);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_DeleteMatrixColumns: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(DeleteMatrixColumns(DELETEMATRIXCOLUMNS_MA, DELETEMATRIXCOLUMNS_C, DELETEMATRIXCOLUMNS_NUM_COLS, rc_active_matrix_process));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_DeleteMatrixColumns, DELETEMATRIXCOLUMNS_MA, DELETEMATRIXCOLUMNS_C, DELETEMATRIXCOLUMNS_NUM_COLS);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_DeleteMatrixRows: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(DeleteMatrixRows(DELETEMATRIXROWS_MA, DELETEMATRIXROWS_R, DELETEMATRIXROWS_NUM_ROWS));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_DeleteMatrixRows, DELETEMATRIXROWS_MA, DELETEMATRIXROWS_R, DELETEMATRIXROWS_NUM_ROWS);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_ClearMatrix: //Sub Procedure
|
|
if(rc_active_matrix_process < 0)
|
|
ClearMatrix(CLEARMATRIX_MA);
|
|
else
|
|
ProcessQueueMatrixOp(FN_ClearMatrix, CLEARMATRIX_MA);
|
|
break;
|
|
case FN_ClearMatrixColumns: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(ClearMatrixColumns(CLEARMATRIXCOLUMNS_MA, CLEARMATRIXCOLUMNS_C, CLEARMATRIXCOLUMNS_NUM_COLS));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_ClearMatrixColumns, CLEARMATRIXCOLUMNS_MA, CLEARMATRIXCOLUMNS_C, CLEARMATRIXCOLUMNS_NUM_COLS);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_ClearMatrixRows: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(ClearMatrixRows(CLEARMATRIXROWS_MA, CLEARMATRIXROWS_R, CLEARMATRIXROWS_NUM_ROWS));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_ClearMatrixRows, CLEARMATRIXROWS_MA, CLEARMATRIXROWS_R, CLEARMATRIXROWS_NUM_ROWS);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_FillMatrix: //Sub Procedure
|
|
if(rc_active_matrix_process < 0)
|
|
FillMatrix(FILLMATRIX_MA, FILLMATRIX_V);
|
|
else
|
|
ProcessQueueMatrixOp(FN_FillMatrix, FILLMATRIX_MA, FILLMATRIX_V);
|
|
break;
|
|
case FN_FillMatrixColumns: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(FillMatrixColumns(FILLMATRIXCOLUMNS_MA, FILLMATRIXCOLUMNS_C, FILLMATRIXCOLUMNS_NUM_COLS, FILLMATRIXCOLUMNS_V));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_FillMatrixColumns, FILLMATRIXCOLUMNS_MA, FILLMATRIXCOLUMNS_C, FILLMATRIXCOLUMNS_NUM_COLS, FILLMATRIXCOLUMNS_V);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_FillMatrixRows: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(FillMatrixRows(FILLMATRIXROWS_MA, FILLMATRIXROWS_R, FILLMATRIXROWS_NUM_ROWS, FILLMATRIXROWS_V));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_FillMatrixRows, FILLMATRIXROWS_MA, FILLMATRIXROWS_R, FILLMATRIXROWS_NUM_ROWS, FILLMATRIXROWS_V);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_CopyMatrixColumns: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(GetMatrixColumns(COPYMATRIXCOLUMNS_MA, COPYMATRIXCOLUMNS_MB, COPYMATRIXCOLUMNS_C, COPYMATRIXCOLUMNS_NUM_COLS));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_CopyMatrixColumns, COPYMATRIXCOLUMNS_MA, COPYMATRIXCOLUMNS_MB, COPYMATRIXCOLUMNS_C, COPYMATRIXCOLUMNS_NUM_COLS);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_CopyMatrixRows: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(GetMatrixRows(COPYMATRIXROWS_MA, COPYMATRIXROWS_MB, COPYMATRIXROWS_R, COPYMATRIXROWS_NUM_ROWS));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_CopyMatrixRows, COPYMATRIXROWS_MA, COPYMATRIXROWS_MB, COPYMATRIXROWS_R, COPYMATRIXROWS_NUM_ROWS);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_IdentityMatrix: //Sub Procedure
|
|
if(rc_active_matrix_process < 0)
|
|
IdentityMatrix(IDENTITYMATRIX_MA, IDENTITYMATRIX_N);
|
|
else
|
|
ProcessQueueMatrixOp(FN_IdentityMatrix, IDENTITYMATRIX_MA, IDENTITYMATRIX_N);
|
|
break;
|
|
case FN_SolveMatrix: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(SolveMatrix(SOLVEMATRIX_MA, SOLVEMATRIX_MB, SOLVEMATRIX_MC));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_SolveMatrix, SOLVEMATRIX_MA, SOLVEMATRIX_MB, SOLVEMATRIX_MC);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
|
|
//MAIN THREAD ONLY
|
|
case FN_IsEqualMatrix: //Number Function
|
|
rc_push_num(IsEqualMatrix(ISEQUALMATRIX_MA, ISEQUALMATRIX_MB, ISEQUALMATRIX_TOLERANCE));
|
|
break;
|
|
|
|
//MAIN THREAD ONLY
|
|
case FN_Determinant: //Number Function
|
|
rc_push_num(Determinant(DETERMINANT_MA));
|
|
break;
|
|
|
|
case FN_AdjointMatrix: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(AdjointMatrix(ADJOINTMATRIX_MA, ADJOINTMATRIX_MB));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_AdjointMatrix, ADJOINTMATRIX_MA, ADJOINTMATRIX_MB);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_InvertMatrix: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(InvertMatrix(INVERTMATRIX_MA, INVERTMATRIX_MB));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_InvertMatrix, INVERTMATRIX_MA, INVERTMATRIX_MB);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
|
|
//MAIN THREAD ONLY
|
|
case FN_MatrixFromBuffer: //Sub Procedure
|
|
MatrixFromBuffer(MATRIXFROMBUFFER_MA, MATRIXFROMBUFFER_R, MATRIXFROMBUFFER_C, &MATRIXFROMBUFFER_BUFFER);
|
|
break;
|
|
|
|
//MAIN THREAD ONLY
|
|
case FN_GetMatrix: //Sub Procedure
|
|
BufferFromMatrix(&GETMATRIX_BUFFER, GETMATRIX_MA);
|
|
break;
|
|
|
|
case FN_RandomizeMatrix: //Sub Procedure
|
|
if(rc_active_matrix_process < 0)
|
|
RandomizeMatrix(RANDOMIZEMATRIX_MA, RANDOMIZEMATRIX_VMIN, RANDOMIZEMATRIX_VMAX);
|
|
else
|
|
ProcessQueueMatrixOp(FN_RandomizeMatrix, RANDOMIZEMATRIX_MA, RANDOMIZEMATRIX_VMIN, RANDOMIZEMATRIX_VMAX);
|
|
break;
|
|
|
|
//MAIN THREAD ONLY
|
|
case FN_MatrixValue: //Number Function
|
|
rc_push_num(MatrixValue(MATRIXVALUE_MA, MATRIXVALUE_R, MATRIXVALUE_C));
|
|
break;
|
|
|
|
case FN_SetMatrixValue: //Sub Procedure
|
|
if(rc_active_matrix_process < 0)
|
|
SetMatrixValue(SETMATRIXVALUE_MA, SETMATRIXVALUE_R, SETMATRIXVALUE_C, SETMATRIXVALUE_V);
|
|
else
|
|
ProcessQueueMatrixOp(FN_SetMatrixValue, SETMATRIXVALUE_MA, SETMATRIXVALUE_R, SETMATRIXVALUE_C, SETMATRIXVALUE_V);
|
|
break;
|
|
case FN_ScalarMatrix: //Sub Procedure
|
|
if(rc_active_matrix_process < 0)
|
|
ScalarMatrix(SCALARMATRIX_MA, SCALARMATRIX_MB, SCALARMATRIX_S_VALUE);
|
|
else
|
|
ProcessQueueMatrixOp(FN_ScalarMatrix, SCALARMATRIX_MA, SCALARMATRIX_MB, SCALARMATRIX_S_VALUE);
|
|
break;
|
|
case FN_ScalarMatrixColumns: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(ScalarMatrixColumns(SCALARMATRIXCOLUMNS_MA, SCALARMATRIXCOLUMNS_MB, SCALARMATRIXCOLUMNS_C, SCALARMATRIXCOLUMNS_NUM_COLS, SCALARMATRIXCOLUMNS_S_VALUE));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_ScalarMatrixColumns, SCALARMATRIXCOLUMNS_MA, SCALARMATRIXCOLUMNS_MB, SCALARMATRIXCOLUMNS_C, SCALARMATRIXCOLUMNS_NUM_COLS, SCALARMATRIXCOLUMNS_S_VALUE);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_ScalarMatrixRows: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(ScalarMatrixRows(SCALARMATRIXROWS_MA, SCALARMATRIXROWS_MB, SCALARMATRIXROWS_R, SCALARMATRIXROWS_NUM_ROWS, SCALARMATRIXROWS_S_VALUE));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_ScalarMatrixRows, SCALARMATRIXROWS_MA, SCALARMATRIXROWS_MB, SCALARMATRIXROWS_R, SCALARMATRIXROWS_NUM_ROWS, SCALARMATRIXROWS_S_VALUE);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_SquareMatrix: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(SquareMatrix(SQUAREMATRIX_MA, SQUAREMATRIX_MB));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_SquareMatrix, SQUAREMATRIX_MA, SQUAREMATRIX_MB);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_SubMatrix: //Sub Procedure
|
|
if(rc_active_matrix_process < 0)
|
|
SubMatrix(SUBMATRIX_MA, SUBMATRIX_R, SUBMATRIX_C);
|
|
else
|
|
ProcessQueueMatrixOp(FN_SubMatrix, SUBMATRIX_MA, SUBMATRIX_R, SUBMATRIX_C);
|
|
break;
|
|
case FN_SubtractMatrix: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(SubtractMatrix(SUBTRACTMATRIX_MA, SUBTRACTMATRIX_MB, SUBTRACTMATRIX_MC));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_SubtractMatrix, SUBTRACTMATRIX_MA, SUBTRACTMATRIX_MB, SUBTRACTMATRIX_MC);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_SwapMatrix: //Sub Procedure
|
|
if(rc_active_matrix_process < 0)
|
|
SwapMatrix(SWAPMATRIX_MA, SWAPMATRIX_MB, rc_active_matrix_process);
|
|
else
|
|
ProcessQueueMatrixOp(FN_SwapMatrix, SWAPMATRIX_MA, SWAPMATRIX_MB);
|
|
break;
|
|
case FN_SwapMatrixColumn: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(SwapMatrixColumn(SWAPMATRIXCOLUMN_MA, SWAPMATRIXCOLUMN_C1, SWAPMATRIXCOLUMN_C2));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_SwapMatrixColumn, SWAPMATRIXCOLUMN_MA, SWAPMATRIXCOLUMN_C1, SWAPMATRIXCOLUMN_C2);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_SwapMatrixRow: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(SwapMatrixRow(SWAPMATRIXROW_MA, SWAPMATRIXROW_R1, SWAPMATRIXROW_R2));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_SwapMatrixRow, SWAPMATRIXROW_MA, SWAPMATRIXROW_R1, SWAPMATRIXROW_R2);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_TransposeMatrix: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(TransposeMatrix(TRANSPOSEMATRIX_MA, TRANSPOSEMATRIX_MB));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_TransposeMatrix, TRANSPOSEMATRIX_MA, TRANSPOSEMATRIX_MB);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_UnAugmentMatrix: //Number Function
|
|
if(rc_active_matrix_process < 0)
|
|
rc_push_num(UnAugmentMatrix(UNAUGMENTMATRIX_MA, UNAUGMENTMATRIX_MB, UNAUGMENTMATRIX_MC));
|
|
else
|
|
{
|
|
ProcessQueueMatrixOp(FN_UnAugmentMatrix, UNAUGMENTMATRIX_MA, UNAUGMENTMATRIX_MB, UNAUGMENTMATRIX_MC);
|
|
rc_push_num(1);
|
|
}
|
|
break;
|
|
case FN_ZeroMatrix: //Sub Procedure
|
|
if(rc_active_matrix_process < 0)
|
|
ZeroMatrix(ZEROMATRIX_MA);
|
|
else
|
|
ProcessQueueMatrixOp(FN_ZeroMatrix, ZEROMATRIX_MA);
|
|
break;
|
|
|
|
//MAIN THREAD ONLY
|
|
case FN_GetMatrixSize: //Sub Procedure
|
|
GetMatrixSize(GETMATRIXSIZE_MA, &GETMATRIXSIZE_R, &GETMATRIXSIZE_C);
|
|
break;
|
|
|
|
case FN_SetMatrixProcess: //Number Function
|
|
rc_push_num(rc_setMatrixProcess(SETMATRIXPROCESS_P_NUM));
|
|
break;
|
|
case FN_ProcessOpen: //Number Function
|
|
rc_push_num(rc_processOpen(PROCESSOPEN_P_NUM));
|
|
break;
|
|
case FN_SetProcessErrorMode: //Sub Procedure
|
|
rc_setProcessErrorMode(SETPROCESSERRORMODE_P_NUM, SETPROCESSERRORMODE_ERROR_MODE);
|
|
break;
|
|
case FN_ProcessError: //Number Function
|
|
rc_push_num(ProcessError(PROCESSERROR_P_NUM));
|
|
break;
|
|
case FN_ProcessWait: //Sub Procedure
|
|
ProcessWait(PROCESSWAIT_P_NUM);
|
|
break;
|
|
case FN_ProcessWaitAll: //Sub Procedure
|
|
ProcessWaitAll();
|
|
break;
|
|
case FN_ProcessContinue: //Sub Procedure
|
|
ProcessContinue(PROCESSCONTINUE_P_NUM);
|
|
break;
|
|
case FN_ProcessStop: //Sub Procedure
|
|
ProcessStop(PROCESSSTOP_P_NUM);
|
|
break;
|
|
case FN_ProcessClear: //Sub Procedure
|
|
ProcessClear(PROCESSCLEAR_P_NUM);
|
|
break;
|
|
case FN_ProcessClose: //Number Function
|
|
rc_push_num(ProcessClose(PROCESSCLOSE_P_NUM));
|
|
break;
|
|
case FN_ProcessErrorMode: //Number Function
|
|
rc_push_num(ProcessErrorMode(PROCESSERRORMODE_P_NUM));
|
|
break;
|
|
case FN_ProcessSleep: //Sub Procedure
|
|
ProcessSleep(PROCESSSLEEP_P_NUM, PROCESSSLEEP_MSEC);
|
|
break;
|
|
case FN_ProcessExists: //Number Function
|
|
rc_push_num(ProcessExists(PROCESSEXISTS_P_NUM));
|
|
break;
|
|
case FN_ProcessStopAll: //Sub Procedure
|
|
ProcessStopAll();
|
|
break;
|
|
case FN_ProcessContinueAll: //Sub Procedure
|
|
ProcessContinueAll();
|
|
break;
|
|
case FN_ProcessQueueSize: //Number Function
|
|
rc_push_num(ProcessQueueSize(PROCESSQUEUESIZE_P_NUM));
|
|
break;
|
|
case FN_NumCPUs: //Number Function
|
|
rc_push_num(NumCPUs());
|
|
break;
|
|
case FN_GetProjectionGeometry: //Sub Procedure
|
|
rc_GetProjectionGeometry(GETPROJECTIONGEOMETRY_CAM_DIST, GETPROJECTIONGEOMETRY_MA, GETPROJECTIONGEOMETRY_F_VERTEX_COUNT, &GETPROJECTIONGEOMETRY_COLUMNS, &GETPROJECTIONGEOMETRY_UV,
|
|
GETPROJECTIONGEOMETRY_GRAPH_OFFSET_X, GETPROJECTIONGEOMETRY_GRAPH_OFFSET_Y, GETPROJECTIONGEOMETRY_V_COLOR,
|
|
&GETPROJECTIONGEOMETRY_VERTEX_COUNT, &GETPROJECTIONGEOMETRY_VERTEX2D, &GETPROJECTIONGEOMETRY_INDEX_COUNT, &GETPROJECTIONGEOMETRY_INDEX,
|
|
&GETPROJECTIONGEOMETRY_CLIP_DIST, &GETPROJECTIONGEOMETRY_MIN_X, &GETPROJECTIONGEOMETRY_MIN_Y, &GETPROJECTIONGEOMETRY_MAX_X, &GETPROJECTIONGEOMETRY_MAX_Y);
|
|
break;
|
|
case FN_CalculateFaceZ: //Number Function
|
|
rc_push_num( CalculateFaceZ(CALCULATEFACEZ_CAM_DIST, CALCULATEFACEZ_GRAPH_OFFSET_X, CALCULATEFACEZ_GRAPH_OFFSET_Y, CALCULATEFACEZ_VIEW_W, CALCULATEFACEZ_VIEW_H, CALCULATEFACEZ_VIEW_DEPTH,
|
|
CALCULATEFACEZ_MA, CALCULATEFACEZ_F_VERTEX_COUNT, &CALCULATEFACEZ_COLUMNS, &CALCULATEFACEZ_FACE_MIN_Z, &CALCULATEFACEZ_FACE_MAX_Z, &CALCULATEFACEZ_Z_AVG));
|
|
break;
|
|
case FN_SetChannelSpacePosition: //Number Function
|
|
rc_push_num(rc_media_setChannelSpacePosition(SETCHANNELSPACEPOSITION_CHANNEL, SETCHANNELSPACEPOSITION_ANGLE, SETCHANNELSPACEPOSITION_DISTANCE));
|
|
break;
|
|
case FN_SaveBMP: //Number Function
|
|
rc_push_num(SaveBMP(SAVEBMP_IMG, SAVEBMP_FILE$));
|
|
break;
|
|
case FN_SavePNG: //Number Function
|
|
rc_push_num(SavePNG(SAVEPNG_IMG, SAVEPNG_FILE$));
|
|
break;
|
|
case FN_SaveJPG: //Number Function
|
|
rc_push_num(SaveJPG(SAVEJPG_IMG, SAVEJPG_FILE$));
|
|
break;
|
|
case FN_GetLineIntersection: //Number Function
|
|
rc_push_num(GetLineIntersect(GETLINEINTERSECTION_P0_X, GETLINEINTERSECTION_P0_Y,
|
|
GETLINEINTERSECTION_P1_X, GETLINEINTERSECTION_P1_Y,
|
|
GETLINEINTERSECTION_P2_X, GETLINEINTERSECTION_P2_Y,
|
|
GETLINEINTERSECTION_P3_X, GETLINEINTERSECTION_P3_Y,
|
|
&GETLINEINTERSECTION_I_X, &GETLINEINTERSECTION_I_Y));
|
|
break;
|
|
case FN_Interpolate: //Number Function
|
|
rc_push_num(Interpolate(INTERPOLATE_MIN_A, INTERPOLATE_MAX_A, INTERPOLATE_MID_A, INTERPOLATE_MIN_B, INTERPOLATE_MAX_B));
|
|
break;
|
|
case FN_ATan2: //Number Function
|
|
rc_push_num(atan2(ATAN2_Y, ATAN2_X));
|
|
break;
|
|
case FN_PointInQuad: //Number Function
|
|
rc_push_num(PointInQuad(POINTINQUAD_X, POINTINQUAD_Y,
|
|
POINTINQUAD_X1, POINTINQUAD_Y1,
|
|
POINTINQUAD_X2, POINTINQUAD_Y2,
|
|
POINTINQUAD_X3, POINTINQUAD_Y3,
|
|
POINTINQUAD_X4, POINTINQUAD_Y4));
|
|
break;
|
|
case FN_PointInTri: //Number Function
|
|
rc_push_num(PointInTri(POINTINTRI_X, POINTINTRI_Y,
|
|
POINTINTRI_X1, POINTINTRI_Y1,
|
|
POINTINTRI_X2, POINTINTRI_Y2,
|
|
POINTINTRI_X3, POINTINTRI_Y3));
|
|
break;
|
|
case FN_Distance2D: //Number Function
|
|
rc_push_num(Distance2D(DISTANCE2D_X1, DISTANCE2D_Y1, DISTANCE2D_X2, DISTANCE2D_Y2));
|
|
break;
|
|
case FN_Distance3D: //Number Function
|
|
rc_push_num(Distance3D(DISTANCE3D_X1, DISTANCE3D_Y1, DISTANCE3D_Z1, DISTANCE3D_X2, DISTANCE3D_Y2, DISTANCE3D_Z2));
|
|
break;
|
|
case FN_GetCircleLineIntersection: //Number Function
|
|
rc_push_num(GetCircleLineIntersection(GETCIRCLELINEINTERSECTION_CIRCLE_X, GETCIRCLELINEINTERSECTION_CIRCLE_Y, GETCIRCLELINEINTERSECTION_RADIUS,
|
|
GETCIRCLELINEINTERSECTION_X1, GETCIRCLELINEINTERSECTION_Y1,
|
|
GETCIRCLELINEINTERSECTION_X2, GETCIRCLELINEINTERSECTION_Y2,
|
|
&GETCIRCLELINEINTERSECTION_IX1, &GETCIRCLELINEINTERSECTION_IY1,
|
|
&GETCIRCLELINEINTERSECTION_IX2, &GETCIRCLELINEINTERSECTION_IY2));
|
|
break;
|
|
case FN_GetLinePlaneIntersection: //Number Function
|
|
rc_push_num(GetLinePlaneIntersection(&GETLINEPLANEINTERSECTION_LINE_POINT, &GETLINEPLANEINTERSECTION_LINE_DIRECTION,
|
|
&GETLINEPLANEINTERSECTION_PLANE_POINT_1,
|
|
&GETLINEPLANEINTERSECTION_PLANE_POINT_2,
|
|
&GETLINEPLANEINTERSECTION_PLANE_POINT_3,
|
|
&GETLINEPLANEINTERSECTION_INTERSECTION));
|
|
break;
|
|
case FN_IncrementMatrixRows: //Sub Procedure
|
|
IncrementMatrixRows(INCREMENTMATRIXROWS_MA, INCREMENTMATRIXROWS_MB, INCREMENTMATRIXROWS_R, INCREMENTMATRIXROWS_NUM_ROWS, INCREMENTMATRIXROWS_VALUE);
|
|
break;
|
|
case FN_IncrementMatrixColumns: //Sub Procedure
|
|
IncrementMatrixColumns(INCREMENTMATRIXCOLUMNS_MA, INCREMENTMATRIXCOLUMNS_MB, INCREMENTMATRIXCOLUMNS_C, INCREMENTMATRIXCOLUMNS_NUM_COLS, INCREMENTMATRIXCOLUMNS_VALUE);
|
|
break;
|
|
case FN_JoinMatrixRows: //Sub Procedure
|
|
JoinMatrixRows(JOINMATRIXROWS_MA, JOINMATRIXROWS_MB, JOINMATRIXROWS_MC);
|
|
break;
|
|
case FN_JoinMatrixColumns: //Sub Procedure
|
|
JoinMatrixColumns(JOINMATRIXCOLUMNS_MA, JOINMATRIXCOLUMNS_MB, JOINMATRIXCOLUMNS_MC);
|
|
break;
|
|
|
|
case FN_TypeArrayDim: //Number Function
|
|
rc_push_num( rc_type_array_dim( TYPEARRAYDIM_ID ) );
|
|
arr_ref_id.clear();
|
|
break;
|
|
case FN_TypeArraySize: //Number Function
|
|
rc_push_num( rc_type_array_size( TYPEARRAYSIZE_ID, TYPEARRAYSIZE_ARRAY_DIM ) );
|
|
arr_ref_id.clear();
|
|
break;
|
|
case FN_TypeArrayCopy: //Sub Procedure
|
|
//cout << "TAS: " << TYPEARRAYCOPY_SRC->uid_value.size() << endl;
|
|
//cout << "TAD: " << TYPEARRAYCOPY_DST->uid_value.size() << endl;
|
|
rc_free_type(TYPEARRAYCOPY_DST); //cout << "TA[2]: " << TYPEARRAYCOPY_DST->uid_value.size() << endl;
|
|
rc_type_array_copy( TYPEARRAYCOPY_SRC, TYPEARRAYCOPY_DST );
|
|
break;
|
|
case FN_TypeArrayFill: //Sub Procedure
|
|
//cout << "test type fill" << endl;
|
|
rc_type_array_fill( TYPEARRAYFILL_SRC, &TYPEARRAYFILL_FDATA );
|
|
break;
|
|
|
|
|
|
}
|
|
}
|
|
|
|
void push_131(double num)
|
|
{
|
|
rc_vm_n tmp_n;
|
|
tmp_n.value = num;
|
|
n_stack.push(tmp_n);
|
|
//current_n_stack_count++;
|
|
}
|
|
|
|
void println_132()
|
|
{
|
|
cout << endl;
|
|
}
|
|
|
|
void mov_133(int n1, int flag)
|
|
{
|
|
switch(flag)
|
|
{
|
|
case LESS_FLAG:
|
|
vm_n[n1].value = CMP_FLAG_LESS;
|
|
break;
|
|
case LESS_EQUAL_FLAG:
|
|
vm_n[n1].value = CMP_FLAG_LESS_EQUAL;
|
|
break;
|
|
case GREATER_FLAG:
|
|
vm_n[n1].value = CMP_FLAG_GREATER;
|
|
break;
|
|
case GREATER_EQUAL_FLAG:
|
|
vm_n[n1].value = CMP_FLAG_GREATER_EQUAL;
|
|
break;
|
|
case EQUAL_FLAG:
|
|
vm_n[n1].value = CMP_FLAG_EQUAL;
|
|
break;
|
|
case NOT_EQUAL_FLAG:
|
|
vm_n[n1].value = CMP_FLAG_NOT_EQUAL;
|
|
break;
|
|
}
|
|
//cout << "n" << n1 << " = " << vm_n[n1].value << endl;
|
|
}
|
|
|
|
void cmp_134(int n1, double num)
|
|
{
|
|
CMP_FLAG_EQUAL = (vm_n[n1].value == num);
|
|
CMP_FLAG_GREATER = (vm_n[n1].value > num);
|
|
CMP_FLAG_GREATER_EQUAL = (vm_n[n1].value >= num);
|
|
CMP_FLAG_LESS = (vm_n[n1].value < num);
|
|
CMP_FLAG_LESS_EQUAL = (vm_n[n1].value <= num);
|
|
CMP_FLAG_NOT_EQUAL = (vm_n[n1].value != num);
|
|
}
|
|
|
|
void mov_arr_135(int n1, uint64_t nid)
|
|
{
|
|
arr_ref_id.push_back( nid );
|
|
vm_n[n1].r = num_var[nid].nref;
|
|
}
|
|
|
|
void mov_arrS_136(int s1, uint64_t sid)
|
|
{
|
|
arr_ref_id.push_back( sid );
|
|
vm_s[s1].r = str_var[sid].sref;
|
|
}
|
|
|
|
void pop_ptr_137(uint64_t n)
|
|
{
|
|
//cout << "pop_ptr " << n << endl;
|
|
//cout << "b_stack_size = " << byref_addr_table.size() << endl;
|
|
for(int i = 0; i < n; i++)
|
|
{
|
|
//cout << "byref i = " << i << endl;
|
|
switch(byref_addr_table.top().type)
|
|
{
|
|
case BYREF_TYPE_NUM:
|
|
num_var[byref_addr_table.top().ptr_id].nref = (n_value*)byref_addr_table.top().ptr_addr;
|
|
num_var[byref_addr_table.top().ptr_id].byref_offset = byref_var_byref_offset.top();
|
|
break;
|
|
case BYREF_TYPE_STR:
|
|
str_var[byref_addr_table.top().ptr_id].sref = (s_value*)byref_addr_table.top().ptr_addr;
|
|
str_var[byref_addr_table.top().ptr_id].byref_offset = byref_var_byref_offset.top();
|
|
break;
|
|
case BYREF_TYPE_USR:
|
|
usr_var[byref_addr_table.top().ptr_id].var_ref = (rc_usrId*)byref_addr_table.top().ptr_addr;
|
|
usr_var[byref_addr_table.top().ptr_id].var_ref_index = byref_var_byref_offset.top();
|
|
break;
|
|
}
|
|
byref_addr_table.pop();
|
|
byref_var_byref_offset.pop();
|
|
}
|
|
}
|
|
|
|
void preset_138(uint64_t nid)
|
|
{
|
|
int nid_size = 1;
|
|
switch(num_var[nid].dimensions)
|
|
{
|
|
case 3:
|
|
nid_size *= num_var[nid].dim[2];
|
|
case 2:
|
|
nid_size *= num_var[nid].dim[1];
|
|
case 1:
|
|
nid_size *= num_var[nid].dim[0];
|
|
break;
|
|
}
|
|
for(int i = 0; i < nid_size; i++)
|
|
num_var[nid].nref[0].value[i] = 0;
|
|
}
|
|
|
|
void presetS_139(uint64_t sid)
|
|
{
|
|
int sid_size = 1;
|
|
switch(str_var[sid].dimensions)
|
|
{
|
|
case 3:
|
|
sid_size *= str_var[sid].dim[2];
|
|
case 2:
|
|
sid_size *= str_var[sid].dim[1];
|
|
case 1:
|
|
sid_size *= str_var[sid].dim[0];
|
|
break;
|
|
}
|
|
for(int i = 0; i < sid_size; i++)
|
|
str_var[sid].sref[0].value[i] = "";
|
|
}
|
|
|
|
void redim_140(uint64_t nid, int n1)
|
|
{
|
|
#ifdef RCBASIC_DEBUG
|
|
if(vm_n[n1].value <= 0)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_REDIM_LEQ_ZERO;
|
|
return;
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
num_var[nid].nref[0].value.resize((uint64_t)vm_n[n1].value);
|
|
num_var[nid].dimensions = 1;
|
|
num_var[nid].dim[0] = (uint64_t)vm_n[n1].value;
|
|
num_var[nid].dim[1] = 0;
|
|
num_var[nid].dim[2] = 0;
|
|
}
|
|
|
|
void redim_141(uint64_t nid, int n1, int n2)
|
|
{
|
|
#ifdef RCBASIC_DEBUG
|
|
if(vm_n[n1].value <= 0 || vm_n[n2].value <= 0)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_REDIM_LEQ_ZERO;
|
|
return;
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
num_var[nid].nref[0].value.resize( (uint64_t)vm_n[n1].value * (uint64_t)vm_n[n2].value );
|
|
num_var[nid].dimensions = 2;
|
|
num_var[nid].dim[0] = (uint64_t)vm_n[n1].value;
|
|
num_var[nid].dim[1] = (uint64_t)vm_n[n2].value;
|
|
num_var[nid].dim[2] = 0;
|
|
}
|
|
|
|
void redim_142(uint64_t nid, int n1, int n2, int n3)
|
|
{
|
|
#ifdef RCBASIC_DEBUG
|
|
if(vm_n[n1].value <= 0 || vm_n[n2].value <= 0 || vm_n[n3].value <= 0)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_REDIM_LEQ_ZERO;
|
|
return;
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
num_var[nid].nref[0].value.resize( (uint64_t)vm_n[n1].value * (uint64_t)vm_n[n2].value * (uint64_t)vm_n[n3].value);
|
|
num_var[nid].dimensions = 3;
|
|
num_var[nid].dim[0] = (uint64_t)vm_n[n1].value;
|
|
num_var[nid].dim[1] = (uint64_t)vm_n[n2].value;
|
|
num_var[nid].dim[2] = (uint64_t)vm_n[n3].value;
|
|
}
|
|
|
|
void redimS_143(uint64_t sid, int n1)
|
|
{
|
|
#ifdef RCBASIC_DEBUG
|
|
if(vm_n[n1].value <= 0)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_REDIM_LEQ_ZERO;
|
|
return;
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
str_var[sid].sref[0].value.resize((uint64_t)vm_n[n1].value);
|
|
str_var[sid].dimensions = 1;
|
|
str_var[sid].dim[0] = (uint64_t)vm_n[n1].value;
|
|
str_var[sid].dim[1] = 0;
|
|
str_var[sid].dim[2] = 0;
|
|
}
|
|
|
|
void redimS_144(uint64_t sid, int n1, int n2)
|
|
{
|
|
#ifdef RCBASIC_DEBUG
|
|
if(vm_n[n1].value <= 0 || vm_n[n2].value <= 0)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_REDIM_LEQ_ZERO;
|
|
return;
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
str_var[sid].sref[0].value.resize( (uint64_t)vm_n[n1].value * (uint64_t)vm_n[n2].value );
|
|
str_var[sid].dimensions = 2;
|
|
str_var[sid].dim[0] = (uint64_t)vm_n[n1].value;
|
|
str_var[sid].dim[1] = (uint64_t)vm_n[n2].value;
|
|
str_var[sid].dim[2] = 0;
|
|
}
|
|
|
|
void redimS_145(uint64_t sid, int n1, int n2, int n3)
|
|
{
|
|
#ifdef RCBASIC_DEBUG
|
|
if(vm_n[n1].value <= 0 || vm_n[n2].value <= 0 || vm_n[n3].value <= 0)
|
|
{
|
|
dbg_error_found = true;
|
|
dbg_error_message = DBG_REDIM_LEQ_ZERO;
|
|
return;
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
str_var[sid].sref[0].value.resize( (uint64_t)vm_n[n1].value * (uint64_t)vm_n[n2].value * (uint64_t)vm_n[n3].value);
|
|
str_var[sid].dimensions = 3;
|
|
str_var[sid].dim[0] = (uint64_t)vm_n[n1].value;
|
|
str_var[sid].dim[1] = (uint64_t)vm_n[n2].value;
|
|
str_var[sid].dim[2] = (uint64_t)vm_n[n3].value;
|
|
}
|
|
|
|
void for_offset_arr1_146(int n1)
|
|
{
|
|
for_offset_index[0] = vm_n[n1].value;
|
|
for_offset_dimensions = 1;
|
|
}
|
|
|
|
void for_offset_arr2_147(int n1, int n2)
|
|
{
|
|
for_offset_index[0] = vm_n[n1].value;
|
|
for_offset_index[1] = vm_n[n2].value;
|
|
for_offset_dimensions = 2;
|
|
}
|
|
|
|
void for_offset_arr3_148(int n1, int n2, int n3)
|
|
{
|
|
for_offset_index[0] = vm_n[n1].value;
|
|
for_offset_index[1] = vm_n[n2].value;
|
|
for_offset_index[2] = vm_n[n3].value;
|
|
for_offset_dimensions = 3;
|
|
}
|
|
|
|
void for_offset_0_149()
|
|
{
|
|
for_offset_dimensions = 0;
|
|
}
|
|
|
|
void end_x_150(int n1)
|
|
{
|
|
rcbasic_exit_code = (int)vm_n[n1].value;
|
|
}
|
|
|
|
void lval_151(int n1)
|
|
{
|
|
//cout << "lval_151 = " << vm_n[n1].value << endl;
|
|
}
|
|
|
|
void lval_152(uint64_t nid)
|
|
{
|
|
//cout << "lval_152 = " << num_var[nid].nid_value[0].value[0] << endl;
|
|
}
|
|
|
|
void lval_153(uint64_t lval_addr )
|
|
{
|
|
//cout << "lval_153 = " << lval_addr << endl;
|
|
}
|
|
|
|
void lval_154(int s1)
|
|
{
|
|
//cout << "lval_154 = " << vm_s[s1].value << endl;
|
|
}
|
|
|
|
void lval_155(uint64_t sid)
|
|
{
|
|
//cout << "lval_155 = " << str_var[sid].sid_value[0].value[0] << endl;
|
|
}
|
|
|
|
void obj_usr_n_156(uint64_t nid)
|
|
{
|
|
//cout << "obj_usr_n start" << endl;
|
|
usr_object.num_ref = &usr_object.obj_ref->num_var[nid];
|
|
usr_object.num_ref->nref = &usr_object.num_ref->nid_value;
|
|
usr_object.index = 0;
|
|
//cout << "obj_usr_n done" << endl;
|
|
}
|
|
|
|
void obj_usr_n1_157(uint64_t nid, int n1)
|
|
{
|
|
usr_object.num_ref = &usr_object.obj_ref->num_var[nid];
|
|
usr_object.num_ref->nref = &usr_object.num_ref->nid_value;
|
|
usr_object.index = (uint64_t)vm_n[n1].value;
|
|
}
|
|
|
|
void obj_usr_n2_158(uint64_t nid, int n1, int n2)
|
|
{
|
|
usr_object.num_ref = &usr_object.obj_ref->num_var[nid];
|
|
usr_object.num_ref->nref = &usr_object.num_ref->nid_value;
|
|
usr_object.index = (uint64_t)vm_n[n1].value * usr_object.num_ref->dim[1] + (uint64_t)vm_n[n2].value;
|
|
}
|
|
|
|
void obj_usr_n3_159(uint64_t nid, int n1, int n2, int n3)
|
|
{
|
|
usr_object.num_ref = &usr_object.obj_ref->num_var[nid];
|
|
usr_object.num_ref->nref = &usr_object.num_ref->nid_value;
|
|
usr_object.index = ((uint64_t)vm_n[n1].value * usr_object.num_ref->dim[1] * usr_object.num_ref->dim[2]) + ( (uint64_t)vm_n[n2].value * usr_object.num_ref->dim[2]) + (uint64_t)vm_n[n3].value;
|
|
}
|
|
|
|
|
|
void obj_usr_s_160(uint64_t sid)
|
|
{
|
|
usr_object.str_ref = &usr_object.obj_ref->str_var[sid];
|
|
usr_object.str_ref->sref = &usr_object.str_ref->sid_value;
|
|
usr_object.index = 0;
|
|
}
|
|
|
|
void obj_usr_s1_161(uint64_t sid, int n1)
|
|
{
|
|
usr_object.str_ref = &usr_object.obj_ref->str_var[sid];
|
|
usr_object.str_ref->sref = &usr_object.str_ref->sid_value;
|
|
usr_object.index = (uint64_t)vm_n[n1].value;
|
|
}
|
|
|
|
void obj_usr_s2_162(uint64_t sid, int n1, int n2)
|
|
{
|
|
usr_object.str_ref = &usr_object.obj_ref->str_var[sid];
|
|
usr_object.str_ref->sref = &usr_object.str_ref->sid_value;
|
|
usr_object.index = (uint64_t)vm_n[n1].value * usr_object.str_ref->dim[1] + (uint64_t)vm_n[n2].value;
|
|
}
|
|
|
|
void obj_usr_s3_163(uint64_t sid, int n1, int n2, int n3)
|
|
{
|
|
usr_object.str_ref = &usr_object.obj_ref->str_var[sid];
|
|
usr_object.str_ref->sref = &usr_object.str_ref->sid_value;
|
|
usr_object.index = ((uint64_t)vm_n[n1].value * usr_object.str_ref->dim[1] * usr_object.str_ref->dim[2]) + ( (uint64_t)vm_n[n2].value * usr_object.str_ref->dim[2]) + (uint64_t)vm_n[n3].value;
|
|
}
|
|
|
|
void obj_usr_get_164(int n1)
|
|
{
|
|
//cout << "obj_usr_get_N start" << endl;
|
|
vm_n[n1].value = usr_object.num_ref->nref[0].value[usr_object.index];
|
|
vm_n[n1].r = usr_object.num_ref->nref;
|
|
vm_n[n1].r_index = usr_object.index;
|
|
|
|
usr_object.num_ref->nid_value.ref_parent = usr_object.num_ref;
|
|
//cout << "obj_usr_get_N done: " << vm_n[n1].r[0].value[vm_n[n1].r_index] << endl;
|
|
}
|
|
|
|
void obj_usr_get_165(int s1)
|
|
{
|
|
vm_s[s1].value = usr_object.str_ref->sref[0].value[usr_object.index];
|
|
vm_s[s1].r = usr_object.str_ref->sref;
|
|
vm_s[s1].r_index = usr_object.index;
|
|
|
|
usr_object.str_ref->sid_value.ref_parent = usr_object.str_ref;
|
|
//cout << "obj_usr_get -- " << usr_object.str_ref->dimensions << " --> " << usr_object.str_ref->dim[0] << ", " << usr_object.str_ref->dim[1] << endl;
|
|
}
|
|
|
|
void obj_usr_get_166(int u1)
|
|
{
|
|
//cout << "obj_usr_get start u" << u1 << endl;
|
|
//rc_usrId * tmp_usr_id = usr_object.obj_ref->byref_ptr;
|
|
//cout << "tmp check = " << usr_object.obj_ref->byref_ptr->dimensions << endl;
|
|
|
|
rc_free_type(&vm_u[u1]); //this should free any memory previously allocated in u1
|
|
|
|
//cout << "tmp check[2] = " << usr_object.obj_ref->byref_ptr->dimensions << endl;
|
|
|
|
//cout << "mem free: " << usr_object.obj_ref->dimensions << endl;
|
|
vm_u[u1] = usr_object.obj_ref[0];
|
|
//cout << "1: " << usr_object.obj_ref[0].uid_value.size() << endl;
|
|
vm_u[u1].var_ref = usr_object.obj_ref;
|
|
//cout << "2" << endl;
|
|
vm_u[u1].var_ref_index = usr_object.index; //usr_object.index;
|
|
|
|
//cout << "obj_usr_get end" << endl;
|
|
|
|
//cout << "tmp check[3] = " << vm_u[u1].var_ref->byref_ptr->dimensions << endl;
|
|
|
|
//cout << "bcheck = " << tmp_usr_id->dimensions << endl;
|
|
}
|
|
|
|
void uref_ptr_167(uint64_t uid, int u1)
|
|
{
|
|
//cout << "<--------UREF-------> : " << uid << " " << u1 << endl;
|
|
byref_id.ptr_id = uid;
|
|
byref_id.ptr_addr = usr_var[uid].var_ref;
|
|
byref_id.type = BYREF_TYPE_USR;
|
|
byref_addr_table.push(byref_id);
|
|
byref_var_byref_offset.push(usr_var[uid].var_ref_index);
|
|
|
|
//cout << "start index = " << usr_var[uid].var_ref_index << endl;
|
|
|
|
int i = vm_u[u1].var_ref_index;
|
|
|
|
usr_var[uid].var_ref = vm_u[u1].var_ref->byref_ptr;
|
|
usr_var[uid].var_ref_index = i; //vm_u[u1].var_ref_index;
|
|
|
|
//int i = vm_u[u1].var_ref_index;
|
|
//cout << "index = " << usr_var[uid].var_ref_index << endl;
|
|
//cout << "uref end: " << usr_var[uid].var_ref->uid_value.size() << endl;
|
|
//cout << "debug out = " << usr_var[uid].var_ref->uid_value[i].str_var[0].sid_value.value[3] << endl;
|
|
}
|
|
|
|
void mov_type_168(uint64_t uid, int u1)
|
|
{
|
|
//cout << "mov_type " << uid << " " << u1 << endl;
|
|
//cout << "dbg[var_ref] : " << vm_u[u1].var_ref[0].uid_value.size() << endl;
|
|
rc_free_type(&usr_var[uid]);
|
|
//usr_var[uid].uid_value.resize(1);
|
|
//cout << "dbg[usr_var]: " << usr_var[uid].uid_value.size() << endl;
|
|
usr_var[uid].uid_value.push_back(vm_u[u1]);
|
|
usr_var[uid].var_ref = &usr_var[uid];
|
|
usr_var[uid].var_ref_index = 0;
|
|
//cout << "mov_type end" << endl;
|
|
}
|
|
|
|
void push_t_169(int u1)
|
|
{
|
|
//cout << "push_t u" << u1 << " :: " << vm_u[u1].uid_value.size() << endl;
|
|
u_stack.push(vm_u[u1]);
|
|
//cout << "push_t end" << endl;
|
|
}
|
|
|
|
void push_t_170(uint64_t uid)
|
|
{
|
|
u_stack.push(usr_var[uid]);
|
|
}
|
|
|
|
void pop_t_171(int u1)
|
|
{
|
|
//cout << "pop_t u" << u1 << " :: " << vm_u[u1].uid_value.size() << endl;
|
|
rc_free_type(&vm_u[u1]);
|
|
vm_u[u1] = u_stack.top();
|
|
//cout << "test: " << vm_u[u1].var_ref->uid_value.size() << endl;
|
|
u_stack.pop();
|
|
}
|
|
|
|
void pop_t_172(uint64_t uid)
|
|
{
|
|
//cout << "pop_T USER" << endl;
|
|
rc_free_type(usr_var[uid].var_ref);
|
|
usr_var[uid].var_ref[0] = u_stack.top();
|
|
u_stack.pop();
|
|
}
|
|
|
|
void push_t_null_173()
|
|
{
|
|
//I will need to do something with this
|
|
}
|
|
|
|
void delete_t_174(uint64_t oid, uint64_t top_level_flag, uint64_t obj_type)
|
|
{
|
|
//cout << "DEBUG: " << oid << ", " << top_level_flag << ", " << obj_type << endl;
|
|
//cout << "Delete Object: " << usr_object.obj_ref->str_var[1].dim[0] << endl;
|
|
if(top_level_flag == 0)
|
|
{
|
|
//cout << "[START] USR TL: " << usr_var[oid].uid_value[0].str_var.size() << endl;
|
|
rc_free_type(&usr_var[oid]);
|
|
//cout << "[END] USR TL: " << usr_var[oid].uid_value[0].str_var.size() << endl;
|
|
}
|
|
else
|
|
{
|
|
switch(obj_type)
|
|
{
|
|
case 0:
|
|
//cout << "DBG NDATA: " << usr_object.obj_ref->num_var[oid].dim[0] << endl;
|
|
usr_object.obj_ref->num_var[oid].nid_value.value.clear();
|
|
usr_object.obj_ref->num_var[oid].nid_value.value.shrink_to_fit();
|
|
usr_object.obj_ref->num_var[oid].dimensions = 0;
|
|
usr_object.obj_ref->num_var[oid].dim[0] = 0;
|
|
usr_object.obj_ref->num_var[oid].dim[1] = 0;
|
|
usr_object.obj_ref->num_var[oid].dim[2] = 0;
|
|
break;
|
|
|
|
case 1:
|
|
//cout << "DBG SDATA: " << usr_object.obj_ref->str_var[oid].dim[0] << endl;
|
|
usr_object.obj_ref->str_var[oid].sid_value.value.clear();
|
|
usr_object.obj_ref->str_var[oid].sid_value.value.shrink_to_fit();
|
|
usr_object.obj_ref->str_var[oid].dimensions = 0;
|
|
usr_object.obj_ref->str_var[oid].dim[0] = 0;
|
|
usr_object.obj_ref->str_var[oid].dim[1] = 0;
|
|
usr_object.obj_ref->str_var[oid].dim[2] = 0;
|
|
break;
|
|
|
|
case 2:
|
|
//cout << "DBG UDATA: " << usr_object.obj_ref->uid_value[oid].dim[0] << endl;
|
|
rc_free_type(&usr_object.obj_ref->uid_value[oid]);
|
|
break;
|
|
}
|
|
}
|
|
//cout << "Done" << endl;
|
|
}
|
|
|
|
void dim_type_175(int u1, int udt_index)
|
|
{
|
|
rc_free_type(&vm_u[u1]);
|
|
rc_dim_type(&vm_u[u1], udt_index, 0, 0, 0, 0 );
|
|
}
|
|
|
|
void dim_type1_176(int u1, int udt_index, int n1)
|
|
{
|
|
rc_free_type(&vm_u[u1]);
|
|
rc_dim_type(&vm_u[u1], udt_index, 1, (uint64_t)vm_n[n1].value, 0, 0 );
|
|
}
|
|
|
|
void dim_type2_177(int u1, int udt_index, int n1, int n2)
|
|
{
|
|
rc_free_type(&vm_u[u1]);
|
|
rc_dim_type(&vm_u[u1], udt_index, 2, (uint64_t)vm_n[n1].value, (uint64_t)vm_n[n2].value, 0 );
|
|
}
|
|
|
|
void dim_type3_178(int u1, int udt_index, int n1, int n2, int n3)
|
|
{
|
|
rc_free_type(&vm_u[u1]);
|
|
rc_dim_type(&vm_u[u1], udt_index, 3, (uint64_t)vm_n[n1].value, (uint64_t)vm_n[n2].value, (uint64_t)vm_n[n3].value );
|
|
}
|
|
|
|
void dim_tfield_179(uint64_t udt_index, uint64_t field_type, uint64_t field_index, int num_dim, int n1, int n2, int n3)
|
|
{
|
|
//cout << "DimTField " << udt_index << " " << field_type << " " << field_index << " " << num_dim << " " << (uint64_t)vm_n[n1].value << " " << (uint64_t)vm_n[n2].value << " " << (uint64_t)vm_n[n3].value << endl;
|
|
rc_types[udt_index].field_dimensions[field_index] = num_dim;
|
|
rc_types[udt_index].field_size[field_index].dim[0] = (uint64_t)vm_n[n1].value;
|
|
rc_types[udt_index].field_size[field_index].dim[1] = (uint64_t)vm_n[n2].value;
|
|
rc_types[udt_index].field_size[field_index].dim[2] = (uint64_t)vm_n[n3].value;
|
|
//cout << "DimTField End" << endl;
|
|
}
|
|
|
|
void obj_usr_init_180(uint64_t uid)
|
|
{
|
|
//cout << "obj_usr_init " << uid << endl;
|
|
usr_object.index = 0;
|
|
|
|
usr_object.index += usr_var[uid].var_ref_index;
|
|
|
|
usr_object.obj_ref = &usr_var[uid].var_ref->uid_value[usr_object.index]; //need to switch to var_ref
|
|
//cout << "obj_usr_init done: " << usr_object.obj_ref[0].uid_value.size() << endl;
|
|
|
|
usr_object.obj_ref->byref_ptr = usr_var[uid].var_ref;
|
|
}
|
|
|
|
void obj_usr_init1_181(uint64_t uid, int n1)
|
|
{
|
|
//cout << "obj_usr_init1 " << uid << endl;
|
|
usr_object.index = (uint64_t)vm_n[n1].value;
|
|
|
|
usr_object.index += usr_var[uid].var_ref_index;
|
|
|
|
usr_object.obj_ref = &usr_var[uid].var_ref->uid_value[usr_object.index];
|
|
|
|
usr_object.obj_ref->byref_ptr = usr_var[uid].var_ref;
|
|
}
|
|
|
|
void obj_usr_init2_182(uint64_t uid, int n1, int n2)
|
|
{
|
|
//uint64_t d[3];
|
|
//d[0] = usr_var[uid].dim[0];
|
|
//d[1] = usr_var[uid].dim[1];
|
|
//d[2] = usr_var[uid].dim[2];
|
|
//cout << "obj_usr_init2: " << uid << " --dim=[" << d[0] << ", " << d[1] << ", " << d[2] << "]" << endl;
|
|
usr_object.index = (uint64_t)vm_n[n1].value * usr_var[uid].dim[1] + (uint64_t)vm_n[n2].value;
|
|
|
|
usr_object.index += usr_var[uid].var_ref_index;
|
|
|
|
usr_object.obj_ref = &usr_var[uid].var_ref->uid_value[usr_object.index];
|
|
|
|
usr_object.obj_ref->byref_ptr = usr_var[uid].var_ref;
|
|
|
|
//cout << "dimbr = " << uid << " " << n1 << " " << n2 << " " << usr_object.obj_ref->byref_ptr->dimensions << endl;
|
|
//cout << "d2_dbg = " << usr_var[uid].var_ref->uid_value.size() << " --- " << usr_object.index << endl;
|
|
}
|
|
|
|
void obj_usr_init3_183(uint64_t uid, int n1, int n2, int n3)
|
|
{
|
|
//cout << "obj_usr_init3 " << uid << endl;
|
|
usr_object.index = ( (uint64_t)vm_n[n1].value * usr_var[uid].dim[1] * usr_var[uid].dim[2] ) + ((uint64_t)vm_n[n2].value * usr_var[uid].dim[2]) + (uint64_t)vm_n[n3].value;;
|
|
|
|
usr_object.index += usr_var[uid].var_ref_index;
|
|
|
|
usr_object.obj_ref = &usr_var[uid].var_ref->uid_value[usr_object.index];
|
|
|
|
usr_object.obj_ref->byref_ptr = usr_var[uid].var_ref;
|
|
}
|
|
|
|
|
|
void obj_usr_init_184(int u1)
|
|
{
|
|
//cout << "obj_usr_init u" << u1 << endl;
|
|
usr_object.index = 0;
|
|
usr_object.obj_ref = &vm_u[u1]; //need to switch to var_ref
|
|
usr_object.obj_ref->var_ref = usr_object.obj_ref;
|
|
//cout << "obj_usr_init done: " << usr_object.obj_ref->var_ref[0].uid_value.size() << " ~ " << vm_u[u1].uid_value.size() << endl;
|
|
}
|
|
|
|
void obj_usr_init1_185(int u1, int n1)
|
|
{
|
|
//cout << "obj_usr_init1 u" << u1 << endl;
|
|
usr_object.index = (uint64_t)vm_n[n1].value;
|
|
usr_object.obj_ref = &vm_u[u1].var_ref->uid_value[usr_object.index];
|
|
}
|
|
|
|
void obj_usr_init2_186(int u1, int n1, int n2)
|
|
{
|
|
uint64_t d[3];
|
|
//cout << "obj_usr_init2: u" << u1 << " --dim=[" << d[0] << ", " << d[1] << ", " << d[2] << "]" << endl;
|
|
usr_object.index = (uint64_t)vm_n[n1].value * vm_u[u1].dim[1] + (uint64_t)vm_n[n2].value;
|
|
usr_object.obj_ref = &vm_u[u1].var_ref->uid_value[usr_object.index];
|
|
}
|
|
|
|
void obj_usr_init3_187(int u1, int n1, int n2, int n3)
|
|
{
|
|
//cout << "obj_usr_init3 u" << u1 << endl;
|
|
usr_object.index = ( (uint64_t)vm_n[n1].value * vm_u[u1].dim[1] * vm_u[u1].dim[2] ) + ((uint64_t)vm_n[n2].value * vm_u[u1].dim[2]) + (uint64_t)vm_n[n3].value;;
|
|
usr_object.obj_ref = &vm_u[u1].var_ref->uid_value[usr_object.index];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool rc_preset_type(rc_usrId* parent)
|
|
{
|
|
uint64_t dim_size = parent->uid_value.size();
|
|
|
|
|
|
rc_usrId* p_obj;
|
|
|
|
uint64_t field_size = 0;
|
|
|
|
for(uint64_t i = 0; i < dim_size; i++)
|
|
{
|
|
p_obj = &parent->uid_value[i];
|
|
|
|
for(uint64_t n_field = 0; n_field < p_obj->num_var.size(); n_field++)
|
|
{
|
|
for(uint64_t nv = 0; nv < p_obj->num_var[n_field].nid_value.value.size(); nv++)
|
|
p_obj->num_var[n_field].nid_value.value[nv] = 0;
|
|
}
|
|
|
|
for(uint64_t s_field = 0; s_field < p_obj->str_var.size(); s_field++)
|
|
{
|
|
for(uint64_t sv = 0; sv < p_obj->str_var[s_field].sid_value.value.size(); sv++)
|
|
p_obj->str_var[s_field].sid_value.value[sv] = "";
|
|
}
|
|
|
|
for(uint64_t u_field = 0; u_field < p_obj->uid_value.size(); u_field++)
|
|
{
|
|
rc_preset_type(&p_obj->uid_value[u_field]);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void preset_t_188(uint64_t uid, uint64_t utype)
|
|
{
|
|
//cout << "T0" << endl;
|
|
if(!usr_var[uid].preset_init)
|
|
{
|
|
rc_free_type(&usr_var[uid]);
|
|
dim_type_90(uid, utype);
|
|
usr_var[uid].preset_init = true;
|
|
}
|
|
else
|
|
{
|
|
rc_preset_type(&usr_var[uid]);
|
|
}
|
|
}
|
|
|
|
void preset_t1_189(uint64_t uid, uint64_t utype, int n1)
|
|
{
|
|
//cout << "T1" << endl;
|
|
if(!usr_var[uid].preset_init)
|
|
{
|
|
rc_free_type(&usr_var[uid]);
|
|
dim_type1_91(uid, utype, n1);
|
|
usr_var[uid].preset_init = true;
|
|
}
|
|
else
|
|
{
|
|
rc_preset_type(&usr_var[uid]);
|
|
}
|
|
}
|
|
|
|
void preset_t2_190(uint64_t uid, uint64_t utype, int n1, int n2)
|
|
{
|
|
//cout << "T2" << endl;
|
|
if(!usr_var[uid].preset_init)
|
|
{
|
|
rc_free_type(&usr_var[uid]);
|
|
dim_type2_92(uid, utype, n1, n2);
|
|
usr_var[uid].preset_init = true;
|
|
}
|
|
else
|
|
{
|
|
rc_preset_type(&usr_var[uid]);
|
|
}
|
|
}
|
|
|
|
void preset_t3_191(uint64_t uid, uint64_t utype, int n1, int n2, int n3)
|
|
{
|
|
//cout << "T3" << endl;
|
|
if(!usr_var[uid].preset_init)
|
|
{
|
|
rc_free_type(&usr_var[uid]);
|
|
dim_type3_93(uid, utype, n1, n2, n3);
|
|
usr_var[uid].preset_init = true;
|
|
}
|
|
else
|
|
{
|
|
rc_preset_type(&usr_var[uid]);
|
|
}
|
|
}
|
|
|
|
|
|
void redim_type_192(int u1, int udt_index)
|
|
{
|
|
// Currently unused
|
|
}
|
|
|
|
void redim_type1_193(int u1, int udt_index, int n1)
|
|
{
|
|
// Currently unused
|
|
}
|
|
|
|
void redim_type2_194(int u1, int udt_index, int n1, int n2)
|
|
{
|
|
// Currently unused
|
|
}
|
|
|
|
void redim_type3_195(int u1, int udt_index, int n1, int n2, int n3)
|
|
{
|
|
// Currently unused
|
|
}
|
|
|
|
|
|
void redim_type_n_196(uint64_t nid)
|
|
{
|
|
usr_object.obj_ref->num_var[nid].nid_value.value.resize(1);
|
|
usr_object.obj_ref->num_var[nid].dimensions = 0;
|
|
usr_object.obj_ref->num_var[nid].dim[0] = 0;
|
|
usr_object.obj_ref->num_var[nid].dim[1] = 0;
|
|
usr_object.obj_ref->num_var[nid].dim[2] = 0;
|
|
}
|
|
|
|
void redim_type_n1_197(uint64_t nid, int n1)
|
|
{
|
|
usr_object.obj_ref->num_var[nid].nid_value.value.resize((uint64_t)vm_n[n1].value);
|
|
usr_object.obj_ref->num_var[nid].dimensions = 1;
|
|
usr_object.obj_ref->num_var[nid].dim[0] = (uint64_t)vm_n[n1].value;
|
|
usr_object.obj_ref->num_var[nid].dim[1] = 0;
|
|
usr_object.obj_ref->num_var[nid].dim[2] = 0;
|
|
}
|
|
|
|
void redim_type_n2_198(uint64_t nid, int n1, int n2)
|
|
{
|
|
usr_object.obj_ref->num_var[nid].nid_value.value.resize((uint64_t)(vm_n[n1].value * vm_n[n2].value));
|
|
usr_object.obj_ref->num_var[nid].dimensions = 2;
|
|
usr_object.obj_ref->num_var[nid].dim[0] = (uint64_t)vm_n[n1].value;
|
|
usr_object.obj_ref->num_var[nid].dim[1] = (uint64_t)vm_n[n2].value;
|
|
usr_object.obj_ref->num_var[nid].dim[2] = 0;
|
|
}
|
|
|
|
void redim_type_n3_199(uint64_t nid, int n1, int n2, int n3)
|
|
{
|
|
usr_object.obj_ref->num_var[nid].nid_value.value.resize((uint64_t)(vm_n[n1].value * vm_n[n2].value * vm_n[n3].value));
|
|
usr_object.obj_ref->num_var[nid].dimensions = 3;
|
|
usr_object.obj_ref->num_var[nid].dim[0] = (uint64_t)vm_n[n1].value;
|
|
usr_object.obj_ref->num_var[nid].dim[1] = (uint64_t)vm_n[n2].value;
|
|
usr_object.obj_ref->num_var[nid].dim[2] = (uint64_t)vm_n[n3].value;
|
|
}
|
|
|
|
|
|
void redim_type_s_200(uint64_t sid)
|
|
{
|
|
usr_object.obj_ref->str_var[sid].sid_value.value.resize(1);
|
|
usr_object.obj_ref->str_var[sid].dimensions = 0;
|
|
usr_object.obj_ref->str_var[sid].dim[0] = 0;
|
|
usr_object.obj_ref->str_var[sid].dim[1] = 0;
|
|
usr_object.obj_ref->str_var[sid].dim[2] = 0;
|
|
}
|
|
|
|
void redim_type_s1_201(uint64_t sid, int n1)
|
|
{
|
|
usr_object.obj_ref->str_var[sid].sid_value.value.resize((uint64_t)vm_n[n1].value);
|
|
usr_object.obj_ref->str_var[sid].dimensions = 1;
|
|
usr_object.obj_ref->str_var[sid].dim[0] = (uint64_t)vm_n[n1].value;
|
|
usr_object.obj_ref->str_var[sid].dim[1] = 0;
|
|
usr_object.obj_ref->str_var[sid].dim[2] = 0;
|
|
}
|
|
|
|
void redim_type_s2_202(uint64_t sid, int n1, int n2)
|
|
{
|
|
usr_object.obj_ref->str_var[sid].sid_value.value.resize((uint64_t)(vm_n[n1].value * vm_n[n2].value));
|
|
usr_object.obj_ref->str_var[sid].dimensions = 2;
|
|
usr_object.obj_ref->str_var[sid].dim[0] = (uint64_t)vm_n[n1].value;
|
|
usr_object.obj_ref->str_var[sid].dim[1] = (uint64_t)vm_n[n2].value;
|
|
usr_object.obj_ref->str_var[sid].dim[2] = 0;
|
|
}
|
|
|
|
void redim_type_s3_203(uint64_t sid, int n1, int n2, int n3)
|
|
{
|
|
usr_object.obj_ref->str_var[sid].sid_value.value.resize((uint64_t)(vm_n[n1].value * vm_n[n2].value * vm_n[n3].value));
|
|
usr_object.obj_ref->str_var[sid].dimensions = 3;
|
|
usr_object.obj_ref->str_var[sid].dim[0] = (uint64_t)vm_n[n1].value;
|
|
usr_object.obj_ref->str_var[sid].dim[1] = (uint64_t)vm_n[n2].value;
|
|
usr_object.obj_ref->str_var[sid].dim[2] = (uint64_t)vm_n[n3].value;
|
|
}
|
|
|
|
void redim_type_204(uint64_t uid, int udt_index)
|
|
{
|
|
if(redim_toplevel_flag)
|
|
rc_dim_type(&usr_var[uid], udt_index, 0, 0, 0, 0, 0);
|
|
else
|
|
rc_dim_type(&usr_object.obj_ref->uid_value[uid], udt_index, 0, 0, 0, 0, 0);
|
|
|
|
redim_toplevel_flag = false;
|
|
}
|
|
|
|
void redim_type1_205(uint64_t uid, int udt_index, int n1)
|
|
{
|
|
if(redim_toplevel_flag)
|
|
rc_dim_type(&usr_var[uid], udt_index, 1, (uint64_t)vm_n[n1].value, 0, 0, usr_var[uid].uid_value.size());
|
|
else
|
|
rc_dim_type(&usr_object.obj_ref->uid_value[uid], udt_index, 1, (uint64_t)vm_n[n1].value, 0, 0, usr_object.obj_ref->uid_value[uid].uid_value.size());
|
|
|
|
redim_toplevel_flag = false;
|
|
}
|
|
|
|
void redim_type2_206(uint64_t uid, int udt_index, int n1, int n2)
|
|
{
|
|
if(redim_toplevel_flag)
|
|
rc_dim_type(&usr_var[uid], udt_index, 2, (uint64_t)vm_n[n1].value, (uint64_t)vm_n[n2].value, 0, usr_var[uid].uid_value.size());
|
|
else
|
|
rc_dim_type(&usr_object.obj_ref->uid_value[uid], udt_index, 2, (uint64_t)vm_n[n1].value, (uint64_t)vm_n[n2].value, 0, usr_object.obj_ref->uid_value[uid].uid_value.size());
|
|
|
|
//cout << "test tl: " << redim_toplevel_flag << " -- " << usr_var[uid].uid_value.size() << endl;
|
|
|
|
redim_toplevel_flag = false;
|
|
}
|
|
|
|
void redim_type3_207(uint64_t uid, int udt_index, int n1, int n2, int n3)
|
|
{
|
|
if(redim_toplevel_flag)
|
|
rc_dim_type(&usr_var[uid], udt_index, 3, (uint64_t)vm_n[n1].value, (uint64_t)vm_n[n2].value, (uint64_t)vm_n[n3].value, usr_var[uid].uid_value.size());
|
|
else
|
|
rc_dim_type(&usr_object.obj_ref->uid_value[uid], udt_index, 3, (uint64_t)vm_n[n1].value, (uint64_t)vm_n[n2].value, (uint64_t)vm_n[n3].value, usr_object.obj_ref->uid_value[uid].uid_value.size());
|
|
|
|
redim_toplevel_flag = false;
|
|
}
|
|
|
|
void redim_top_208()
|
|
{
|
|
redim_toplevel_flag = true;
|
|
}
|
|
|
|
|
|
bool rcbasic_run()
|
|
{
|
|
unsigned char rcbasic_cmd;
|
|
double d[12];
|
|
uint64_t i[12];
|
|
bool end_of_program = false;
|
|
while(!end_of_program)
|
|
{
|
|
#ifdef RCBASIC_DEBUG
|
|
if(dbg_error_found)
|
|
{
|
|
output_debug_message();
|
|
break;
|
|
}
|
|
#endif // RCBASIC_DEBUG
|
|
|
|
rcbasic_cmd = segment[current_segment][current_address];
|
|
current_address++;
|
|
|
|
//cout << "n3 = " << vm_n[3].value << endl;
|
|
//cout << "x = " << num_var[0].value[0] << endl;
|
|
//cout << "\ncmd = " << (int)rcbasic_cmd << endl;
|
|
|
|
switch(rcbasic_cmd)
|
|
{
|
|
case 0:
|
|
end_of_program = true;
|
|
rcbasic_exit_code = 0;
|
|
break;
|
|
case 1:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
dbg_1(i[0], i[1], i[2]);
|
|
break;
|
|
case 32:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
mov_32(i[0], i[1]);
|
|
break;
|
|
case 33:
|
|
i[0] = readInt();
|
|
d[0] = readDouble();
|
|
mov_33(i[0], d[0]);
|
|
break;
|
|
case 34:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
mov_34(i[0], i[1]);
|
|
break;
|
|
case 35:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
//cout << "mov_35 x is " << i[0] << endl;
|
|
//cout << "mov_35 is using n" << i[1] << endl;
|
|
mov_35(i[0], i[1]);
|
|
break;
|
|
case 36:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
movS_36(i[0], i[1]);
|
|
break;
|
|
case 37:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
movS_37(i[0], i[1]);
|
|
break;
|
|
case 38:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
movS_38(i[0], i[1]);
|
|
break;
|
|
case 39:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
movS_39(i[0], i[1]);
|
|
break;
|
|
case 40:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
mov_r_40(i[0], i[1]);
|
|
break;
|
|
case 41:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
mov_rS_41(i[0], i[1]);
|
|
break;
|
|
case 42:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
mov_type_42(i[0], i[1]);
|
|
break;
|
|
case 43:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
addS_43(i[0], i[1]);
|
|
break;
|
|
case 44:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
add_44(i[0], i[1]);
|
|
break;
|
|
case 45:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
sub_45(i[0], i[1]);
|
|
break;
|
|
case 46:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
mul_46(i[0], i[1]);
|
|
break;
|
|
case 47:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
div_47(i[0], i[1]);
|
|
break;
|
|
case 48:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
pow_48(i[0], i[1]);
|
|
break;
|
|
case 49:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
mod_49(i[0], i[1]);
|
|
break;
|
|
case 50:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
shl_50(i[0], i[1]);
|
|
break;
|
|
case 51:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
shr_51(i[0], i[1]);
|
|
break;
|
|
case 52:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
and_52(i[0], i[1]);
|
|
break;
|
|
case 53:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
or_53(i[0], i[1]);
|
|
break;
|
|
case 54:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
xor_54(i[0], i[1]);
|
|
break;
|
|
case 55:
|
|
i[0] = readInt();
|
|
not_55(i[0]);
|
|
break;
|
|
case 56:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
cmp_56(i[0], i[1]);
|
|
break;
|
|
case 57:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
cmpS_57(i[0], i[1]);
|
|
break;
|
|
case 58:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
cmp_u_58(i[0], i[1]);
|
|
break;
|
|
case 59:
|
|
i[0] = readInt();
|
|
jmp_59(i[0]);
|
|
break;
|
|
case 60:
|
|
i[0] = readInt();
|
|
jmp_60(i[0]);
|
|
break;
|
|
case 61:
|
|
i[0] = readInt();
|
|
je_61(i[0]);
|
|
break;
|
|
case 62:
|
|
i[0] = readInt();
|
|
je_62(i[0]);
|
|
break;
|
|
case 63:
|
|
i[0] = readInt();
|
|
jne_63(i[0]);
|
|
break;
|
|
case 64:
|
|
i[0] = readInt();
|
|
jne_64(i[0]);
|
|
break;
|
|
case 65:
|
|
i[0] = readInt();
|
|
jg_65(i[0]);
|
|
break;
|
|
case 66:
|
|
i[0] = readInt();
|
|
jg_66(i[0]);
|
|
break;
|
|
case 67:
|
|
i[0] = readInt();
|
|
jge_67(i[0]);
|
|
break;
|
|
case 68:
|
|
i[0] = readInt();
|
|
jge_68(i[0]);
|
|
break;
|
|
case 69:
|
|
i[0] = readInt();
|
|
jl_69(i[0]);
|
|
break;
|
|
case 70:
|
|
i[0] = readInt();
|
|
jl_70(i[0]);
|
|
break;
|
|
case 71:
|
|
i[0] = readInt();
|
|
jle_71(i[0]);
|
|
break;
|
|
case 72:
|
|
i[0] = readInt();
|
|
jle_72(i[0]);
|
|
break;
|
|
case 73:
|
|
i[0] = readInt();
|
|
obj_num_73(i[0]);
|
|
break;
|
|
case 74:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
obj_num1_74(i[0], i[1]);
|
|
break;
|
|
case 75:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
obj_num2_75(i[0], i[1], i[2]);
|
|
break;
|
|
case 76:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
obj_num3_76(i[0], i[1], i[2], i[3]);
|
|
break;
|
|
case 77:
|
|
i[0] = readInt();
|
|
obj_str_77(i[0]);
|
|
break;
|
|
case 78:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
obj_str1_78(i[0], i[1]);
|
|
break;
|
|
case 79:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
obj_str2_79(i[0], i[1], i[2]);
|
|
break;
|
|
case 80:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
obj_str3_80(i[0], i[1], i[2], i[3]);
|
|
break;
|
|
case 81:
|
|
i[0] = readInt();
|
|
obj_usr_81(i[0]);
|
|
break;
|
|
case 82:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
obj_usr1_82(i[0], i[1]);
|
|
break;
|
|
case 83:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
obj_usr2_83(i[0], i[1], i[2]);
|
|
break;
|
|
case 84:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
obj_usr3_84(i[0], i[1], i[2], i[3]);
|
|
break;
|
|
case 85:
|
|
i[0] = readInt();
|
|
obj_get_85(i[0]);
|
|
break;
|
|
case 86:
|
|
i[0] = readInt();
|
|
obj_getS_86(i[0]);
|
|
break;
|
|
case 87:
|
|
i[0] = readInt();
|
|
obj_set_87(i[0]);
|
|
break;
|
|
case 88:
|
|
i[0] = readInt();
|
|
obj_setS_88(i[0]);
|
|
break;
|
|
case 89:
|
|
clear_obj_89();
|
|
break;
|
|
case 90:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
dim_type_90(i[0], i[1]);
|
|
break;
|
|
case 91:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
dim_type1_91(i[0], i[1], i[2]);
|
|
break;
|
|
case 92:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
dim_type2_92(i[0], i[1], i[2], i[3]);
|
|
break;
|
|
case 93:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
i[4] = readInt();
|
|
dim_type3_93(i[0], i[1], i[2], i[3], i[4]);
|
|
break;
|
|
case 94:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
dim_num1_94(i[0], i[1]);
|
|
break;
|
|
case 95:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
dim_num2_95(i[0], i[1], i[2]);
|
|
break;
|
|
case 96:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
dim_num3_96(i[0], i[1], i[2], i[3]);
|
|
break;
|
|
case 97:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
dim_str1_97(i[0], i[1]);
|
|
break;
|
|
case 98:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
dim_str2_98(i[0], i[1], i[2]);
|
|
break;
|
|
case 99:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
dim_str3_99(i[0], i[1], i[2], i[3]);
|
|
break;
|
|
case 100:
|
|
i[0] = readInt();
|
|
delete_100(i[0]);
|
|
break;
|
|
case 101:
|
|
i[0] = readInt();
|
|
deleteS_101(i[0]);
|
|
break;
|
|
case 102:
|
|
i[0] = readInt();
|
|
push_102(i[0]);
|
|
break;
|
|
case 103:
|
|
i[0] = readInt();
|
|
push_103(i[0]);
|
|
break;
|
|
case 104:
|
|
i[0] = readInt();
|
|
pushS_104(i[0]);
|
|
break;
|
|
case 105:
|
|
i[0] = readInt();
|
|
pushS_105(i[0]);
|
|
break;
|
|
case 106:
|
|
push_emptyS_106();
|
|
break;
|
|
case 107:
|
|
i[0] = readInt();
|
|
pop_107(i[0]);
|
|
break;
|
|
case 108:
|
|
i[0] = readInt();
|
|
pop_108(i[0]);
|
|
break;
|
|
case 109:
|
|
i[0] = readInt();
|
|
popS_109(i[0]);
|
|
break;
|
|
case 110:
|
|
i[0] = readInt();
|
|
popS_110(i[0]);
|
|
break;
|
|
case 111:
|
|
i[0] = readInt();
|
|
get_stack_size_111(i[0]);
|
|
break;
|
|
case 112:
|
|
i[0] = readInt();
|
|
get_stack_sizeS_112(i[0]);
|
|
break;
|
|
case 113:
|
|
clear_stack_113();
|
|
break;
|
|
case 114:
|
|
clear_stackS_114();
|
|
break;
|
|
case 115:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
while_115(i[0], i[1]);
|
|
break;
|
|
case 116:
|
|
i[0] = readInt();
|
|
wend_116(i[0]);
|
|
break;
|
|
case 117:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
//cout << "step = " << vm_n[i[3]].value << endl;
|
|
//cout << "for counter = " << vm_n[i[1]].value << " to " << vm_n[i[2]].value << " step " << vm_n[i[3]].value << endl;
|
|
for_117(i[0], i[1], i[2], i[3]);
|
|
//cout << "for info: " << current_segment << " " << current_address << endl << endl;
|
|
//cout << "for counter = " << vm_n[i[1]].value << " to " << vm_n[i[2]].value << " step " << vm_n[i[3]].value << endl;
|
|
break;
|
|
case 118:
|
|
i[0] = readInt();
|
|
next_118(i[0]);
|
|
//cout << endl << "next to: " << i[0] << endl;
|
|
break;
|
|
case 119:
|
|
//do not really needed, so
|
|
break;
|
|
case 120:
|
|
i[0] = readInt();
|
|
loop_120(i[0]);
|
|
break;
|
|
case 121:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
loop_while_121(i[0], i[1]);
|
|
break;
|
|
case 122:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
loop_until_122(i[0], i[1]);
|
|
break;
|
|
case 123:
|
|
pop_loop_stack_123();
|
|
break;
|
|
case 124:
|
|
i[0] = readInt();
|
|
gosub_124(i[0]);
|
|
break;
|
|
case 125:
|
|
return_125();
|
|
break;
|
|
case 126:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
ptr_126(i[0], i[1]);
|
|
break;
|
|
case 127:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
ptrS_127(i[0], i[1]);
|
|
break;
|
|
case 128:
|
|
i[0] = readInt();
|
|
print_128(i[0]);
|
|
break;
|
|
case 129:
|
|
i[0] = readInt();
|
|
printS_129(i[0]);
|
|
break;
|
|
case 130:
|
|
i[0] = readInt();
|
|
//cout << "func " << i[0] << endl;
|
|
func_130(i[0]);
|
|
break;
|
|
case 131:
|
|
d[0] = readDouble();
|
|
push_131(d[0]);
|
|
break;
|
|
case 132:
|
|
println_132();
|
|
break;
|
|
case 133:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
mov_133(i[0], i[1]);
|
|
break;
|
|
case 134:
|
|
i[0] = readInt();
|
|
d[0] = readDouble();
|
|
cmp_134(i[0], d[0]);
|
|
break;
|
|
case 135:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
mov_arr_135(i[0], i[1]);
|
|
break;
|
|
case 136:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
mov_arrS_136(i[0], i[1]);
|
|
break;
|
|
case 137:
|
|
i[0] = readInt();
|
|
pop_ptr_137(i[0]);
|
|
break;
|
|
case 138:
|
|
i[0] = readInt();
|
|
preset_138(i[0]);
|
|
break;
|
|
case 139:
|
|
i[0] = readInt();
|
|
presetS_139(i[0]);
|
|
break;
|
|
case 140:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
redim_140(i[0], i[1]);
|
|
break;
|
|
case 141:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
redim_141(i[0], i[1], i[2]);
|
|
break;
|
|
case 142:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
redim_142(i[0], i[1], i[2], i[3]);
|
|
break;
|
|
case 143:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
redimS_143(i[0], i[1]);
|
|
break;
|
|
case 144:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
redimS_144(i[0], i[1], i[2]);
|
|
break;
|
|
case 145:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
redimS_145(i[0], i[1], i[2], i[3]);
|
|
break;
|
|
case 146:
|
|
i[0] = readInt();
|
|
for_offset_arr1_146(i[0]);
|
|
break;
|
|
case 147:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
for_offset_arr2_147(i[0], i[1]);
|
|
break;
|
|
case 148:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
for_offset_arr3_148(i[0], i[1], i[2]);
|
|
break;
|
|
case 149:
|
|
for_offset_0_149();
|
|
break;
|
|
case 150:
|
|
i[0] = readInt();
|
|
end_x_150(i[0]);
|
|
end_of_program = true;
|
|
break;
|
|
case 151:
|
|
//lval
|
|
break;
|
|
case 152:
|
|
//lval
|
|
break;
|
|
case 153:
|
|
//lval
|
|
break;
|
|
case 154:
|
|
//lval
|
|
break;
|
|
case 155:
|
|
//lval
|
|
break;
|
|
case 156:
|
|
i[0] = readInt();
|
|
obj_usr_n_156(i[0]);
|
|
break;
|
|
case 157:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
obj_usr_n1_157(i[0], i[1]);
|
|
break;
|
|
case 158:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
obj_usr_n2_158(i[0], i[1], i[2]);
|
|
break;
|
|
case 159:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
obj_usr_n3_159(i[0], i[1], i[2], i[3]);
|
|
break;
|
|
case 160:
|
|
i[0] = readInt();
|
|
obj_usr_s_160(i[0]);
|
|
break;
|
|
case 161:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
obj_usr_s1_161(i[0], i[1]);
|
|
break;
|
|
case 162:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
obj_usr_s2_162(i[0], i[1], i[2]);
|
|
break;
|
|
case 163:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
obj_usr_s3_163(i[0], i[1], i[2], i[3]);
|
|
break;
|
|
case 164:
|
|
i[0] = readInt();
|
|
obj_usr_get_164(i[0]);
|
|
break;
|
|
case 165:
|
|
i[0] = readInt();
|
|
obj_usr_get_165(i[0]);
|
|
break;
|
|
case 166:
|
|
i[0] = readInt();
|
|
obj_usr_get_166(i[0]);
|
|
break;
|
|
case 167:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
uref_ptr_167(i[0], i[1]);
|
|
break;
|
|
case 168:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
mov_type_168(i[0], i[1]);
|
|
break;
|
|
case 169:
|
|
i[0] = readInt();
|
|
push_t_169(i[0]);
|
|
break;
|
|
case 170:
|
|
i[0] = readInt();
|
|
push_t_170(i[0]);
|
|
break;
|
|
case 171:
|
|
i[0] = readInt();
|
|
pop_t_171(i[0]);
|
|
break;
|
|
case 172:
|
|
i[0] = readInt();
|
|
pop_t_172(i[0]);
|
|
break;
|
|
case 173:
|
|
push_t_null_173();
|
|
break;
|
|
case 174:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
delete_t_174(i[0], i[1], i[2]);
|
|
break;
|
|
case 175:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
dim_type_175(i[0], i[1]);
|
|
break;
|
|
case 176:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
dim_type1_176(i[0], i[1], i[2]);
|
|
break;
|
|
case 177:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
dim_type2_177(i[0], i[1], i[2], i[3]);
|
|
break;
|
|
case 178:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
i[4] = readInt();
|
|
dim_type3_178(i[0], i[1], i[2], i[3], i[4]);
|
|
break;
|
|
case 179:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
i[4] = readInt();
|
|
i[5] = readInt();
|
|
i[6] = readInt();
|
|
dim_tfield_179(i[0], i[1], i[2], i[3], i[4], i[5], i[6]);
|
|
break;
|
|
case 180:
|
|
i[0] = readInt();
|
|
obj_usr_init_180(i[0]);
|
|
break;
|
|
case 181:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
obj_usr_init1_181(i[0], i[1]);
|
|
break;
|
|
case 182:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
obj_usr_init2_182(i[0], i[1], i[2]);
|
|
break;
|
|
case 183:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
obj_usr_init3_183(i[0], i[1], i[2], i[3]);
|
|
break;
|
|
case 184:
|
|
i[0] = readInt();
|
|
obj_usr_init_184(i[0]);
|
|
break;
|
|
case 185:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
obj_usr_init1_185(i[0], i[1]);
|
|
break;
|
|
case 186:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
obj_usr_init2_186(i[0], i[1], i[2]);
|
|
break;
|
|
case 187:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
obj_usr_init3_187(i[0], i[1], i[2], i[3]);
|
|
break;
|
|
case 188:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
preset_t_188(i[0], i[1]);
|
|
break;
|
|
case 189:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
preset_t1_189(i[0], i[1], i[2]);
|
|
break;
|
|
case 190:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
preset_t2_190(i[0], i[1], i[2], i[3]);
|
|
break;
|
|
case 191:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
i[4] = readInt();
|
|
preset_t3_191(i[0], i[1], i[2], i[3], i[4]);
|
|
break;
|
|
case 192:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
redim_type_192(i[0], i[1]);
|
|
break;
|
|
case 193:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
redim_type1_193(i[0], i[1], i[2]);
|
|
break;
|
|
case 194:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
redim_type2_194(i[0], i[1], i[2], i[3]);
|
|
break;
|
|
case 195:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
i[4] = readInt();
|
|
redim_type3_195(i[0], i[1], i[2], i[3], i[4]);
|
|
break;
|
|
case 196:
|
|
i[0] = readInt();
|
|
redim_type_n_196(i[0]);
|
|
break;
|
|
case 197:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
redim_type_n1_197(i[0], i[1]);
|
|
break;
|
|
case 198:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
redim_type_n2_198(i[0], i[1], i[2]);
|
|
break;
|
|
case 199:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
redim_type_n3_199(i[0], i[1], i[2], i[3]);
|
|
break;
|
|
case 200:
|
|
i[0] = readInt();
|
|
redim_type_s_200(i[0]);
|
|
break;
|
|
case 201:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
redim_type_s1_201(i[0], i[1]);
|
|
break;
|
|
case 202:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
redim_type_s2_202(i[0], i[1], i[2]);
|
|
break;
|
|
case 203:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
redim_type_s3_203(i[0], i[1], i[2], i[3]);
|
|
break;
|
|
case 204:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
redim_type_204(i[0], i[1]);
|
|
break;
|
|
case 205:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
redim_type1_205(i[0], i[1], i[2]);
|
|
break;
|
|
case 206:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
redim_type2_206(i[0], i[1], i[2], i[3]);
|
|
break;
|
|
case 207:
|
|
i[0] = readInt();
|
|
i[1] = readInt();
|
|
i[2] = readInt();
|
|
i[3] = readInt();
|
|
i[4] = readInt();
|
|
redim_type3_207(i[0], i[1], i[2], i[3], i[4]);
|
|
break;
|
|
case 208:
|
|
redim_top_208();
|
|
break;
|
|
default:
|
|
cout << "invalid cmd: " << rcbasic_cmd << endl;
|
|
rcbasic_exit_code = 1;
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void rcbasic_init()
|
|
{
|
|
for(int i = 0; i < RC_MAX_FILES; i++)
|
|
rc_fstream[i] = NULL;
|
|
rc_media_init();
|
|
arr_ref_id.clear();
|
|
}
|
|
|
|
void rcbasic_clean()
|
|
{
|
|
rc_media_quit();
|
|
byref_addr_table.empty();
|
|
loop_stack.empty();
|
|
n_stack.empty();
|
|
s_stack.empty();
|
|
gosub_return_addr.empty();
|
|
}
|
|
|
|
void rcbasic_test()
|
|
{
|
|
SDL_Init(SDL_INIT_EVERYTHING);
|
|
|
|
SDL_Window * win = SDL_CreateWindow("test", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 480, SDL_WINDOW_SHOWN);
|
|
SDL_Renderer * ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE | SDL_RENDERER_PRESENTVSYNC);
|
|
SDL_Rect src;
|
|
src.x = 50;
|
|
src.y = 50;
|
|
src.w = 100;
|
|
src.h = 100;
|
|
SDL_SetRenderDrawColor(ren, 255, 0, 0, 255);
|
|
SDL_RenderFillRect(ren, &src);
|
|
SDL_RenderPresent(ren);
|
|
SDL_Delay(5000);
|
|
SDL_DestroyRenderer(ren);
|
|
SDL_DestroyWindow(win);
|
|
}
|
|
|
|
int main(int argc, char * argv[])
|
|
{
|
|
//rcbasic_test();
|
|
//return 0;
|
|
|
|
if(argc > 0)
|
|
rcbasic_runtime_path = argv[0];
|
|
|
|
//cout << "RCBASIC RUNTIME START" << endl;
|
|
#ifdef RC_WINDOWS
|
|
TCHAR buf[MAX_PATH];
|
|
GetCurrentDirectory(MAX_PATH, buf);
|
|
rc_dir_path = buf;
|
|
SetConsoleOutputCP(CP_UTF8);
|
|
SetConsoleCP(CP_UTF8);
|
|
#else
|
|
#ifdef RC_GETCWD
|
|
char buf[2048];
|
|
getcwd(buf, 2048);
|
|
rc_dir_path = (string)buf;
|
|
#else
|
|
rc_dir_path = get_current_dir_name();
|
|
#endif
|
|
#endif // RC_WINDOWS
|
|
|
|
string rc_filename = "main.cbc";
|
|
|
|
if(argc > 1)
|
|
rc_filename = argv[1];
|
|
else
|
|
#ifdef RC_WINDOWS
|
|
{
|
|
//rc_filename = argv[0];
|
|
//rc_filename = rc_filename.substr(0, rc_filename.length()-3) + "cbc";
|
|
}
|
|
#else
|
|
{
|
|
//rc_filename = argv[0];
|
|
//rc_filename += ".cbc";
|
|
}
|
|
#endif // RC_WINDOWS
|
|
|
|
if(rc_filename.compare("--version")==0)
|
|
{
|
|
cout << "RCBASIC Runtime v4.0a" << endl;
|
|
return 0;
|
|
}
|
|
|
|
#ifdef RCBASIC_DEBUG
|
|
rc_filename = "debug.cbc";
|
|
#endif // RCBASIC_DEBUG
|
|
|
|
//DEBUG START
|
|
//rc_filename = "/home/n00b/Projects/RCBASIC3/rcbasic_build/tst.cbc";
|
|
//DEBUG END
|
|
|
|
if(argc >1)
|
|
{
|
|
rc_cmd_count = argc - 1;
|
|
rc_cmd_args = new string[rc_cmd_count];
|
|
for(int i = 1; i < argc; i++)
|
|
rc_cmd_args[i-1] = argv[i];
|
|
}
|
|
|
|
rcbasic_init();
|
|
rc_initSubprocessSystem();
|
|
|
|
if(rc_filename.length()>=4)
|
|
{
|
|
if(rc_filename.substr(rc_filename.length()-4, 4).compare(".cbc")!=0)
|
|
rc_filename += ".cbc";
|
|
}
|
|
else
|
|
{
|
|
rc_filename += ".cbc";
|
|
}
|
|
|
|
#ifdef RC_ANDROID
|
|
rc_filename = "main.cbc";
|
|
#endif
|
|
|
|
#ifdef RC_IOS
|
|
if( rc_intern_dirChange("assets")!=0)
|
|
{
|
|
cout << "could not set path" << endl;
|
|
return 0;
|
|
}
|
|
rc_filename = "main.cbc";
|
|
#endif
|
|
|
|
//cout << "starting: " << rc_filename << endl;
|
|
|
|
#ifdef RC_WEB
|
|
rc_filename = "main.cbc";
|
|
#endif
|
|
|
|
if(rcbasic_load(rc_filename))
|
|
{
|
|
#ifdef RCBASIC_DEBUG
|
|
loadDebugData("rcbasic.dbgs", "rcbasic.dbgi");
|
|
#endif // RCBASIC_DEBUG
|
|
|
|
//cout << "n_count = " << n_count << endl;
|
|
//cout << "s_count = " << s_count << endl;
|
|
//cout << "n_stack_size = " << n_stack_size << endl;
|
|
//cout << "s_stack_size = " << s_stack_size << endl;
|
|
//cout << "loop_stack_size = " << loop_stack_size << endl;
|
|
//cout << "numID_count = " << numID_count << endl;
|
|
//cout << "strID_count = " << strID_count << endl;
|
|
//cout << "code_segment_size = " << code_segment_size << endl;
|
|
//cout << "data_segment_size = " << data_segment_size << endl;
|
|
//cout << "last code = " << (int)segment[CODE_SEGMENT][code_segment_size-1] << endl;
|
|
//cout << "last data = " << (int)segment[DATA_SEGMENT][data_segment_size-1] << endl << endl;
|
|
|
|
rcbasic_run();
|
|
}
|
|
else
|
|
cout << "++Could not load rcbasic program" << endl;
|
|
|
|
rc_cleanSubprocessSystem();
|
|
rcbasic_clean();
|
|
|
|
exit(rcbasic_exit_code);
|
|
//cout << "Hello world!" << endl;
|
|
return 0;
|
|
}
|