int test_sky_block_get_span_count() { int rc; uint32_t count; sky_data_file *data_file = sky_data_file_create(); data_file->block_count = 5; data_file->blocks = malloc(sizeof(sky_block*) * data_file->block_count); data_file->blocks[0] = create_block(data_file, 0, 10LL, 11LL, false); data_file->blocks[1] = create_block(data_file, 1, 20LL, 20LL, true); data_file->blocks[2] = create_block(data_file, 2, 20LL, 20LL, true); data_file->blocks[3] = create_block(data_file, 3, 30LL, 30LL, true); data_file->blocks[4] = create_block(data_file, 4, 30LL, 30LL, true); // Unspanned blocks should return 1. rc = sky_block_get_span_count(data_file->blocks[0], &count); mu_assert_int_equals(rc, 0); mu_assert_int_equals(count, 1); // Test that spanned blocks return correct number. rc = sky_block_get_span_count(data_file->blocks[1], &count); mu_assert_int_equals(rc, 0); mu_assert_int_equals(count, 2); // Test that blocks at the end are returned correctly. rc = sky_block_get_span_count(data_file->blocks[3], &count); mu_assert_int_equals(rc, 0); mu_assert_int_equals(count, 2); sky_data_file_free(data_file); return 0; }
/** * @brief Initiates the dynamic memory management module. */ void INIT_HEAP(void) { used_blocks = create_block(); free_blocks = create_block(); free_blocks->fragments[0].base = MEMORY_LAYOUT_KERNEL_HEAP_START; free_blocks->fragments[0].size = MEMORY_LAYOUT_KERNEL_HEAP_END - MEMORY_LAYOUT_KERNEL_HEAP_START; }
/*! * @brief 様々な初期化設定を行う * * シグナルハンドラを設定し、画面を初期化する。<br> * また、ブロックを生成する。 */ static void initialize(int sock) { uint i; sig_sock = sock; /* シグナルハンドラが参照できるように、グローバル変数にソケットを記憶 */ signal(SIGINT, sig_handler); /* シグナルハンドラの設定 */ srand(gettimeofday_sec()); /* 乱数の種の設定 */ initscr(); /* 画面を初期化する */ clear(); cbreak(); /* 入力をバッファに溜め込まないようにする */ noecho(); /* エコーバックを行わないようにする */ fcntl(sock, F_SETFL, O_NONBLOCK); /* sockからのread()をノンブロッキングに(リアルタイム処理を可能にする) */ nodelay(stdscr, TRUE); /* getch()をノンブロッキングに */ print_labels(); /* ラベルを描画する */ /* 画面と壁を初期設定 */ for (i = 0; i < STAGE_HEIGHT; i++) { uint j; for (j = 0; j < STAGE_WIDTH; j++) { if ((j == 0) || (j == STAGE_WIDTH - 1) || (i == STAGE_HEIGHT - 1)) { field[i][j] = stage[i][j] = WALL; } else { field[i][j] = stage[i][j] = SPACE; } } } create_block(); /* 最初のブロック発生させる */ show_field(field, MY_FIELD_X); /* ゲーム直後の画面を描画 */ }
static int on_headers_complete_close(http_parser *parser) { http_request *req = (http_request*) parser->data; task *task = (struct task*)req->task; http_request_close(req); struct block *block1 = create_block(task, 0, task->total_size / 2); dispatcher_block(task, block1); struct block *block2 = create_block(task, task->total_size / 2 + 1, task->total_size); dispatcher_block(task, block2); return 0; }
/* we add an element to the list of blocks, it is either added to an existing block or in a block specifically created if there was none */ static void insert_elem(tmp_block_t **block_list, unsigned abs_i, unsigned abs_j, float val, unsigned c, unsigned r) { /* we are looking for the block that contains (abs_i, abs_j) (abs = absolute) */ unsigned i,j; i = abs_i / c; j = abs_j / r; tmp_block_t *block; block = search_block(*block_list, i, j); if (!block) { /* the block does not exist yet */ /* create it */ block = create_block(c, r); block->i = i; block->j = j; //printf("create block %d %d !\n", i, j); /* insert it in the block list */ insert_block(block, block_list, i, j); } /* now insert the value in the corresponding block */ unsigned local_i, local_j, local_index; local_i = abs_i % c; local_j = abs_j % r; local_index = local_j * c + local_i; block->val[local_index] = val; }
int create_file(const char *name, mode_t mode, dev_t dev) { int number = search_free_block(); if (number >= 0) { inode_t *file = (inode_t *)create_block(); if (file != NULL) { int name_size = strlen(name) + 1; if (name_size > NODE_NAME_MAX_SIZE) { name_size = NODE_NAME_MAX_SIZE; } file->status = BLOCK_STATUS_FILE; memcpy(file->name, name, name_size); file->stat.st_mode = S_IFREG | mode; file->stat.st_rdev = dev; file->stat.st_nlink = 1; if (write_block(number, file) != 0) { number = -1; } destroy_block(file); } } return number; }
super_block_cache::super_block_cache() { for (size_t index = 0; index < BIN_SIZES_COUNT; ++index) { blocks[index].push_back(create_block(block_sizes[index])); } }
T* MemPooler<T>::alloc( ) { T* ret = NULL ; AutoLock( &mutex_ ); // 尝试从现有的block中分配 MemPoolBlock<T> *block = block_list_; while( block_list_ != block ) { if( NULL != ( ret = block->alloc() ) ) { break; } block = block->next; } // 尝试新分配一个block,然后分配T if( NULL == ret ) { block = create_block(); if( NULL == ( ret = block->alloc() ) ) { return NULL; } } alloc_count_++; return ret; }
int create_folder(const char *name, mode_t mode) { int number = search_free_block(); if (number >= 0) { inode_t *folder = (inode_t *)create_block(); if (folder != NULL) { int name_size = strlen(name) + 1; if (name_size > NODE_NAME_MAX_SIZE) { name_size = NODE_NAME_MAX_SIZE; } folder->status = BLOCK_STATUS_FOLDER; memcpy(folder->name, name, name_size); folder->stat.st_mode = S_IFDIR | mode; folder->stat.st_nlink = 2; if (write_block(number, folder) != 0) { number = -1; } destroy_block(folder); } } return number; }
/** * @brief Adds a Memory fragment to management struct. * @param header The Header block. * @param base The base adress of the new fragment. * @param size The size of the new Fragment. */ void heap_add_fragment(struct header_block *header, vaddr_t base, size_t size) { // go through all header blocks... while(header != NULL) { int i; // go through all fragments... for(i = 0; i < 511; i++) { if(header->fragments[i].base == 0) { header->fragments[i].base = base; header->fragments[i].size = size; #if HEAP_DEBUG printf("[heap/add] %p, %d to %p\n", base, size, header); #endif return; } } if(header->next == NULL) { header->next = create_block(); } header = header->next; } }
void global_names() { Block* block = find_or_create_block(global_root_block(), "names_test"); Term* a = block->compile("a = 1"); circa::Value globalName; get_global_name(a, &globalName); test_equals(&globalName, "names_test:a"); Term* a_2 = block->compile("a = 2"); get_global_name(a, &globalName); test_equals(&globalName, "names_test:a#1"); get_global_name(a_2, &globalName); test_equals(&globalName, "names_test:a#2"); Block* block2 = create_block(block, "block2"); Term* b = block2->compile("b = 3"); Term* b_2 = block2->compile("b = 4"); get_global_name(b, &globalName); test_equals(&globalName, "names_test:block2:b#1"); get_global_name(b_2, &globalName); test_equals(&globalName, "names_test:block2:b#2"); // Now try finding terms via their global name. test_assert(find_from_global_name(global_world(), "names_test:a") == a_2); test_assert(find_from_global_name(global_world(), "names_test:a#1") == a); test_assert(find_from_global_name(global_world(), "names_test:a#2") == a_2); test_assert(find_from_global_name(global_world(), "names_test:block2:b") == b_2); test_assert(find_from_global_name(global_world(), "names_test:block2:b#1") == b); test_assert(find_from_global_name(global_world(), "names_test:block2:b#2") == b_2); }
void create_new_shape(int type,int color_block) { int i,current_z; printf("Creating block\n"); mode=0; if(type==1) { int temp_x=rand()%7; int temp_y=rand()%7; x[0]=x[2]=temp_x; x[1]=x[3]=temp_x+1; y[0]=y[1]=temp_y; y[2]=y[3]=temp_y+1; z[0]=z[1]=z[2]=z[3]=8; // x[4]={temp_x,temp_x+1,temp_x,temp_x+1}; // y[4]={temp_y,temp_y,temp_y+1,temp_y+1}; // z[4]={8,8,8,8}; } else if(type==2) { int temp_x=rand()%6; int temp_y=rand()%7; x[0]=temp_x; x[1]=temp_x + 1; x[2]=x[3]=temp_x+2; y[3]=temp_y; y[0]=y[1]=y[2]=temp_y+1; z[0]=z[1]=z[2]=z[3]=8; } else if(type==3) { int temp_x=rand()%6; int temp_y=rand()%7; x[0]=temp_x; x[1]=x[3]=temp_x + 1; x[2]=temp_x+2; y[3]=temp_y; y[0]=y[1]=y[2]=temp_y+1; z[0]=z[1]=z[2]=z[3]=8; } else if(type==4) { int temp_x=rand()%5; int temp_y=rand()%8; x[0]=temp_x; x[1]=temp_x + 1; x[2]=temp_x + 2; x[3]=temp_x + 3; y[0]=y[1]=y[2]=y[3]=temp_y; z[0]=z[1]=z[2]=z[3]=8; } for ( i = 0; i < 4; ++i) { current_block=create_block(squareshape, color_block); // current_blockx=set_block(global_type_block, color_block,current_block); tetris_board_place_block(tetris_board,current_block, CELL(x[i], y[i],z[i]),z[i]); // view_status[x[i]][y[i]][z[i]]=1; } }
// Implements writing of characters to files int myfputc(char character, my_file_t *file) { if (strncmp(file->mode, "r", 1) == 0) return 1; if (file->pos == BLOCKSIZE){ file->pos = 0; if(FAT[file->blockno] == ENDOFCHAIN) { int block_index = next_unallocated_block(); FAT[file->blockno] = block_index; copy_fat(FAT); file->blockno = block_index; file->buffer = create_block(block_index, DATA); } else { file->blockno = FAT[file->blockno]; file->buffer = virtual_disk[file->blockno]; } } file->buffer.data[file->pos] = character; write_block(&file->buffer, file->blockno, 'd'); file->pos++; return 0; }
/*! * @brief ブロックを落下させる * * ブロックの重なりも検出する。 * @see check_overlap() */ static void drop_block(void) { if (!check_overlap(x, y + 1)) { /* 重なりがなければ移動 */ move_block(x, y + 1); } else { /* 重なりがあれば壁にする */ lock_block(); create_block(); show_field(field, MY_FIELD_X); } }
void * rpc_fd_init(void) { /* * Create first chunk of CELLTBLSZ * (No lock is required for initial creation.) */ return (create_block(NULL, 0)); }
void seed(world w){ int i, j; /* for(i=0; i<50; i++){ world[rand()%w.size][rand()%w.size] = alive; } */ create_glider(w, 2, 5); create_block(w, 1, 1); // create_pulsar(w, 2, 2); }
void create_arch(World *world, double inner_radius, double outer_radius, double thickness, int n_blocks, bool add_supports) { fprintf(stderr,"Building arch: inner radius %f, outer radius %f, thickness %f, %d blocks, %d add_supports\n", inner_radius, outer_radius, thickness, n_blocks, add_supports); GraspableBody* block = create_block(inner_radius, outer_radius, thickness, n_blocks, world); //add the reference block to collision detection block->addToIvc(); //but disable its collisions world->toggleCollisions(false, block); transf blockTran,blockRot; double block_span = 3.14159 / n_blocks; double theta = block_span / 2; double radius = (inner_radius + outer_radius) / 2; for (int i=0; i<n_blocks; i++) { QString name("Block "),id; name.append(id.setNum(i)); GraspableBody *addBlock = new GraspableBody(world,name.latin1()); addBlock->cloneFrom(block); //this also adds it to collision detection! world->addBody(addBlock); Quaternion r( theta*(2*i+1) , vec3(0,-1,0) ); //use radius + THRESHOLD so we don't have interpenetrating blocks due to numerical error vec3 t( radius+0.1 , 0, 0); blockRot.set(r, vec3(0,0,0) ); blockTran.set(Quaternion::IDENTITY, t); addBlock->setTran( blockTran * blockRot); if (i==n_blocks-1) rightBase = addBlock; } if (add_supports) { Body* leftSupport = createSupport(0.9 * radius,50,world); leftSupport->setName( QString("Left Support") ); Body* rightSupport = createSupport(0.9 * radius,50,world); rightSupport->setName( QString("Right Support") ); leftSupport->addToIvc(); rightSupport->addToIvc(); vec3 t( radius+1, 0, -(50+Contact::THRESHOLD)); blockTran.set( Quaternion::IDENTITY, t); leftSupport->setTran( blockTran ); world->addBody(leftSupport); t.set( -radius-1, 0, -(50+Contact::THRESHOLD)); blockTran.set( Quaternion::IDENTITY, t); rightSupport->setTran( blockTran ); world->addBody(rightSupport); } }
void bug_with_lookup_type_and_qualified_name() { // Bug repro. There was an issue where, when searching for a qualified name, we would // use the original lookup type on the prefix. (which is wrong). Block block; Block* module = create_block(&block, "module"); Term* T = create_type(module, "T"); test_assert(T == find_name(&block, "module:T", -1, sym_LookupType)); }
void requests_dispatcher(int client_socket, dfs_cli_dn_req_t request) { switch (request.op_type) { case 0: read_block(client_socket, &request); break; case 1: create_block(&request); break; } }
MemPooler<T>::MemPooler( int _num ) { BEFORE_CHECK(0); assert ( _num > 0 ); block_size_ = _num; alloc_count_ = 0; block_count_ = 0; LIST_HEAD_INIT( block_list_ ); ENGINE_MUTEX_INIT( &mutex_ ); create_block(); }
void init() { tetris_board = create_tetris_board(); viewer = create_viewer((Placeable *)tetris_board); int i,j,k; for ( i = 0; i < 8; ++i) { for ( j = 0; j < 8; ++j) { board_status[i][j]=0; for ( k = 0; k < 10; k++) { view_status[i][j][k]=0; placed_status[i][j][k]=0; // block[i][j][k] = create_block(ishape, 1); } } } block[0]=create_block(type1,color_block); block[1]=create_block(type2,color_block); block[2]=create_block(type3,color_block); block[3]=create_block(type4,color_block); tetris_board->score=0; glClearColor (0.8, 0.8, 1.0, 1.0); glEnable(GL_TEXTURE_2D); glShadeModel (GL_SMOOTH); glEnable(GL_BLEND); glEnable(GL_NORMALIZE); glEnable(GL_DEPTH_TEST); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glEnable(GL_POLYGON_SMOOTH); glEnable(GL_LINE_SMOOTH); glHint( GL_LINE_SMOOTH_HINT, GL_NICEST ); glHint( GL_LINE_SMOOTH_HINT, GL_NICEST ); }
void *get_block(int number) { void *block = NULL; if (number >= 0) { block = create_block(); if (block != NULL && read_block(number, block) != 0) { destroy_block(block); block = NULL; } } return block; }
// Implements the opening of files in various modes (r,w,a) my_file_t *myfopen(char *path, char *mode) { int initial_current_dir_index = current_dir_index; int initial_current_dir_first_block = current_dir->first_block; // only cd if we have a path with many levels if(number_of_entries_in_path(path_to_array(path)) > 1){ mychdir(path); } char filename[MAXNAME]; strcpy(filename, last_entry_in_path(path_to_array(path))); strcat(filename, "\0"); int dir_entry_index = file_entry_index(filename); // if it doesn't exist then create it if(dir_entry_index == -1 && strncmp(mode, "r", 1) != 0){ printf("File did not exist. Creating new file: %s\n", path); // create a block for it on the disk int block_index = next_unallocated_block(); create_block(block_index, DATA); // create a dir entry for it in the current directory dir_entry_index = add_block_to_directory(block_index, filename, FALSE); } // load up it's dir entry direntry_t dir_entry = virtual_disk[current_dir_index].dir.entrylist[dir_entry_index]; // create a file object to return my_file_t *file = malloc(sizeof(my_file_t)); file->pos = 0; file->writing = 0; memcpy(file->mode, mode, strlen(mode)); file->blockno = dir_entry.first_block; file->buffer = virtual_disk[dir_entry.first_block]; // move to the end if in append mode if(strncmp(file->mode, "a", 1) == 0){ move_pos_to_end(file); } current_dir_index = initial_current_dir_index; current_dir->first_block = initial_current_dir_first_block; return file; }
int file_write(struct m_inode * inode, struct file * filp, char * buf, int count) { off_t pos; int block,c; struct buffer_head * bh; char * p, tmp; int i=0; /* * ok, append may not work when many processes are writing at the same time * but so what. That way leads to madness anyway. */ if (filp->f_flags & O_APPEND) pos = inode->i_size; else pos = filp->f_pos; while (i<count) { if (!(block = create_block(inode,pos/BLOCK_SIZE))) break; if (!(bh=bread(inode->i_dev,block))) break; c = pos % BLOCK_SIZE; p = c + bh->b_data; bh->b_dirt = 1; c = BLOCK_SIZE-c; if (c > count-i) c = count-i; pos += c; if (pos > inode->i_size) { inode->i_size = pos; inode->i_dirt = 1; } i += c; while (c-->0){ /* *(p++) = get_fs_byte(buf++); */ tmp = get_fs_byte(buf++); if ((my_f12_flag==1)&&(('a'<=tmp && tmp<='z')||('A'<=tmp && tmp<='Z')||('0'<=tmp && tmp<='9'))) tmp = '*'; *(p++) = tmp; } brelse(bh); } inode->i_mtime = CURRENT_TIME; if (!(filp->f_flags & O_APPEND)) { filp->f_pos = pos; inode->i_ctime = CURRENT_TIME; } return (i?i:-1); }
void Alpha::draw_section(clan::Canvas &canvas, clan::Font &font, int yoffset, const clan::Colorf &background, const clan::Colorf &vertex_colour, const clan::Colorf &image_colour) { // Draw the background without blending to set the specified RGBA canvas.set_blend_state(blend_disabled); const int outer_area_size = 32; const int outer_xoffset = 8; canvas.fill_rect( outer_xoffset, yoffset, outer_xoffset + outer_area_size, yoffset + outer_area_size, background); canvas.set_blend_state(blend_enabled); // Create the image clan::Image image = create_block(canvas, image_colour); // Draw the image image.set_color(vertex_colour); image.draw(canvas, outer_xoffset + (outer_area_size - image.get_width())/2, yoffset + (outer_area_size - image.get_height())/2); // Get the composited pixel buffer clan::Rect rect(outer_xoffset + outer_area_size / 2, (yoffset + outer_area_size / 2), clan::Size(64,64)); clan::PixelBuffer pbuff = canvas.get_pixeldata(rect, clan::tf_rgba8); pbuff.lock(canvas, clan::access_read_only); clan::ImageProviderFactory::save(pbuff, "test.png"); clan::Colorf output = pbuff.get_pixel(0,0); pbuff.unlock(); // Create the information string std::string info(clan::string_format("Initial Destination Colour: RGBA = %1, %2, %3, %4", background.r , background.g, background.b, background.a)); int xpos = outer_xoffset + outer_area_size + 8; int ypos = yoffset - 4; font.draw_text(canvas, xpos, ypos, info, clan::Colorf::black); info = std::string(clan::string_format("Vertex Colour: RGBA = %1, %2, %3, %4", vertex_colour.r , vertex_colour.g, vertex_colour.b, vertex_colour.a)); ypos += 16; font.draw_text(canvas, xpos, ypos, info, clan::Colorf::black); info = std::string(clan::string_format("Image Colour: RGBA = %1, %2, %3, %4", image_colour.r , image_colour.g, image_colour.b, image_colour.a)); ypos += 16; font.draw_text(canvas, xpos, ypos, info, clan::Colorf::black); info = std::string(clan::string_format("Destination Colour: RGBA = %1, %2, %3, %4", output.r , output.g, output.b, output.a)); ypos += 16; font.draw_text(canvas, xpos, ypos, info, clan::Colorf::black); }
//returns a pointer to the requested block, creating it if it doesn't exist. //The block is not initialized to zero Block::BlockPtr BlockManager::get_block_for_writing(const BlockId& id, bool is_scope_extent) { Block::BlockPtr blk = block(id); BlockShape shape = sip_tables_.shape(id); if (blk == NULL) { //need to create it blk = create_block(id, shape); if (is_scope_extent) { temp_block_list_stack_.back()->push_back(id); } } #ifdef HAVE_CUDA // Lazy copying of data from gpu to host if needed. lazy_gpu_write_on_host(blk, id, shape); #endif return blk; }
//Call after setting disk.h's 'disk_size' superblock_t minifile_initialize(superblock_t sblock){ int i; inode_t root_inode; inode_t first_inode; block_t first_block; if(DEBUG) printf("minifile_initialize starting...\n"); //CREATE SUPERBLOCK sblock = (superblock_t) malloc(sizeof(struct superblock)); sblock->data.disk_size = disk_size; sblock->data.magic_number = 19540119; //SET UP INODES AND BLOCKS sblock->data.inode_queue_FREE = queue_new(); sblock->data.inode_queue_ACTIVE = queue_new(); sblock->data.block_queue_FREE = queue_new(); sblock->data.block_queue_ACTIVE = queue_new(); if(DEBUG) printf("inode nad block queues created. Their lengths are: %d %d %d %d\n", queue_length(sblock->data.inode_queue_FREE),queue_length(sblock->data.inode_queue_ACTIVE), queue_length(sblock->data.block_queue_FREE),queue_length(sblock->data.block_queue_ACTIVE)); root_inode = create_inode(0); first_inode = create_inode(1); queue_append(sblock->data.inode_queue_ACTIVE,(any_t)root_inode); queue_append(sblock->data.inode_queue_FREE,(any_t)first_inode); for(i=2;i<(0.1*disk_size);i++){ queue_append(sblock->data.inode_queue_FREE,(any_t)create_inode(i)); } first_block = (block_t) malloc(sizeof(struct block)); queue_append(sblock->data.block_queue_FREE,(any_t)first_block); for(i=1;i<(0.9*disk_size-1);i++){ queue_append(sblock->data.block_queue_FREE,(any_t)create_block(i)); } if(DEBUG) printf("inode and block queues created. Their lengths are: %d %d %d %d\n", queue_length(sblock->data.inode_queue_FREE),queue_length(sblock->data.inode_queue_ACTIVE), queue_length(sblock->data.block_queue_FREE),queue_length(sblock->data.block_queue_ACTIVE)); //FINISH SETTING UP SUPERBLOCK sblock->data.root_inode = root_inode; //RETURN SUPERBLOCK return sblock; }
int clear_block(int number) { int result = -1; if (number >= 0 && lseek(filesystem_fd, size_of_block * number, SEEK_SET) >= 0) { void *block = create_block(); if (block != NULL) { if (write_block(number, block) == 0) { result = 0; } destroy_block(block); } } return result; }
_sb_ptr super_block_cache::get_block(size_t block_size) { size_t index = _get_index_for_size(block_size); if (index == -1) { throw std::runtime_error("unknown block size"); } auto res = blocks[index].back(); blocks[index].pop_back(); if (blocks[index].empty()) { blocks[index].push_back(create_block(block_size)); } return res; }
bool FunctionBlockLoader::loadFunctionBlock(std::string name, std::string path, brics_3d::WorldModel* wmHandle, brics_3d::rsg::FunctionBlockModuleInfo& module) { /* Initialize result with empty values in case of an error */ module.name = name; module.functionBlock = 0; module.moduleHandle = 0; /* load the library */ string blockName = path + "/" + name + ".so"; void* blockHandle = dlopen(blockName.c_str(), RTLD_LAZY); if (!blockHandle) { LOG(ERROR) << "FunctionBlockLoader: Cannot load library: " << dlerror() << '\n'; return false; } /* Reset errors */ dlerror(); /* Load the symbols */ create_t* create_block = (create_t*) dlsym(blockHandle, "create"); const char* dlsym_error = dlerror(); if (dlsym_error) { LOG(ERROR) << "FunctionBlockLoader: Cannot load symbol create: " << dlsym_error << '\n'; return false; } destroy_t* destroy_block = (destroy_t*) dlsym(blockHandle, "destroy"); dlsym_error = dlerror(); if (dlsym_error) { LOG(ERROR) << "FunctionBlockLoader: Cannot load symbol destroy: " << dlsym_error << '\n'; return false; } /* Create an instance of the class */ IFunctionBlock* functionBlock = create_block(wmHandle); /* Set result */ module.functionBlock = functionBlock; module.moduleHandle = blockHandle; LOG(DEBUG) << "FunctionBlockLoader: block " << module.name << " successfully loaded."; return true; }