LibbfHashTable* libbf_hash_table_clone(LibbfHashTable *hash_table, LibbfCloneValue clone_value_func) { LibbfHashTable *hash_table_new; LibbfHashNode *new_node; LibbfHashNode *node; int i; hash_table_new = alloc0 (LibbfHashTable, 1); hash_table_new->size = hash_table->size; hash_table_new->nnodes = hash_table->nnodes; hash_table_new->value_destroy_func = hash_table->value_destroy_func; hash_table_new->nodes = alloc0 (LibbfHashNode*, hash_table_new->size); for (i = 0; i < hash_table->size; i++) { node = hash_table->nodes[i]; while(node) { LibbfHashNode *next = hash_table_new->nodes[i]; new_node = libbf_hash_node_new(node->key, (clone_value_func)? clone_value_func(node->value) : node->value); new_node->next = next; hash_table_new->nodes[i] = new_node; node = node->next; } } return hash_table_new; }
ssl_server_client * ssl_server_listen(ssl_server * serv){ BIO * bio = BIO_new_dgram(serv->fd, BIO_NOCLOSE); { struct timeval timeout; timeout.tv_sec = 10; timeout.tv_usec = 0; BIO_ctrl(bio, BIO_CTRL_DGRAM_SET_RECV_TIMEOUT, 0, &timeout); } SSL * ssl = SSL_new(serv->ctx); SSL_set_bio(ssl, bio, bio); SSL_set_options(ssl, SSL_OP_COOKIE_EXCHANGE); struct sockaddr_storage client_addr; while (DTLSv1_listen(ssl, &client_addr) <= 0){ SSL_free(ssl); return NULL; } ssl_server_client * con = alloc0(sizeof(ssl_server_client)); con->ssl = ssl; con->addr = client_addr; con->bio = bio; return con; }
ssl_server * ssl_setup_server(int fd){ ssl_ensure_initialized(); SSL_CTX * ctx = SSL_CTX_new(DTLSv1_server_method()); { // setup server SSL CTX SSL_CTX_set_cipher_list(ctx, "HIGH:!aNULL:!MD5:!RC4"); SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF); if (!SSL_CTX_use_certificate_file(ctx, "certs/server-cert.pem", SSL_FILETYPE_PEM)) printf("\nERROR: no certificate found!"); if (!SSL_CTX_use_PrivateKey_file(ctx, "certs/server-key.pem", SSL_FILETYPE_PEM)) printf("\nERROR: no private key found!"); if (!SSL_CTX_check_private_key (ctx)) printf("\nERROR: invalid private key!"); /* Client has to authenticate */ SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE, dtls_verify_callback); SSL_CTX_set_read_ahead(ctx, 1); SSL_CTX_set_cookie_generate_cb(ctx, generate_cookie); SSL_CTX_set_cookie_verify_cb(ctx, verify_cookie); } ssl_server * srv = alloc0(sizeof(ssl_server)); srv->ctx = ctx; srv->fd = fd; return srv; }
oct_node * oct_get_super(oct_node * oc){ static int parent_it = 0; if(!oc->super){ oc->super = alloc0(sizeof(oct_node)); oc->super->sub[parent_it] = oc; parent_it = 7 - parent_it; } return oc->super; }
oct_node * oct_get_sub(oct_node * oc, int idx){ ASSERT(idx < 8 && idx >= 0); if(oc->sub[idx] == NULL){ oc->sub[idx] = alloc0(sizeof(oct_node)); oc->sub[idx]->super = oc; } return oc->sub[idx]; }
SCCP(Allocator& alloc, InstrGraph* ir) : alloc(alloc) , ir(ir) , ssawork(alloc, ir->size()) , cfgwork() , mark(alloc, ir->size()) , analyzer(ir) { Allocator0 alloc0(alloc); eval_counts = new (alloc0) int[ir->size()]; }
static LibbfHashNode* libbf_hash_node_new (int key, void* value) { LibbfHashNode *hash_node = alloc0 (LibbfHashNode, 1); hash_node->key = key; hash_node->value = value; hash_node->next = NULL; return hash_node; }
LibbfHashTable* libbf_hash_table_new (LibbfDestroyNotify value_destroy_func) { LibbfHashTable *hash_table; hash_table = alloc0 (LibbfHashTable, 1); hash_table->size = HASH_TABLE_MIN_SIZE; hash_table->nnodes = 0; hash_table->value_destroy_func = value_destroy_func; hash_table->nodes = alloc0 (LibbfHashNode*, hash_table->size); return hash_table; }
bool test_connections(){ web_context * ctx = alloc0(sizeof(web_context)); for(int i = 0; i < 100; i++){ char namebuf[100]; sprintf(namebuf, "__test%i", i); add_connection(ctx, namebuf, "aa", "bb"); } ASSERT(get_connection_by_name(ctx, "__test1")); remove_connection(ctx, "__test1"); //ASSERT(get_connection_by_name(ctx, "__test1") == NULL); //ASSERT(get_connection_by_name(ctx, "__test14")->connection == (udpc_connection *) 14); dealloc(ctx->active_connections); dealloc(ctx); return true; }
ssl_server_con * ssl_server_accept(ssl_server_client * scli, int fd){ BIO_set_fd(SSL_get_rbio(scli->ssl), fd, BIO_NOCLOSE); BIO_ctrl(SSL_get_rbio(scli->ssl), BIO_CTRL_DGRAM_SET_CONNECTED, 0, &scli->addr); int ret = 0; do{ret = SSL_accept(scli->ssl);} while(ret == 0); if(ret < 0){ handle_ssl_error(scli->ssl, ret); return NULL; } ASSERT(ret > 0); struct timeval timeout; timeout.tv_sec = 5; timeout.tv_usec = 0; BIO_ctrl(SSL_get_rbio(scli->ssl), BIO_CTRL_DGRAM_SET_RECV_TIMEOUT, 0, &timeout); ssl_server_con * con = alloc0(sizeof(ssl_server_con)); con->ssl = scli->ssl; return con; }
ssl_client * ssl_start_client(int fd, struct sockaddr * remote_addr){ ssl_ensure_initialized(); SSL_CTX * ctx = SSL_CTX_new(DTLSv1_client_method()); SSL_CTX_set_cipher_list(ctx, "HIGH:!aNULL:!MD5:!RC4"); if (!SSL_CTX_use_certificate_file(ctx, "certs/client-cert.pem", SSL_FILETYPE_PEM)) printf("\nERROR: no certificate found!"); if (!SSL_CTX_use_PrivateKey_file(ctx, "certs/client-key.pem", SSL_FILETYPE_PEM)) printf("\nERROR: no private key found!"); if (!SSL_CTX_check_private_key (ctx)) printf("\nERROR: invalid private key!"); SSL_CTX_set_verify_depth (ctx, 2); SSL_CTX_set_read_ahead(ctx, 1); SSL * ssl = SSL_new(ctx); // Create BIO, connect and set to already connected. BIO * bio = BIO_new_dgram(fd, BIO_CLOSE); BIO_ctrl(bio, BIO_CTRL_DGRAM_SET_CONNECTED, 0, remote_addr); SSL_set_bio(ssl, bio, bio); int ret = SSL_connect(ssl); if(ret < 0){ handle_ssl_error(ssl, ret); } { struct timeval timeout; timeout.tv_sec = 3; timeout.tv_usec = 0; BIO_ctrl(bio, BIO_CTRL_DGRAM_SET_RECV_TIMEOUT, 0, &timeout); } ssl_client * cli = alloc0(sizeof(ssl_client)); cli->ssl = ssl; cli->ctx = ctx; return cli; }
i64 get_hash(oct_node n, oct_node bn, game_data * gd){ { // Get hash quick bool ok = false; i64 hash = _get_hash(n, &ok); if(ok){ logd("Found: %p\n", hash); return hash; } } { //Hash node not found, build hash tree. bool _ok = false; i64 hash2 = _get_hash(bn, &_ok); logd("init hash: %p\n", hash2); ASSERT(_ok); bool changed = false; while(oct_has_super(bn)){ bn = oct_get_super(bn); hash2 = iron_hash(&hash2, sizeof(hash2)); logd("next hash: %p\n", hash2); changed = true; } ASSERT(changed); hash_node * new_node = alloc0(sizeof(hash_node)); new_node->type = HASH64; new_node->hash = hash2; add_entity(bn, (entity_header *) new_node); gd->hashed_node = bn; } { //now it should be possible to find a hash for n bool ok = false; i64 hash = _get_hash(n, &ok); logd("Final: %p\n", hash); ASSERT(ok); return hash; } }
oct_node * oct_create(){ return alloc0(sizeof(oct_node)); }
game_data * load_game_data(){ game_data * gd = alloc0(sizeof(game_data)); /*texture_asset * tile22 = renderer_load_texture(rnd2, "../racket_octree/tile62.png"); texture_asset * tile25 = renderer_load_texture(rnd2, "../racket_octree/tile72.png"); texture_asset * tile3 = renderer_load_texture(rnd2, "../racket_octree/tile2x2.png"); texture_asset * tile1 = renderer_load_texture(rnd2, "../racket_octree/tile1.png"); // texture_asset * guy = renderer_load_texture(rnd2, "../racket_octree/guy2.png"); //texture_asset * guy = renderer_load_texture(rnd2, "../racket_octree/guy3.png"); texture_asset * guy = renderer_load_texture(rnd2, "mannie.png"); texture_asset * guyupper = renderer_clone_texture(guy); texture_asset * tile4 = renderer_load_texture(rnd2, "../racket_octree/tile6.png"); texture_asset * tile5 = renderer_load_texture(rnd2, "../racket_octree/tile8.png"); texture_asset * rock_small = renderer_load_texture(rnd2, "../racket_octree/rock_small.png"); texture_asset * tree1 = renderer_load_texture(rnd2, "../racket_octree/tree1.png"); texture_asset * tree2 = renderer_load_texture(rnd2, "../racket_octree/tree2.png"); texture_asset * tree3 = renderer_load_texture(rnd2, "../racket_octree/tree3.png"); texture_asset * foilage = renderer_load_texture(rnd2, "../racket_octree/foilage.png"); texture_asset * fireplace = renderer_load_texture(rnd2, "../racket_octree/fireplace.png"); texture_asset * buggy = renderer_load_texture(rnd2, "../racket_octree/buggy.png"); texture_asset * cat = renderer_load_texture(rnd2, "../racket_octree/cat.png"); texture_asset * select_cube = renderer_load_texture(rnd2, "../racket_octree/select_cube.png"); texture_asset_set_offset(tile22, vec2mk(0, -42)); texture_asset_set_offset(tile25, vec2mk(0, -42)); texture_asset_set_offset(tile5, vec2mk(0, -42)); texture_asset_set_offset(tile4, vec2mk(0, -42)); texture_asset_set_offset(tile3, vec2mk(0, - 77)); texture_asset_set_offset(tile1, vec2mk(0, -23)); texture_asset_set_offset(rock_small, vec2mk(0, -19)); texture_asset_set_offset(guy, vec2mk(0, -70)); texture_asset_set_offset(guyupper, vec2mk(0, -42)); texture_asset_set_offset(buggy, vec2mk(0, -42)); texture_asset_set_offset(cat, vec2mk(0, -42)); texture_asset_set_offset(select_cube, vec2mk(0, -42)); texture_asset_set_size(guyupper, (vec2i){40, 40}); texture_asset_set_offset(tree1, vec2mk(0, -42)); texture_asset_set_offset(tree2, vec2mk(0, -42)); texture_asset_set_offset(tree3, vec2mk(0, -42)); texture_asset_set_offset(foilage, vec2mk(0, -42)); texture_asset_set_offset(fireplace, vec2mk(0, -42)); game_data_add_tile(gd, tile22); game_data_add_tile(gd, tile25); game_data_add_tile(gd, tile3); game_data_add_tile(gd, tile1); game_data_add_tile(gd, tile4); game_data_add_tile(gd, tile5); game_data_add_tile(gd, rock_small); game_data_add_tile(gd, tree1); game_data_add_tile(gd, tree2); game_data_add_tile(gd, tree3); game_data_add_tile(gd, foilage); game_data_add_sprite(gd, guy); game_data_add_sprite(gd, guyupper); game_data_add_sprite(gd, fireplace); game_data_add_sprite(gd, buggy); game_data_add_sprite(gd, cat); game_data_add_sprite(gd, select_cube);*/ gd->loaded_nodes = ht_create(1024, sizeof(oct_node), 4); gd->enemies = ht_create(1024, 8, 4); return gd; }
image * image_new(int width, int height, image_pixel_type type){ void * buffer = alloc0(width * height * image_pixel_type_size(type)); image _pt = {.type = type, .width = width, .height = height, .buffer = buffer }; return iron_clone(&_pt, sizeof(_pt)); }
void* libbf_compiler_dynalloc_init(ExecutableCodeData_t* executableCodeData, OFFSET_t min_delta_offset, OFFSET_t max_delta_offset, int sizeof_my_type, void* executable_code, int size_of_executable_code, void* init_data_ptr, int count_active_pages, AdvancedOptions_t* options) { #if !defined(WIN32) struct sigaction action; sigset_t block_mask; #endif int ret; long pagesize = libbf_getpagesize(); DynAllocDesc* dynAllocDesc = alloc0(DynAllocDesc, 1); void* mem; int reserved_size; int count_low_pages = (min_delta_offset * sizeof_my_type + pagesize - 1) / pagesize; /* ceil rounding */ int count_high_pages = (max_delta_offset * sizeof_my_type + pagesize - 1) / pagesize; /* ceil rounding */ if (count_active_pages <= 0) count_active_pages = NB_MIN_ACTIVE_PAGES; /* number of initial regular pages */ reserved_size = (count_low_pages + count_active_pages + count_high_pages) * pagesize; mem = libbf_alloc_aligned(pagesize, reserved_size); if (mem == NULL) fatal("alloc_aligned failed"); memset(mem, 0, reserved_size); if (init_data_ptr) memcpy((void*)((long)mem + count_low_pages * pagesize), init_data_ptr, count_active_pages * pagesize); dynAllocDesc->executableCodeData = *executableCodeData; dynAllocDesc->executableCodeData.input_output_data = dynAllocDesc; dynAllocDesc->executableCodeData.base_data_ptr = (void*)((long)mem + count_low_pages * pagesize); dynAllocDesc->signature1 = SIGNATURE_1; dynAllocDesc->signature2 = SIGNATURE_2; dynAllocDesc->sizeof_elt = sizeof_my_type; dynAllocDesc->increase_from_low = 0; dynAllocDesc->increase_from_high = 0; dynAllocDesc->current_mem = mem; dynAllocDesc->count_low_pages = count_low_pages; dynAllocDesc->count_active_pages = count_active_pages; dynAllocDesc->count_high_pages = count_high_pages; dynAllocDesc->max_total_pages = -1; /* unlimited */ dynAllocDesc->current_executable_code = executable_code; dynAllocDesc->size_of_executable_code = size_of_executable_code; dynAllocDesc->options = options; dynAllocDesc->isInterrupted = FALSE; dynAllocDesc->sigalarm_set = FALSE; dynAllocDesc->sigalarm_active = FALSE; #if !defined(WIN32) action.sa_sigaction = libbf_compiler_dynalloc_handler; sigemptyset(&(action.sa_mask)); action.sa_flags = SA_SIGINFO; sigemptyset(&block_mask); sigaddset(&block_mask, SIGALRM); action.sa_mask = block_mask; ret = sigaction(SIGBUS, &action, &dynAllocDesc->old_action_sigbus); if (ret != 0) fatal("sigaction failed"); ret = sigaction(SIGSEGV, &action, &dynAllocDesc->old_action_sigsegv); if (ret != 0) fatal("sigaction failed"); #endif #if defined(WIN32) if (options && options->stop_after_ms > 0) { dynAllocDesc->hasStarted = FALSE; dynAllocDesc->start_time = GetTickCount(); _beginthreadex(NULL, 0, libbf_compiler_timer_handler_win32, dynAllocDesc, 0, 0); while(dynAllocDesc->hasStarted == FALSE) Sleep(100); } #elif (defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__)) && (defined(__i386__) || defined(__x86_64__)) if (options && (options->stop_after_ms > 0 || options->average_load > 0)) { struct itimerval tv; tv.it_interval.tv_sec = 0; tv.it_interval.tv_usec = 0; if (options->average_load == 0) { tv.it_value.tv_sec = options->stop_after_ms / 1000; tv.it_value.tv_usec = (options->stop_after_ms % 1000) * 1000; } else { tv.it_value.tv_sec = 0; tv.it_value.tv_usec = TIMER_RESOLUTION; } setitimer(ITIMER_REAL, &tv, NULL); action.sa_sigaction = libbf_compiler_timer_handler; sigemptyset(&(action.sa_mask)); action.sa_flags = SA_SIGINFO; memcpy(&dynAllocDesc->saved_action_sigalrm, &action, sizeof(struct sigaction)); ret = sigaction(SIGALRM, &action, &dynAllocDesc->old_action_sigalrm); if (ret != 0) fatal("sigaction failed"); gettimeofday(&dynAllocDesc->start_tv, NULL); dynAllocDesc->sigalarm_set = TRUE; dynAllocDesc->sigalarm_active = TRUE; } #endif /* Lock low and high pages, upper reserved page and checker description page */ ret = libbf_mprotect(mem, pagesize * count_low_pages, PROT_NONE); ret |= libbf_mprotect((void*)((long)mem + (count_low_pages + count_active_pages) * pagesize), (count_high_pages) * pagesize, PROT_NONE); if (ret != 0) fatal("mprotect failed"); return dynAllocDesc; }
static void CONCAT(CONCAT(LIBBF_INTERPRETER_OPTIMIZER_RADIX, internal_), MY_TYPE_T_STR) (OptimizationUnit* code, OFFSET_t min_delta_offset, OFFSET_t max_delta_offset) { #if defined(GOTO_ADDR_SUPPORTED) DECLARE_LABEL(BF_AFFECT_EXPR); DECLARE_LABEL(BF_INC_DATA_PTR); DECLARE_LABEL(BF_PRINT_DATA); DECLARE_LABEL(BF_READ_DATA); DECLARE_LABEL(BF_WHILE_DATA); DECLARE_LABEL(BF_END_WHILE); DECLARE_LABEL(BF_END); #ifndef PROFILE DECLARE_LABEL(BF_SET_CST); DECLARE_LABEL(BF_SET_CST_0); DECLARE_LABEL(BF_INC_CST); DECLARE_LABEL(BF_INC_CST_1); DECLARE_LABEL(BF_INC_CST_M_1); DECLARE_LABEL(BF_SET_DATA); DECLARE_LABEL(BF_INC_DATA); DECLARE_LABEL(BF_DEC_DATA); DECLARE_LABEL(BF_INC_CST_MUL_DATA); DECLARE_LABEL(BF_INC_CST_ADD_DATA); DECLARE_LABEL(BF_INC_DATA_MUL_DATA); DECLARE_LABEL(BF_WHILE_INC_DATA_PTR); #ifdef USE_END_WHILE_INC_DATA_PTR DECLARE_LABEL(BF_END_WHILE_INC_DATA_PTR); #endif #else DECLARE_LABEL(BF_NOP); #endif DECLARE_LABEL(BF_DYNALLOC_REALLOC_NEEDED); #ifdef __cplusplus static const void* tab_addr[BF_COUNT_INSTR]; #else static const void* tab_addr[BF_COUNT_INSTR] = { #endif FILL_TAB_ADDR(BF_AFFECT_EXPR) FILL_TAB_ADDR(BF_INC_DATA_PTR) FILL_TAB_ADDR(BF_PRINT_DATA) FILL_TAB_ADDR(BF_READ_DATA) FILL_TAB_ADDR(BF_WHILE_DATA) FILL_TAB_ADDR(BF_END_WHILE) FILL_TAB_ADDR(BF_END) #ifndef PROFILE FILL_TAB_ADDR(BF_SET_CST) FILL_TAB_ADDR(BF_SET_CST_0) FILL_TAB_ADDR(BF_INC_CST) FILL_TAB_ADDR(BF_INC_CST_1) FILL_TAB_ADDR(BF_INC_CST_M_1) FILL_TAB_ADDR(BF_SET_DATA) FILL_TAB_ADDR(BF_INC_DATA) FILL_TAB_ADDR(BF_DEC_DATA) FILL_TAB_ADDR(BF_INC_CST_MUL_DATA) FILL_TAB_ADDR(BF_INC_CST_ADD_DATA) FILL_TAB_ADDR(BF_INC_DATA_MUL_DATA) FILL_TAB_ADDR(BF_WHILE_INC_DATA_PTR) #ifdef USE_END_WHILE_INC_DATA_PTR FILL_TAB_ADDR(BF_END_WHILE_INC_DATA_PTR) #endif #else FILL_TAB_ADDR(BF_NOP) #endif FILL_TAB_ADDR(BF_DYNALLOC_REALLOC_NEEDED) #ifndef __cplusplus }; #endif #endif void* void_data_ptr; #if defined(DEBUG_INTERPRETER) || defined(__CYGWIN__) || defined(PROFILE) void* ori_data_ptr; unsigned MY_TYPE_T* data_ptr; void* current_code_ptr; #else void* old_action; register unsigned MY_TYPE_T* data_ptr; #endif register OptimizationUnit* code_ptr; #ifdef PROFILE long long count_instr = 0; #endif register OFFSET_t offset; #if defined(GOTO_ADDR_SUPPORTED) libbf_optimized_code_resolve_interpeter_addr(code, tab_addr); #endif #if defined(DEBUG_INTERPRETER) || defined(__CYGWIN__) || defined(PROFILE) void_data_ptr = alloc0(MY_TYPE_T, 32768); ori_data_ptr = void_data_ptr; data_ptr = ((unsigned MY_TYPE_T*)void_data_ptr) + 1024; void_data_ptr = data_ptr; current_code_ptr = NULL; #else libbf_interpreter_dynalloc_init(min_delta_offset, max_delta_offset, sizeof(MY_TYPE_T), code, #if defined(GOTO_ADDR_SUPPORTED) tab_addr[BF_DYNALLOC_REALLOC_NEEDED], #else NULL, #endif &old_action, &void_data_ptr); data_ptr = (unsigned MY_TYPE_T*)void_data_ptr; #endif code_ptr = code; #if defined(GOTO_ADDR_SUPPORTED) /* Start up execution ! */ SAFE_JUMP_TO(code_ptr->ou_interpreter_addr); /* safe jump to begin... */ #else while(1) { switch(code_ptr->ou_instr) { #endif LABEL(BF_AFFECT_EXPR) DEAL_INSTR(); data_ptr[offset] = CONCAT(libbf_compute_expr_,MY_TYPE_T_STR)(code_ptr->ou_expr, data_ptr); SAFE_NEXT_INSTR(); /* safe because of function call */ LABEL(BF_INC_DATA_PTR) DEAL_INSTR(); data_ptr += offset; NEXT_INSTR(); LABEL(BF_PRINT_DATA) DEAL_INSTR(); putchar(data_ptr[offset]); SAFE_NEXT_INSTR(); /* safe because of function call */ LABEL(BF_READ_DATA) DEAL_INSTR(); data_ptr[offset] = getchar(); SAFE_NEXT_INSTR(); /* safe because of function call */ LABEL(BF_WHILE_DATA) DEAL_INSTR(); if (data_ptr[offset] == 0) { code_ptr = code_ptr->ou_jump_to; JUMP_TO(code_ptr->ou_interpreter_addr); } NEXT_INSTR(); LABEL(BF_END_WHILE) DEAL_INSTR(); if (data_ptr[offset] != 0) { code_ptr = code_ptr->ou_jump_to; JUMP_TO(code_ptr->ou_interpreter_addr); } NEXT_INSTR(); #ifndef PROFILE /* Very common subcases of BF_AFFECT_EXPR, so much more efficient to create */ /* dedicated opcodes */ LABEL(BF_SET_CST) DEAL_INSTR(); data_ptr[offset] = code_ptr->ou_constant; NEXT_INSTR(); LABEL(BF_SET_CST_0) DEAL_INSTR(); data_ptr[offset] = 0; NEXT_INSTR(); LABEL(BF_INC_CST) DEAL_INSTR(); data_ptr[offset] += code_ptr->ou_constant; NEXT_INSTR(); LABEL(BF_INC_CST_1) DEAL_INSTR(); data_ptr[offset] ++; NEXT_INSTR(); LABEL(BF_INC_CST_M_1) DEAL_INSTR(); data_ptr[offset] --; NEXT_INSTR(); LABEL(BF_SET_DATA) DEAL_INSTR(); data_ptr[offset] = data_ptr[code_ptr->ou_offset2]; NEXT_INSTR(); LABEL(BF_INC_DATA) DEAL_INSTR(); data_ptr[offset] += data_ptr[code_ptr->ou_offset2]; NEXT_INSTR(); LABEL(BF_DEC_DATA) DEAL_INSTR(); data_ptr[offset] -= data_ptr[code_ptr->ou_offset2]; NEXT_INSTR(); LABEL(BF_INC_CST_ADD_DATA) DEAL_INSTR(); data_ptr[offset] += code_ptr->ou_constant + data_ptr[code_ptr->ou_offset2]; NEXT_INSTR(); LABEL(BF_INC_CST_MUL_DATA) DEAL_INSTR(); data_ptr[offset] += code_ptr->ou_constant * data_ptr[code_ptr->ou_offset2]; NEXT_INSTR(); LABEL(BF_INC_DATA_MUL_DATA) DEAL_INSTR(); data_ptr[offset] += data_ptr[code_ptr->ou_offset2] * data_ptr[code_ptr->ou_offset3]; NEXT_INSTR(); #ifdef USE_END_WHILE_INC_DATA_PTR LABEL(BF_END_WHILE_INC_DATA_PTR) DEAL_INSTR(); data_ptr += code_ptr->ou_offset2; if (data_ptr[offset] != 0) { code_ptr = code_ptr->ou_jump_to; JUMP_TO(code_ptr->ou_interpreter_addr); } NEXT_INSTR(); #endif #define INC_PTR_WITH_BYTES(ptr, bytes) ptr = (unsigned MY_TYPE_T*)(((long)ptr) + bytes) LABEL(BF_WHILE_INC_DATA_PTR) { register int offset2_bytes; DEAL_INSTR(); offset2_bytes = sizeof(MY_TYPE_T) * code_ptr->ou_offset2; data_ptr += offset; while (*data_ptr) { INC_PTR_WITH_BYTES(data_ptr, offset2_bytes); } data_ptr -= offset; SAFE_NEXT_INSTR(); } #else LABEL(BF_NOP) DEAL_INSTR(); NEXT_INSTR(); #endif LABEL(BF_END) #if !(defined(DEBUG_INTERPRETER)|| defined(__CYGWIN__) || defined(PROFILE)) libbf_interpreter_dynalloc_end(old_action, data_ptr); #else free(ori_data_ptr); #endif #ifdef PROFILE libbf_dump_profiled_code(code); fprintf(stderr, "normal exit : %lld instructions executed\n", count_instr); #endif return; LABEL(BF_DYNALLOC_REALLOC_NEEDED) { long shift = libbf_interpreter_dynalloc_realloc(data_ptr); data_ptr += shift; if (shift == 0) { #if !(defined(DEBUG_INTERPRETER)|| defined(__CYGWIN__) || defined(PROFILE)) libbf_interpreter_dynalloc_end(old_action, data_ptr); #else free(ori_data_ptr); #endif #ifdef PROFILE fprintf(stderr, "abnormal exit (not enough memory) : %lld instructions executed\n", count_instr); #endif return; } SAFE_JUMP_TO(code_ptr->ou_interpreter_addr); /* safe because of function call */ } #if !defined(GOTO_ADDR_SUPPORTED) default: SHOULDNT_HAPPEN(); } } #endif }