bool_t string_to_signum(const char *str, int *ret)
{
if (signame_to_signum(str, ret))
return TRUE;
return string_to_integer(str, ret);
}
int convert_string_to_tree(char *string, int index, int *position_of_delimiters, NODE *root)
{
if(position_of_delimiters[index]=='\0')
{
return index;
}
int *return_numbers = string_to_integer(string,position_of_delimiters[index]);
if(return_numbers[0]==return_numbers[1])
{
root->data = return_numbers[0];
root->left_child = root->right_child = NULL;
root->parent = NULL;
index++;
index = convert_string_to_tree(string, index,position_of_delimiters,root);
index = convert_string_to_tree(string, index,position_of_delimiters,root);
free(return_numbers);
return index;
}
else if(return_numbers[0]!=root->data)
{
free(return_numbers);
return index;
}
else if(return_numbers[0]!=return_numbers[1])
{
NODE *new_node = (NODE*)malloc(sizeof(NODE));
new_node->data = return_numbers[1];
new_node->left_child = NULL;
new_node->right_child = NULL;
if(root->left_child==NULL)
{
root->left_child = new_node;
new_node->parent = root;
index++;
}
else if(root->right_child==NULL)
{
root->right_child = new_node;
new_node->parent = root;
index++;
}
index = convert_string_to_tree(string, index,position_of_delimiters,new_node);
index = convert_string_to_tree(string, index,position_of_delimiters,new_node);
free(return_numbers);
return index;
}
}
/*
* MAIN: Run the program and tests your functions.
* sample command: ./bignum 4 12 + 13
* Result: 31
*/
int main(int argc, char** argv) {
int input_base;
int* input1;
int* input2;
int* result;
if(argc != 5) {
print_usage(argv[0]);
}
input_base = string_to_integer(argv[1]);
if(!valid_base(input_base)) {
fprintf(stderr, "Invalid base: %s\n", argv[1]);
print_usage(argv[0]);
}
if(!valid_input(argv[2], input_base)) {
fprintf(stderr, "Invalid input1: %s\n", argv[2]);
print_usage(argv[0]);
}
if(!valid_input(argv[4], input_base)) {
fprintf(stderr, "Invalid input2: %s\n", argv[4]);
print_usage(argv[0]);
}
if(argv[3][0] != '-' && argv[3][0] != '+') {
fprintf(stderr, "Invalid operation: %s\n", argv[3]);
print_usage(argv[0]);
}
input1 = string_to_integer_array(argv[2]);
input2 = string_to_integer_array(argv[4]);
result = perform_math(input1, input2, argv[3][0], input_base);
printf("Result: ");
bignum_print(result);
printf("\n");
exit(0);
}
/* Creates a X figure of dimension argv[1] rows and columns */
int main(int argc, char* argv[]) {
int row;
int col;
int len;
if (argc != 2)
{
return -1;
}
len = string_to_integer(argv[1]);
if (len < 1)
{
return -1;
}
row = 1;
while (row <= len) {
col = 1;
while (col <= len) {
if ((col == len - row + 1) && (col == row))
{
print_char('X');
}
else if (col == row)
{
print_char('\\');
}
else if (col == len - row + 1)
{
print_char('/');
}
else
{
print_char(' ');
}
col++;
}
print_char('\n');
row++;
}
return 0;
}
unsigned int integer_to_binary(unsigned char** result,integer data,int keyLenBytes){
integer base=string_to_integer("256");
integer div=create_integer(data.num_components);
copy_integer(data,div);
integer zero=create_integer(1);
zero.c[0]=0;
unsigned char* pf=new unsigned char[data.num_components];
for(int i=0; i<data.num_components; i++){
pf[i]=0;
}
int tpos=data.num_components-1;
pf[tpos]=div.c[0];
tpos--;
while(compare_integers(div,zero)==1){
integer mod=create_integer(div.num_components+1+1);
mod_integer(div,base,mod);
integer div_temp=create_integer(div.num_components);
copy_integer(div,div_temp);
divide_small_integer(div_temp,256,div);
pf[tpos]=div.c[0];
tpos--;
}
int startpos=div.num_components-keyLenBytes;
*result=new unsigned char[keyLenBytes];
for(int i=0; i<keyLenBytes; i++){
(*result)[i]=pf[i+startpos];
}
return keyLenBytes;
}
int main(int argc, char *argv[]){
int h, w, i, len;
if (argc < 2) {
return (1);
}
if (argv[1] <= 0) {
return (1);
}
len = string_to_integer(argv[1]);
h = len;
w = len;
if (len == 1){
print_char('X');
print_char('\n');
} else {
for (i=0; i<=len; i++){
print_row(i, len);
}
}
}
int problem263()
{
integer testnum = string_to_integer("5");
integer testnum_helper = string_to_integer("5");
integer two = string_to_integer("2");
integer total_src = string_to_integer("0");
integer total_tar = string_to_integer("0");
integer target_dif = string_to_integer("6");
integer dif = string_to_integer("0");
int found = 0;
integer lastprime = string_to_integer("5");
//int sexy_count = 0;
printf("text here\n");
while (found < 4) {
//printf("gets 1\n");
if (miller_rabin(testnum) == PRIME) {
subtract_integer(testnum, lastprime, dif);
if (compare_integers(dif, target_dif) == 0) {
printf("difference between %s and %s is six\n",
integer_to_string(testnum), integer_to_string(lastprime));
found++;
}else {
found = 1;
}
copy_integer(testnum, lastprime);
add_integer(total_src, testnum, total_tar);
copy_integer(total_tar, total_src);
printf("Total is %s\n", integer_to_string(total_tar));
}
add_integer(testnum_helper, two, testnum);
copy_integer(testnum, testnum_helper);
printf("Tested %s\n", integer_to_string(testnum));
}
return 0;
}
integer hex_to_integer(unsigned char* data, unsigned int datalenBytes, unsigned int pad){
integer base=string_to_integer("256");
int siz=datalenBytes;
integer radix=create_integer(siz);
set_zero_integer(radix);
radix.c[0]=1;
integer result=create_integer(siz*2+pad);
set_zero_integer(result);
integer digit=create_integer(1);
for(int i=datalenBytes-1; i>=0; i--){
digit.c[0]=data[i];
integer part_res=create_integer(1+radix.num_components+1);
set_zero_integer(part_res);
multiply_integer(digit,radix,part_res);
add_integer(result,part_res,result);
free_integer(part_res);
integer radix_temp=create_integer(radix.num_components);
copy_integer(radix,radix_temp);
multiply_integer(radix_temp,base,radix);
free_integer(radix_temp);
}
optimize_integer(result);
return result;
}
int main(void)
{
int n;
n = string_to_integer("98");
printf("%d\n", n);
n = string_to_integer("-402");
printf("%d\n", n);
n = string_to_integer(" ------++++++-----+++++--98");
printf("%d\n", n);
n = string_to_integer("2147483647");
printf("%d\n", n);
n = string_to_integer("0");
printf("%d\n", n);
n = string_to_integer("-2147483648");
printf("%d\n", n);
n = string_to_integer("2147483648");
printf("%d\n", n);
n = string_to_integer("34234232147483648");
printf("%d\n", n);
n = string_to_integer("Suite 402");
printf("%d\n", n);
n = string_to_integer(" + + - -98 Battery Street; San Francisco, CA 94111 - USA ");
printf("%d\n", n);
n = string_to_integer("---++++ -++ Sui - te - 402 #cisfun :)");
printf("%d\n", n);
return (0);
}
static int integer(It beg, It end, T& result) noexcept {
return string_to_integer(beg, end, result);
}
int main(int argc, char *argv[])
{
struct parsed_argv params;
bool_t succeeded = FALSE;
int i;
if (!parse_argv(argc, argv, ¶ms, &i))
exit(EXIT_FAILURE);
/* tty's foreground pgid kill mode */
if (params.tty_name != NULL) {
pid_t pgid = get_foreground_pgrp(params.tty_name);
if (pgid <= 0) {
fprintf(stderr, "%s: Cannot obtain foreground process group on %s - %s\n",
PROGNAME, params.tty_name, strerror(errno));
exit(EXIT_FAILURE);
}
if (params.excepting && params.except_pgid == pgid) {
if (params.verbose)
fprintf(stderr, "info:tty's pgid = except pgid. dont kill.\n");
} else {
if (params.verbose)
fprintf(stderr, "invoke:kill(pid=%d(%s),signum=%d)\n",
-pgid, params.tty_name, params.signum);
if (kill(-pgid, params.signum) != 0) {
fprintf(stderr, "%s:(%d on %s) %s\n", PROGNAME, pgid, params.tty_name, strerror(errno));
exit(EXIT_FAILURE);
}
}
exit(EXIT_SUCCESS);
}
/* normal kill mode */
for (; i < argc; i++) {
pid_t pid;
union sigval sigval;
if (!string_to_integer(argv[i], &pid)) {
fprintf(stderr, "%s: Invalid pid - %s\n", PROGNAME, argv[i]);
continue;
}
if (params.pid_is_winpid) {
pid_t cyg_pid = cygwin_winpid_to_pid(abs(pid));
if (cyg_pid < 0) {
fprintf(stderr, "%s: Not a cygwin process's pid - %s\n", PROGNAME, argv[i]);
continue;
}
pid = pid < 0 ? -cyg_pid : cyg_pid;
if (params.verbose)
fprintf(stderr, "convert:win_pid=%s => cyg_pid=%d\n", argv[i], pid);
}
if (params.use_sigqueue) {
if (params.verbose)
fprintf(stderr, "invoke:sigqueue(pid=%d,signum=%d,sigval=%#08x)\n",
pid, params.signum, params.sigval);
sigval.sival_int = params.sigval;
if (sigqueue(pid, params.signum, sigval) != 0) {
fprintf(stderr, "%s:(%d) %s\n", PROGNAME, pid, strerror(errno));
}
} else {
if (params.verbose)
fprintf(stderr, "invoke:kill(pid=%d,signum=%d)\n", pid, params.signum);
if (kill(pid, params.signum) != 0) {
fprintf(stderr, "%s:(%d) %s\n", PROGNAME, pid, strerror(errno));
}
}
succeeded = TRUE;
}
exit(succeeded ? EXIT_SUCCESS : EXIT_FAILURE);
}
bool_t parse_argv(int argc, char*argv[], struct parsed_argv *result, int *next_index)
{
bool_t flag_pid_found = FALSE;
int opt;
memset(result, 0, sizeof(struct parsed_argv));
result->signum = SIGTERM;
opterr = 0; /* suppress auto error */
while(!flag_pid_found && (opt = getopt(argc, argv, "+vws:S:i:t:e:h")) != -1) {
switch(opt) {
case 'w':
result->pid_is_winpid = TRUE;
break;
case 's':
case 'S': /* for -S[IGSOME] to some */
if (!string_to_signum(optarg, &result->signum)) {
fprintf(stderr, "%s: Unknown signal: %s\n", PROGNAME, optarg);
return FALSE;
}
break;
case 'i':
if (!string_to_integer(optarg, &result->sigval)) {
fprintf(stderr, "%s: Invalid sigval: %s\n", PROGNAME, optarg);
return FALSE;
}
result->use_sigqueue = TRUE;
break;
case 't':
result->tty_name = strdup(optarg);
break;
case 'e':
if (!string_to_integer(optarg, &result->except_pgid)) {
fprintf(stderr, "%s: Invalid excepting pgid: %s\n", PROGNAME, optarg);
return FALSE;
}
result->excepting = TRUE;
break;
case 'v':
result->verbose = TRUE;
break;
case 'h':
usage();
return FALSE;
case '?':
if (isdigit(optopt)) {
flag_pid_found = TRUE;
} else {
fprintf(stderr, "%s: Invalid option: -%c\n", PROGNAME, optopt);
return FALSE;
}
}
}
if (optind >= argc && result->tty_name == NULL) {
usage();
return FALSE;
} else if (optind < argc && result->tty_name != NULL) {
fprintf(stderr, "%s: Can't specify tty and pid at same time.\n", PROGNAME);
usage();
return FALSE;
}
*next_index = optind;
return TRUE;
}
void RequestHandler :: handleClient( int fd ){
Connection conn( fd );
HttpMessage request, response;
std::string content;
std::vector< std::string > parts;
std::string body;
bool done = false;
size_t request_counter = 0;
conn.set_timeout( 15 );
while( !done ){
try{
//std::cerr << "Handler " << *ptr_fd << " receiving..." << std::endl;
while( content.find( "\r\n\r\n" ) == std::string::npos ){
content += conn.receive( 1024 );
}
} catch( std::string error ){
//std::cerr << "RH: ERROR: " << error << std::endl;
done = true;
continue;
}
//std::cerr << "Handler " << *ptr_fd << " done receiving..." << std::endl;
//std::cerr << "content: '" << content << "'" << std::endl;
parts = split_string( content, "\r\n\r\n" );
if( parts.size() > 1 ){
for( size_t i = 1 ; i < parts.size() - 1 ; ++i ){
body += parts[i] + std::string( "\r\n\r\n" );
}
body += parts[parts.size()-1];
}
content.clear();
std::vector<std::string> header_lines = split_string( parts[0], "\r\n" );
std::vector< std::string > request_line = split_string( header_lines[0], " " );
//std::cerr << "request_line: '" << header_lines[0] << "' and header_lines.size() = " << header_lines.size() << "request_line.size() = " << << std::endl;
if( header_lines.size() < 2 || request_line.size() != 3 ){
// return error response
//conn.disconnect();
std::cerr << "RH: ERROR: " << "Invalid request line!" << std::endl;
done = true;
continue;
}
request.set_method( request_line[0] );
request.set_path( request_line[1] );
request.set_version( request_line[2] );
for( size_t i = 1 ; i < header_lines.size() ; ++i ){
std::vector<std::string> tmp = split_string( header_lines[i], ":" );
if( tmp.size() > 2 ){
std::string str;
for( size_t i = 1 ; i < tmp.size() - 1 ; ++i ){
str += tmp[i] + std::string( ":" );
}
str += tmp[tmp.size()-1];
request.set_header_field( trim(tmp[0] ), trim( str ) );
}
else{
request.set_header_field( trim( tmp[0] ), trim( tmp[1] ) );
}
}
if( ( request_line[0] == "PUT" ) || ( request_line[0] == "POST" ) ){
size_t content_length = 0;
if( request.has_header_field( "Content-Length" ) ){
content_length = string_to_integer( request.get_header_field( "Content-Length" ) );
}
if( request.has_header_field( "Transfer-Encoding" ) ){
if( request.get_header_field( "Transfer-Encoding" ) == "chunked" ){
bool chunks_done = false;
size_t chunk_size = 0, pos;
content = body;
body.clear();
while( !chunks_done ){
pos = content.find( "\r\n" );
if( pos != std::string::npos ){
std::string hex = content.substr( 0, pos );
chunk_size = hex_string_to_integer( trim( hex ) );
content = content.substr( pos+2 );
if( chunk_size == 0 ){ chunks_done = true; continue; }
}
try{
while( content.size() < chunk_size+2 ){
content += conn.receive( chunk_size - content.size() + 2 );
}
} catch( std::string error ){
//std::cerr << "RH: ERROR: " << error << std::endl;
done = true;
continue;
}
body += content.substr( 0, chunk_size );
content = content.substr( chunk_size + 2 );
try{
while( content.find( "\r\n" ) == std::string::npos ){
content += conn.receive( 1 );
}
} catch( std::string error ){
//std::cerr << "RH: ERROR:" << error << std::endl;
done = true;
break;
}
}
}
}
else{
try{
while( body.size() < content_length ){
body += conn.receive( content_length - content.size() );
}
} catch( std::string error ){
std::cerr << "RH: ERROR:" << error << std::endl;
done = true;
continue;
}
}
request.set_body( body );
}
//std::cerr << "Request: " << request.serialize() << std::endl;
try{
response = RequestHandler::handleRequest( request );
conn.send( response.serialize() );
} catch( std::string error ){
//std::cerr << "RH: ERROR: " << error << std::endl;
}
done = true;
if( request.has_header_field( "Connection" ) ){
if( ( request.get_header_field( "Connection" ) == "Keep-Alive" ) ||
( request.get_header_field( "Connection" ) == "keep-alive" ) ){
done = false;
}
}
++request_counter;
if( request_counter > 15 ){
done = true;
}
}
//printf( "Disconnecting %i \n", conn.get_fd() );
//gconn_unmark( conn.get_fd() );
conn.disconnect();
--global_connection_count;
//delete (int*)arg;
//pthread_exit( NULL );
}
int igetline(FILE *imgcfg, char *strchar, int *x)
{
char *st, *st1, *st4, *st5, *st6, *pch;
char *strcha2;
int k, len;
st=(char *)calloc(200,sizeof(char));
st1=(char *)calloc(200,sizeof(char));
st4=(char *)calloc(200,sizeof(char));
st5=(char *)calloc(200,sizeof(char));
st6=(char *)calloc(200,sizeof(char));
strcha2=(char *)calloc(200,sizeof(char));
strcpy(strcha2,strchar);
strncat(strcha2," ",1);
if ( fgets(st,200,imgcfg) == NULL )
{
perror ("Error reading file in igetline (1)");
}
if(feof(imgcfg)==0)
{
strcpy(st4,"");
strncat(st4,st,3);
strcpy(st1,"");
//strncat(st1,st+4,200);
// st1 = const_cast<char*>((std::string(st1) + std::string(st)).c_str());
strncat(st1,st+4,120);
while(feof(imgcfg)==0 && ( strncmp(st4,"set",3)!=0 || strncmp(st1, strcha2,strlen(strcha2))!=0))
{
if (fgets(st,200,imgcfg) == NULL )
{
perror ("Error reading file in igetline (2)");
}
strcpy(st4,"");
strncat(st4,st,3);
strcpy(st1,"");
strncat(st1,st+4,120);
}
if(feof(imgcfg)==0 && strncmp(st1, strcha2,strlen(strcha2))==0)
{
pch=(char *)memchr(st, '"', strlen(st));
strcpy(st5,pch+1);
pch=(char *)memchr(st5, '"',strlen(st5));
strcpy(st6,"");
strncat(st6,st5, strlen(st5)-strlen(pch));
k=0;
pch=(char *)memchr(st6,',',strlen(st6));
while(pch!=NULL)
{ strcpy(st1,"");
strncat(st1,st6, strlen(st6)-strlen(pch));
x[k]=string_to_integer(st1);
len=strlen(st1);
k++;
strcpy(st1,"");
strncat(st1,st6+len+1,120);
strcpy(st6,st1);
pch=(char *)memchr(st6,',',strlen(st6));
}
x[k]=string_to_integer(st6); rewind(imgcfg); return(0);
}
else { printf(" '%s' float parameter does not exist in 2dx_image.cfg\n", strchar); rewind(imgcfg); return(1); }
}
else
{ printf(" '%s' float parameter does not exist in 2dx_image.cfg \n", strchar); rewind(imgcfg); return(1); }
}
int pow_mod(unsigned char** result,unsigned char* p,unsigned char* q, unsigned char* r,unsigned int keyLengthBytes){
std::set_new_handler(newh);
Array<integer> factors;
integer div=hex_to_integer(q,keyLengthBytes,0);
int siz=keyLengthBytes;
integer power_of_two=create_integer(siz);
set_zero_integer(power_of_two);
integer zero=create_integer(1);
set_zero_integer(zero);
integer two=string_to_integer("2");
integer one=string_to_integer("1");
int i=0;
integer div_temp=create_integer(div.num_components);
integer rem=create_integer(div.num_components+2);
while(compare_integers(div, zero) == 1){
set_zero_integer(rem);
mod_integer(div, two,rem);
copy_integer(div,div_temp);
divide_small_integer(div_temp,2,div);
if(compare_integers(rem, zero) == 1){
integer ptt=create_integer(power_of_two.num_components);
copy_integer(power_of_two,ptt);
factors.pushBack(ptt);
}
add_integer(power_of_two,one,power_of_two);
i++;
}
free_integer(rem);
free_integer(div_temp);
Array<integer> partial_results;
integer part_res=hex_to_integer(p,keyLengthBytes,2);
integer ri=hex_to_integer(r,keyLengthBytes,1);
integer idx = create_integer(part_res.num_components);
set_zero_integer(idx);
integer part_res_temp1=create_integer(part_res.num_components);
integer part_res_temp2=create_integer(part_res.num_components);
integer part_res_temp3=create_integer(part_res.num_components);
for(int i=0; i<factors.size(); i++){
while(compare_integers(factors[i],idx)==1){
copy_integer(part_res,part_res_temp1);
copy_integer(part_res,part_res_temp2);
multiply_integer(part_res_temp1,part_res_temp2,part_res);
copy_integer(part_res,part_res_temp3);
mod_integer(part_res_temp3,ri,part_res);
add_integer(idx,one,idx);
}
integer ptt=create_integer(part_res.num_components);
copy_integer(part_res,ptt);
partial_results.pushBack(ptt);
}
free_integer(part_res_temp1);
free_integer(part_res_temp2);
free_integer(part_res_temp3);
integer resulti=create_integer(ri.num_components+1);
set_zero_integer(resulti);
resulti.c[0]=1;
integer resulti_temp=create_integer(resulti.num_components);
integer resulti_temp2=create_integer(resulti.num_components);
for(int i=0; i<partial_results.size(); i++){
copy_integer(resulti,resulti_temp);
multiply_integer(resulti_temp,partial_results[i],resulti);
copy_integer(resulti,resulti_temp2);
mod_integer(resulti_temp2,ri,resulti);
}
free_integer(resulti_temp);
free_integer(resulti_temp2);
int lol=integer_to_binary(result,resulti,keyLengthBytes);
return lol;
}
void IrrealVM :: execute( uint64_t thread_id ){
//if( global_vm_queue.size() < 1 ){ return; }
pthread_mutex_lock( &global_vm_queue_lock );
if( global_vm_queue.size() < 1 ){
pthread_mutex_unlock( &global_vm_queue_lock );
return;
}
uint64_t ctx_id = global_vm_queue.front();
global_vm_queue.pop_front();
IrrealContext *ctx = global_contexts[ ctx_id ];
pthread_mutex_unlock( &global_vm_queue_lock );
test_for_error( ctx == NULL, "Invalid context!" );
ctx->lock_context();
global_running_threads_vm[ thread_id ] = ctx_id;
//printf( "Executing vm #%lu\n", ctx_id );
//_debug_running_threads();
IrrealStack *current, *code;
current = ctx->getCurrentStack();
code = ctx->getCodeStack();
test_for_error( current == NULL, "Invalid current stack!" );
test_for_error( code == NULL, "Invalid code stack!" );
uint8_t state = ctx->getState();
switch( state ){
case STATE_JOINING:
if( !current->isJoined() ){
pthread_mutex_lock( &global_vm_queue_lock );
global_vm_queue.push_back( ctx_id );
pthread_mutex_unlock( &global_vm_queue_lock );
ctx->mark();
ctx->unlock_context();
return;
}
break;
case STATE_SYNCING:
test_for_error( current->peek() == NULL, "Not enough values to perform 'sync'!" );
//printf( "syncing... ('%s')\n", current->peek()->getValue().c_str() );
if( current->peek()->getState() == STATE_NOT_YET ){
pthread_mutex_lock( &global_vm_queue_lock );
global_vm_queue.push_back( ctx_id );
pthread_mutex_unlock( &global_vm_queue_lock );
ctx->mark();
ctx->unlock_context();
return;
}
//printf( "Data synced, now continuing... \n" );
break;
}
std::string anon_name;
bool anon_state = false;
uint64_t begin_end_counter = 0;
bool done = false;
IrrealStack *anon_stack = NULL;
long int debug_value;
IrrealStack *debug_stack;
debug_value = ctx->getStack("PARAMS")->size();
debug_stack = ctx->getStack("PARAMS");
while( !done ){
ctx->mark();
//printf( "\n\n" );
IrrealValue *q = code->pop();
//printf( "current: " ); current->_debug_print();
//printf( "params: " ); ctx->getStack("PARAMS")->_debug_print();
//printf( "out: " ); ctx->getStack("OUT")->_debug_print();
if( q == NULL ){
//printf( "q == NULL\n" );
done = true;
if( ctx->getReturnValue() != NULL ){
//printf( "Returning value! ('%s')\n", ctx->getReturnValue()->getValue().c_str() );
ctx->getStack( ctx->getReturnValue()->getValue() )->merge( ctx->getStack( "OUT" ), false );
ctx->getReturnValue()->setType( TYPE_SYMBOL );
ctx->getReturnValue()->setState( STATE_OK );
}
pthread_mutex_lock( &global_running_vms_lock );
--global_running_vms;
pthread_mutex_unlock( &global_running_vms_lock );
continue;
}
if( q->getType() & TYPE_OPERATOR ){
printf( "q = {'%s', %s} \n", q->getValue().c_str(), debug_cmd_names[ q->getType() & (~0x80 ) ].c_str() );
}
else{
printf( "q = {'%s', %i} \n", q->getValue().c_str(), q->getType() );
}
if( anon_state ){
if( q->getType() & TYPE_OPERATOR ){
switch( q->getType() ){
case CMD_BEGIN:
++begin_end_counter;
break;
case CMD_END:
--begin_end_counter;
break;
}
anon_stack->push( q );
if( begin_end_counter == 0 ){
test_for_error( anon_stack == NULL, "Stack error when parsing block!" );
anon_stack->pop();
anon_state = false;
IrrealValue* value = new IrrealValue();
value->setType( TYPE_SYMBOL );
value->setValue( anon_name );
current->push( value );
//printf( "pushing to stack: '%s' \n", current->peek()->getValue().c_str() );
continue;
}
}
else{
test_for_error( anon_stack == NULL, "Stack error when parsing block!" );
anon_stack->push( q );
}
}
else{
if( q->getType() & TYPE_OPERATOR ){
//printf( "Executing command: %s \n", debug_cmd_names[ q->getType() & (~0x80) ].c_str() );
switch( q->getType() ){
case CMD_BEGIN:
{
anon_name = ctx->spawnNewAnonymousStack();
anon_stack = ctx->getStack( anon_name );
test_for_error( anon_stack == NULL, "Unable to spawn new anonymous stack!" );
begin_end_counter = 1;
anon_state = true;
}
break;
case CMD_PUSH:
{
IrrealValue *target_stack_name;
IrrealValue *value;
IrrealStack *target_stack;
target_stack_name = current->pop();
value = current->pop();
test_for_error( target_stack_name == NULL, "Not enough values to perform 'push'!" );
test_for_error( value == NULL, "Not enough values to perform 'push'!" );
target_stack = ctx->getStack( target_stack_name->getValue() );
test_for_error( target_stack == NULL, "PUSH: Stack not found!" );
target_stack->push( value );
}
break;
case CMD_POP:
{
IrrealValue *target_stack_name;
IrrealStack *target_stack, *testing;
IrrealValue *value;
target_stack_name = current->pop();
test_for_error( target_stack_name == NULL, "Not enough values to perform 'pop'!" );
target_stack = ctx->getStack( target_stack_name->getValue() );
testing = ctx->getStack( target_stack_name->getValue() );
test_for_error( target_stack == NULL, "POP: Stack not found!" );
value = target_stack->pop();
if( value == NULL ){
printf( "\n\n**** Debug info***\n\n" );
printf( "In PARAMS stack there were %li entries in the beginning...\n", debug_value );
printf( "target_stack_name = '%s' \n", target_stack_name->getValue().c_str() );
printf( "Context mark count: %lu \n", ctx->read_marks() );
printf( "target_stack pop_counter = %lu \n", target_stack->_debug_get_counter() );
printf( "target_stack = %p, target_stack->id = %lu \n", target_stack, target_stack->get_id() );
printf( "debug_stack = %p, debug_stack->id = %lu \n", debug_stack, debug_stack->get_id() );
printf( "testing: %p, testing->id = %lu\n", testing, testing->get_id() );
printf( "debug_stack->size = %lu, target_stack->size = %lu, testing->size = %lu \n", debug_stack->size(), target_stack->size(), testing->size() );
value = testing->pop();
printf( "testing->pop = %p, value->getValue = %s\n", value, value->getValue().c_str() );
printf( "\n" );
fflush( stdout );
value = NULL;
}
test_for_error( value == NULL, "POP: Target stack empty!" );
current->push( value );
}
break;
case CMD_DEF:
{
IrrealValue *target_name;
IrrealValue *value;
target_name = current->pop();
value = current->pop();
test_for_error( target_name == NULL, "Not enough values to perform 'def'!" );
test_for_error( value == NULL, "No enough values to perform 'def'!" );
ctx->spawnNewStack( target_name->getValue() );
switch( value->getType() ){
case TYPE_SYMBOL:
{
IrrealStack *target_stack = ctx->getStack( target_name->getValue() );
IrrealStack *source_stack = ctx->getStack( value->getValue() );
test_for_error( target_stack == NULL, "DEF: Target stack not found!" );
test_for_error( source_stack == NULL, "DEF: Source stack not found!" );
IrrealValue *tmp = source_stack->pop();
while( tmp != NULL ){
target_stack->push( tmp );
tmp = source_stack->pop();
}
}
break;
default:
{
IrrealStack *target_stack = ctx->getStack( target_name->getValue() );
test_for_error( target_stack == NULL, "DEF: Target stack not found!" );
target_stack->push( value );
}
break;
}
}
break;
case CMD_MERGE:
{
IrrealValue *target_name;
IrrealStack *target_stack;
target_name = current->pop();
test_for_error( target_name == NULL, "Not enough values to perform 'merge'!" );
target_stack = ctx->getStack( target_name->getValue() );
test_for_error( target_stack == NULL, "MERGE: Stack not found!" );
current->merge( target_stack, false );
}
break;
case CMD_CALL:
{
IrrealValue *func, *nparams, *return_value;
nparams = current->pop();
func = current->pop();
test_for_error( nparams == NULL, "Not enough values to perform 'call'!" );
test_for_error( func == NULL, "Not enough values to perform 'call'!" );
IrrealContext *new_ctx = new IrrealContext();
new_ctx->lock_context();
return_value = new IrrealValue();
return_value->setType( TYPE_SENTINEL );
return_value->setState( STATE_NOT_YET );
return_value->setValue( ctx->spawnNewAnonymousStack() );
//printf( "current->peek() = '%s' \n", current->peek()->getValue().c_str() );
new_ctx->setReturnValue( return_value );
IrrealStack *func_stack = ctx->getStack( func->getValue() );
test_for_error( func_stack == NULL, "CALL: Function not found!" );
new_ctx->getCodeStack()->nondestructive_merge( func_stack, true );
size_t N = string_to_integer( nparams->getValue() );
//printf( "nparams: %lu \n", N );
IrrealStack *params = new_ctx->getStack( "PARAMS" );
for( size_t i = 0 ; i < N ; ++i ){
IrrealValue *p = current->pop();
test_for_error( p == NULL, "Not enough values to perform 'call'!" );
if( p->getType() == TYPE_SYMBOL ){
std::string stack_name = ctx->spawnNewAnonymousStack();
IrrealStack *pstack = ctx->getStack( stack_name );
IrrealStack *target_stack = ctx->getStack( p->getValue() );
test_for_error( pstack == NULL, "CALL: Unable to spawn new anonymous stack!" );
test_for_error( target_stack == NULL, "CALL: Undefined symbol!" );
pstack->nondestructive_merge( target_stack, false );
params->push( new IrrealValue( TYPE_SYMBOL, STATE_OK, stack_name ) );
}
else{
params->push( p );
}
}
//printf( "Calling with params: "); params->_debug_print();
//printf( "Merging scope...\n" );
new_ctx->mergeScope( ctx->getScope() );
new_ctx->unlock_context();
pthread_mutex_lock( &global_vm_queue_lock );
global_vm_queue.push_front( new_ctx->get_id() );
pthread_mutex_unlock( &global_vm_queue_lock );
pthread_mutex_lock( &global_running_vms_lock );
++global_running_vms;
pthread_mutex_unlock( &global_running_vms_lock );
current->push( return_value );
//printf( "current->peek() = '%s' \n", current->peek()->getValue().c_str() );
}
break;
case CMD_JOIN:
ctx->setState( STATE_JOINING );
done = true;
pthread_mutex_lock( &global_vm_queue_lock );
global_vm_queue.push_back( ctx->get_id() );
pthread_mutex_unlock( &global_vm_queue_lock );
break;
case CMD_ADD:
{
IrrealValue *first, *second, *value;
first = current->pop();
second = current->pop();
test_for_error( first == NULL, "Not enough values to perform 'add'!" );
test_for_error( second == NULL, "Not enough values to perform 'add'!" );
value = new IrrealValue();
value->setType( TYPE_INTEGER );
value->setValue( integer_to_string( string_to_integer( first->getValue() ) + string_to_integer( second->getValue() ) ) );
current->push( value );
}
break;
case CMD_PRINT:
{
IrrealValue *value;
value = current->pop();
test_for_error( value == NULL, "Not enough values to perform 'print'!" );
printf( "print: type = %i, state = %i, value = '%s' \n", value->getType(), value->getState(), value->getValue().c_str() );
}
break;
case CMD_SYNC:
ctx->setState( STATE_SYNCING );
done = true;
pthread_mutex_lock( &global_vm_queue_lock );
global_vm_queue.push_back( ctx->get_id() );
pthread_mutex_unlock( &global_vm_queue_lock );
break;
case CMD_DUP:
{
IrrealValue *value, *new_value;
value = current->pop();
test_for_error( value == NULL, "Not enough values to perform 'dup'!" );
new_value = new IrrealValue( value->getType(), value->getState(), value->getValue() );
current->push( value );
current->push( new_value );
}
break;
case CMD_WHILE:
{
IrrealValue *test, *body;
/*
{...} {some tests} while
some tests
{ ...
* {...} {some tests} while
} {} if
*/
test = current->pop();
body = current->pop();
test_for_error( test == NULL, "Not enough values to perform 'while'!" );
test_for_error( body == NULL, "Not enough values to perform 'while'!" );
IrrealStack *new_code = new IrrealStack();
IrrealStack *test_stack = ctx->getStack( test->getValue() );
IrrealStack *body_stack = ctx->getStack( body->getValue() );
test_for_error( test_stack == NULL, "Invalid test stack for 'while'!" );
test_for_error( body_stack == NULL, "Invalid body stack for 'while'!" );
new_code->nondestructive_merge( test_stack, true );
new_code->push( new IrrealValue( CMD_BEGIN, STATE_OK, "" ) );
new_code->nondestructive_merge( body_stack, true );
new_code->push( body );
new_code->push( test );
new_code->push( new IrrealValue( CMD_WHILE, STATE_OK, "" ) );
new_code->push( new IrrealValue( CMD_END, STATE_OK, "" ) );
new_code->push( new IrrealValue( CMD_BEGIN, STATE_OK, "" ) );
new_code->push( new IrrealValue( CMD_END, STATE_OK, "" ) );
new_code->push( new IrrealValue( CMD_IF, STATE_OK, "" ) );
//printf( "while: new_code: " ); new_code->_debug_print();
code->merge( new_code, false );
delete new_code;
}
break;
case CMD_IF:
{
IrrealValue *test, *block_true, *block_false;
block_false = current->pop();
block_true = current->pop();
test = current->pop();
test_for_error( block_false == NULL, "Not enough values to perform 'if'!" );
test_for_error( block_true == NULL, "Not enough values to perform 'if'!" );
test_for_error( test == NULL, "Not enough values to perform 'if'!" );
IrrealStack *stack_true, *stack_false;
stack_true = ctx->getStack( block_true->getValue() );
stack_false = ctx->getStack( block_false->getValue() );
test_for_error( stack_true == NULL, "IF: Stack (true) not found!" );
test_for_error( stack_false == NULL, "IF: Stack (false) not found!" );
//printf( "if: stack_true: " ); stack_true->_debug_print();
//printf( "if: stack_false: " ); stack_false->_debug_print();
//if( test == NULL ){ printf( "if: test: null!\n" ); }
//printf( "if: test value: %li \n", string_to_integer( test->getValue() ) );
if( string_to_integer( test->getValue() ) ){
code->nondestructive_merge( stack_true, false );
}
else{
code->nondestructive_merge( stack_false, false );
}
}
break;
case CMD_SUB:
{
IrrealValue *first, *second, *value;
second = current->pop();
first = current->pop();
test_for_error( first == NULL, "Not enough values to perform 'sub'!" );
test_for_error( second == NULL, "Not enough values to perform 'sub'!" );
value = new IrrealValue();
value->setType( TYPE_INTEGER );
value->setValue( integer_to_string( string_to_integer( first->getValue() ) - string_to_integer( second->getValue() ) ) );
current->push( value );
}
break;
case CMD_MUL:
{
IrrealValue *first, *second, *value;
first = current->pop();
second = current->pop();
test_for_error( first == NULL, "Not enough values to perform 'mul'!" );
test_for_error( second == NULL, "Not enough values to perform 'mul'!" );
value = new IrrealValue();
value->setType( TYPE_INTEGER );
value->setValue( integer_to_string( string_to_integer( first->getValue() ) * string_to_integer( second->getValue() ) ) );
current->push( value );
}
break;
case CMD_DIV:
{
IrrealValue *first, *second, *value;
second = current->pop();
first = current->pop();
test_for_error( first == NULL, "Not enough values to perform 'div'!" );
test_for_error( second == NULL, "Not enough values to perform 'div'!" );
value = new IrrealValue();
value->setType( TYPE_INTEGER );
value->setValue( integer_to_string( string_to_integer( first->getValue() ) / string_to_integer( second->getValue() ) ) );
current->push( value );
}
break;
case CMD_MOD:
{
IrrealValue *first, *second, *value;
second = current->pop();
first = current->pop();
test_for_error( first == NULL, "Not enough values to perform 'mod'!" );
test_for_error( second == NULL, "Not enough values to perform 'mod'!" );
value = new IrrealValue();
value->setType( TYPE_INTEGER );
value->setValue( integer_to_string( string_to_integer( first->getValue() ) % string_to_integer( second->getValue() ) ) );
current->push( value );
}
break;
case CMD_LENGTH:
{
IrrealValue *value;
value = current->pop();
test_for_error( value == NULL, "Not enough values to perform 'length'!" );
current->push( new IrrealValue( TYPE_INTEGER, STATE_OK, integer_to_string( ctx->getStack( value->getValue() )->size() ) ) );
}
break;
case CMD_MACRO:
{
IrrealValue *value;
value = current->pop();
test_for_error( value == NULL, "Not enough values to perform 'macro'!" );
//printf( "MACRO: debug: stack name = '%s'\n", value->getValue().c_str() );
IrrealStack *source_stack = ctx->getStack( value->getValue() );
test_for_error( source_stack == NULL, "MACRO: Invalid source stack!" );
code->nondestructive_merge( source_stack, true );
}
break;
case CMD_SWAP:
{
IrrealValue *stack_name, *value0, *value1;
IrrealStack *target_stack;
stack_name = current->pop();
test_for_error( stack_name == NULL, "Not enough values to perform 'swap'!" );
target_stack = ctx->getStack( stack_name->getValue() );
test_for_error( target_stack == NULL, "SWAP: Invalid stack!" );
value0 = target_stack->pop();
value1 = target_stack->pop();
test_for_error( value0 == NULL, "SWAP: Not enough values in target stack!" );
test_for_error( value1 == NULL, "SWAP: Not enough values in target stack!" );
target_stack->push( value0 );
target_stack->push( value1 );
}
break;
case CMD_ROTR:
{
}
break;
default:
break;
}
}
else{
current->push( q );
}
}
}
ctx->unlock_context();
}
