int main(void) { cassoclist_t *cassoclist; unsigned int errcode; size_t counter = 0; void *pointer; cassoclist = cassoclist_initialize(sizeof(void *),free_object); if(!cassoclist){ return -1; } while(counter != 1024){ pointer = malloc(1); errcode = cassoclist_add(cassoclist,integer_to_string(counter),&pointer); if(errcode){ fputs("Error!\n",stderr); return -1; } fprintf(stdout,"add : %s,%d\n",integer_to_string(counter),pointer); counter++; } counter = 0; while(counter != 1024){ errcode = cassoclist_lookup(cassoclist ,integer_to_string(counter),&pointer); if(errcode){ fputs("Error!\n",stderr); } fprintf(stdout,"find : %s,%d\n",integer_to_string(counter),pointer); counter++; } cassoclist_release(cassoclist); return 0; }
int main(void) { cassoclist_t *cassoclist; unsigned int errcode; size_t counter = 0; size_t temp; clock_t time; cassoclist = cassoclist_initialize(sizeof(size_t),NULL); if(!cassoclist){ fputs("Error!\n",stderr); return -1; } time = clock(); while(counter != (1<<22)){ errcode = cassoclist_add(cassoclist,integer_to_string(counter),&counter); if(errcode){ fputs("Error!\n",stderr); return -1; } counter++; } fprintf(stdout,"insert : %fs\n",(double)(clock()-time)/CLOCKS_PER_SEC); counter = 0; time = clock(); while(counter != (1<<22)){ errcode = cassoclist_lookup(cassoclist,integer_to_string(counter),&temp); if(errcode){ fputs("Error!\n",stderr); } counter++; } fprintf(stdout,"find : %fs\n",(double)(clock()-time)/CLOCKS_PER_SEC); cassoclist_release(cassoclist); return 0; }
std::string to_string(const ma::limited_int<Integer>& limited_value) { if (limited_value.overflowed()) { return ">" + integer_to_string(limited_value.value()); } else { return integer_to_string(limited_value.value()); } }
// Serialize HttpMessage object to a string (very useful if you want to send a request :D ) std::string HttpMessage :: serialize(){ std::stringstream stream; // code == 0 means that this is a HTTP request. if( code == 0 ){ stream << method << " " << path << " " << version << "\r\n"; } else { stream << version << " " << code << " " << code_string << "\r\n"; } // If content-length header field is not provided, compute it if( header.find( "Content-Length") == header.end() && method != "GET" && method != "HEAD" ){ header["Content-Length"] = integer_to_string( body.size() ); } // Serialize all header fields into the stream, the order of the fields // STL implementation spesific and depends on the comparation function used in std::map for( std::map<std::string, std::string>::iterator it = header.begin(); it != header.end(); it++ ){ stream << (*it).first << ": " << (*it).second << "\r\n"; } stream << "\r\n"; stream << body; return stream.str(); }
bookmark_menu_item::bookmark_menu_item(Gtk::RadioButtonGroup& _group, int _line, std::string _filename) : Gtk::RadioMenuItem(_group),filename(_filename) { line = _line; set_label(filename+" "+ integer_to_string(line)); set_active(false); }
IrrealContext :: IrrealContext(){ pthread_mutex_lock( &global_contexts_lock ); context_id = next_context_id; prefix = integer_to_string( context_id ) + std::string( "::" ); global_contexts[ context_id ] = this; ++next_context_id; pthread_mutex_lock( &global_stacks_lock ); global_stacks[ prefix + std::string( "CURRENT" ) ] = IrrealStack(); global_stacks[ prefix + std::string( "PARAMS" ) ] = IrrealStack(); global_stacks[ prefix + std::string( "CODE" ) ] = IrrealStack(); global_stacks[ prefix + std::string( "OUT" ) ] = IrrealStack(); pthread_mutex_unlock( &global_stacks_lock ); scope.push_back( prefix ); state = STATE_OK; return_value = NULL; //context_lock = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_init( &context_lock, NULL ); marks = 0; pthread_mutex_unlock( &global_contexts_lock ); }
std::string IrrealContext :: spawnNewAnonymousStack(){ pthread_mutex_lock( &global_stacks_lock ); std::string name = std::string( "_anon_" ) + integer_to_string( next_anon_stack_id ); ++next_anon_stack_id; global_stacks[ prefix + name ] = IrrealStack(); pthread_mutex_unlock( &global_stacks_lock ); spawned_stacks.push_back( name ); return name; }
inline ss_size_t format_thousands( C *dest , ss_size_t cchDest , C const *picture , I const &number , C fmtSep , C outputSep ) { C szRawNumber[21]; // 21 is large enough for any 64-bit number (signed or unsigned) C const* rawNumber = integer_to_string(szRawNumber, STLSOFT_NUM_ELEMENTS(szRawNumber), static_cast<unsigned int>(number)); STLSOFT_STATIC_ASSERT(sizeof(C) <= 8); return translate_thousands(dest, cchDest, picture, rawNumber, fmtSep, outputSep); }
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; }
int main() { int mysockfd = socket(AF_INET, SOCK_STREAM, 0), clientfd,no_of_words; struct sockaddr_in servaddr; char receive_data[MAXLINE],send_data[MAXLINE]; int n,temp,i,j; if(mysockfd<0) { printf("socket failed\n"); return -1; } memset(&servaddr, 0, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(5000); // inet_pton(AF_INET, "227.0.0.1", &servaddr.sin_addr); temp = bind(mysockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)); if(temp<0) { printf("bind failed\n"); return -1; } else { printf("bind successful\n"); } temp = listen(mysockfd, 1); if(temp<0) { printf("listen failed\n"); return -1; } else { printf("listen successful\n"); } struct sockaddr_in client; unsigned int clilen=sizeof(client); clientfd = accept(mysockfd, (struct sockaddr *)&client, &clilen); if(clientfd<0) { printf("accept failed\n"); return -1; } else { printf("accept successful\n"); } while(1) { if((n=read(clientfd,receive_data,MAXLINE-1))==0) break; if(n>0) { receive_data[n]='\0'; no_of_words=0; for(i=0;receive_data[i]!='\0';i++) { if(receive_data[i]==' ') no_of_words++; } no_of_words++; printf("%s %d\n",receive_data,no_of_words); integer_to_string(no_of_words,send_data); write(clientfd,send_data,strlen(send_data)); } } printf("end\n"); return 0; }
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(); }