int fdset_poll2(fdset *fds) {
int r, i;
while (1) {
FD_ZERO(&fds->rfds);
FD_ZERO(&fds->exfds);
FD_ZERO(&fds->wfds);
fds->max_fd = -1;
if (vector_empty(&fds->rev) && vector_empty(&fds->exev)) {
// We have nothing left to select(2) on.
return 0;
}
fdset_populate(fds, &fds->rfds, &fds->rev);
fdset_populate(fds, &fds->exfds, &fds->exev);
r = select(fds->max_fd+1, &fds->rfds, 0, &fds->exfds, &fds->timeout);
if (r < 0) {
if (errno != EINTR) {
perror("select");
return r;
}
continue;
}
if (r == 0) {
// Timeout case
fds->timeout_cb(NULL);
continue;
}
for (i = 0; i < vector_size(&fds->rev); ++i) {
select_event_t *pse = (select_event_t*)vector_at(&fds->rev, i);
if (FD_ISSET(pse->fd, &fds->rfds)) {
VERBOSE("FD %d is read ready\n", pse->fd);
pse->callback(pse->opaque);
}
}
for (i = 0; i < vector_size(&fds->exev); ++i) {
int rev_pos;
select_event_t se;
se = *(select_event_t*)vector_at(&fds->exev, i);
if (FD_ISSET(se.fd, &fds->exfds)) {
INFO("FD %d is in ERROR\n", se.fd);
// Also remove this fd from the list of ex/read events
// to monitor.
vector_erase(&fds->exev, i);
--i;
// Remove from read events list as well.
rev_pos = algorithm_find(&fds->rev, &se.fd, find_by_fd);
if (rev_pos != -1) {
vector_erase(&fds->rev, rev_pos);
}
se.callback(se.opaque);
} // if ()
} // for ()
} // while (1)
} // fdset_poll2()
//applies unit resolution to the cnf of sat state
//returns 1 if unit resolution succeeds, 0 if it finds a contradiction
BOOLEAN sat_unit_resolution(SatState* sat_state) {
BOOLEAN more = 1;
while (more) {
more = 0;
for (c2dSize i = vector_size(&sat_state->q); i >= 1; i--) {
Clause* clause = vector_get(&sat_state->q, i - 1);
clause->subsumed = sat_check_subsumed_clause(clause);
if (sat_subsumed_clause(clause)) {
vector_erase(&sat_state->q, i - 1);
continue;
}
BOOLEAN flag = 0;
c2dSize pos;
for (c2dSize j = 0; j < sat_clause_size(clause); j++) {
Lit* lit = vector_get(&clause->lits, j);
if (!sat_implied_literal(sat_opp_literal(lit))) {
flag++;
pos = j;
if (flag == 2)
break;
}
}
if (flag == 0) {
sat_state->ac = malloc(sizeof(Clause));
vector_init(&sat_state->ac->lits);
sat_state->ac->subsumed = 0;
sat_state->ac->mark = 0;
if (vector_size(&sat_state->ds) > 0) {
for (c2dSize j = 0; j < sat_var_count(sat_state); j++) {
Var* var = vector_get(&sat_state->vars, j);
var->u = var->level <= 1;
}
sat_get_assert_clause(sat_state, sat_state->ac, clause->index - 1, 0,
vector_size(&sat_state->s) - 1);
}
return 0;
}
if (flag == 1) {
Lit* lit = vector_get(&clause->lits, pos);
lit->implied = 1;
lit->locate = clause->index - 1;
lit->var->level = vector_size(&sat_state->ds) + 1;
vector_push(&sat_state->il, lit);
vector_push(&sat_state->s, lit);
clause->subsumed = 1;
vector_erase(&sat_state->q, i - 1);
more = 1;
}
}
}
return 1;
}
static void * helper_thread(void * ignore)
{
while (1)
{
queue_entry_t * qe;
char b = 1;
mutex_lock(&helper.mutex);
if (!vector_size(helper.queue))
{
helper.alive = 0;
mutex_unlock(&helper.mutex);
Dprintf("%s() EXIT\n", __FUNCTION__);
return NULL;
}
qe = vector_elt(helper.queue, 0);
// NOTE: vector_erase() is O(|helper.queue|). If this queue
// gets to be big we can change how this removal works.
vector_erase(helper.queue, 0);
mutex_unlock(&helper.mutex);
if (qe->action == QEMOUNT)
helper_thread_mount(qe->mount);
else if (qe->action == QEUNMOUNT)
{
helper_thread_unmount(qe->mount);
if (write(unmount_pipe[1], &b, 1) != 1)
perror("helper_thread: write");
}
memset(qe, 0, sizeof(*qe));
free(qe);
}
assert(0); // not reachable
return NULL; // placate compiler
}
void* client_thread(void* x)
#endif
{
puts("client_thread started");
unsigned int i;
while(1)
{
mutex_lock(&client_vector_mutex);
for(i = 0; i < clients.size; i++)
{
struct client* client = VECTOR_GET_AS(clients, i, struct client);
if(client_update(client) < 0)
{
puts("client disconnected!");
vector_erase(clients, i);
i--;
continue;
}
else
{
}
}
mutex_unlock(&client_vector_mutex);
}
#ifndef _WIN32
return NULL;
#endif
}
// ----------------------------------------------------------------------------
void
vertex_buffer_erase( vertex_buffer_t * self,
const size_t index )
{
ivec4 * item;
size_t vstart, vcount, istart, icount, i;
assert( self );
assert( index < vector_size( self->items ) );
item = (ivec4 *) vector_get( self->items, index );
vstart = item->vstart;
vcount = item->vcount;
istart = item->istart;
icount = item->icount;
// Update items
for( i=0; i<vector_size(self->items); ++i )
{
ivec4 * item = (ivec4 *) vector_get( self->items, i );
if( item->vstart > vstart)
{
item->vstart -= vcount;
item->istart -= icount;
}
}
self->state = FROZEN;
vertex_buffer_erase_indices( self, istart, istart+icount );
vertex_buffer_erase_vertices( self, vstart, vstart+vcount );
vector_erase( self->items, index );
self->state = DIRTY;
}
/* XXX Not using */
si_t application_quit()
{
si_t i, n;
struct object * addr;
/* 有多少个窗口 */
n = vector_size(&(global_application.window_vector));
/* 依次删除窗口 */
for(i = n - 1; i >= 0; -- i)
{
addr = vector_at(&global_application.window_vector, i);
/*
这里没有逐个注销窗口类对象或者它的派生类对象。
因为窗口管理程序收到用户应用程序的退出请求后，
会释放关于这个用户应用程序的所有资源。
*/
/* 释放这棵树 */
object_tree_free(addr->parent);
/* 从窗口向量中删除这个节点 */
vector_erase(&global_application.window_vector, i);
}
vector_exit(&global_application.window_vector);
event_listener_exit(&global_application.app_event_listener);
uds_exit(&global_application.uds);
free(global_application.name);
return 0;
}
void fdset_remove(fdset *fds, vector *v, int fd) {
int i;
for (i = 0; i < vector_size(v); ++i) {
select_event_t *pse = (select_event_t*)vector_at(v, i);
if (pse->fd == fd) {
vector_erase(v, i);
--i;
}
}
}
int iterator_erase(Vector* vector, Iterator* iterator) {
size_t index = iterator_index(vector, iterator);
if (vector_erase(vector, index) == VECTOR_ERROR) {
return VECTOR_ERROR;
}
*iterator = vector_iterator(vector, index);
return VECTOR_SUCCESS;
}
si_t application_exit()
{
struct object * addr;
si_t i, n;
/**
* release focus list
**/
list_exit(&(global_application.focus_list));
/* 有多少个窗口 */
n = vector_size(&(global_application.window_vector));
/* 依次删除窗口 */
for(i = n - 1; i >= 0; -- i)
{
addr = vector_at(&(global_application.window_vector), i);
/*
这里没有逐个注销窗口类对象或者它的派生类对象。
因为窗口管理程序收到用户应用程序的退出请求后，
会释放关于这个用户应用程序的所有资源。
*/
/* 释放这棵树 */
object_tree_free(addr->parent);
/* 从窗口向量中删除这个节点 */
vector_erase(&(global_application.window_vector), i);
}
vector_exit(&(global_application.window_vector));
if(0 != cancel_application())
{
EGUI_PRINT_ERROR("failed to cancle application");
}
event_listener_exit(&global_application.app_event_listener);
queue_exit(&global_application.message_queue);
uds_exit(&global_application.uds);
free(global_application.name);
free(global_application.icon_root_path);
term_restore();
return 0;
}
/* ------------------------------------------------------------------------- */
void
texture_atlas_merge( TextureAtlas *self )
{
Node *node, *next;
size_t i;
for( i=0; i< self->nodes->size-1; ++i )
{
node = (Node *) (vector_get( self->nodes, i ));
next = (Node *) (vector_get( self->nodes, i+1 ));
if( node->y == next->y )
{
node->width += next->width;
vector_erase( self->nodes, i+1 );
--i;
}
}
}
// ---------------------------------------------------- texture_atlas_merge ---
void
texture_atlas_merge( texture_atlas_t * self )
{
ivec3 *node, *next;
size_t i;
assert( self );
for( i=0; i< self->nodes->size-1; ++i )
{
node = (ivec3 *) (vector_get( self->nodes, i ));
next = (ivec3 *) (vector_get( self->nodes, i+1 ));
if( node->y == next->y )
{
node->z += next->z;
vector_erase( self->nodes, i+1 );
--i;
}
}
}
/*
如果 window 有左子节点
那么这个左子节点并不是 window 子对象
所以在析构以 window 为根的树之前一定要要将 window->lchild 成员清空
如果 window 在对象树中
那么完成删除工作后一定要更新 root->parent 的 lchild 成员和 rchild 成员
这是为了保证遍历的正确
*/
si_t application_del_window(struct window * window)
{
si_t is_top_window = 0;
/* 删除主窗口 */
/* 退出程序 */
if(window == global_application.main_window)
{
application_exit();
return 0;
}
if(window->parent->parent == OBJECT_POINTER(window))
{
is_top_window = 1;
}
cancel_window(window->descriptor);
object_delete(OBJECT_POINTER(window), __widget_destructor);
if(is_top_window)
{
si_t i = 0, n = 0;
/* 有多少个窗口 */
n = vector_size(&(global_application.window_vector));
/* 找到这个窗口在向量中的索引 */
for(i = 0; i < n; ++ i)
{
struct object* tree = vector_at(&(global_application.window_vector), i);
if(tree->parent == OBJECT_POINTER(window))
{
/* 从窗口向量中删除这个节点 */
vector_erase(&(global_application.window_vector), i);
break;
}
}
}
return 0;
}
// ----------------------------------------------- font_manager_delete_font ---
void
font_manager_delete_font( font_manager_t * self,
texture_font_t * font)
{
size_t i;
texture_font_t *other;
assert( self );
assert( font );
for( i=0; i<self->fonts->size;++i )
{
other = (texture_font_t *) vector_get( self->fonts, i );
if ( (strcmp(font->filename, other->filename) == 0) && ( font->size == other->size) )
{
vector_erase( self->fonts, i);
break;
}
}
texture_font_delete( font );
}
int file_hiding_cfs_unhide(CFS_t * cfs, inode_t ino)
{
Dprintf("%s(%u)\n", __FUNCTION__, ino);
file_hiding_state_t * state = (file_hiding_state_t *) cfs;
hide_entry_t * me;
/* make sure this is really a table classifier */
if (OBJMAGIC(cfs) != FILE_HIDING_MAGIC)
return -EINVAL;
int idx = hide_lookup(state->hide_table, ino);
if (idx < 0)
return idx;
me = vector_elt(state->hide_table, idx);
fprintf(stderr,"file_hiding_cfs: unhiding %u\n", ino);
vector_erase(state->hide_table, idx);
hide_entry_destroy(me);
return 0;
}
static int remove_member(struct item_data *data, int position)
{
if (position < 0 || position >= data->members.size)
return 0;
menu_navigate_top(data->imenu, MENU_NAVIGATE_DOWN);
--data->add_button->y;
#ifndef WIIVC
--data->import_button->y;
#endif
for (int i = position + 1; i < data->members.size; ++i) {
struct member_data *member_data = get_member(data, i);
--member_data->index;
--member_data->member->y;
}
struct member_data *member_data = get_member(data, position);
struct menu_item *watch = menu_userwatch_watch(member_data->userwatch);
menu_item_remove(watch);
member_data->anchor_button->data = NULL;
menu_item_remove(member_data->member);
vector_erase(&data->members, position, 1);
free(member_data);
return 1;
}
void vector_unittest()
{
Vector vector;
int integer, i;
int* iterator;
/* An empty vector. */
vector_construct( &vector, sizeof( int ) );
EXPECT_EQUAL( vector_next( &vector, NULL ), NULL );
EXPECT_EQUAL( vector_at( &vector, 0 ), NULL );
EXPECT_EQUAL( vector_at( &vector, 1 ), NULL );
EXPECT_EQUAL( vector_at( &vector, 2 ), NULL );
EXPECT_EQUAL( vector_at( &vector, 3 ), NULL );
EXPECT_EQUAL( vector_at( &vector, 14 ), NULL );
EXPECT_EQUAL( vector_at( &vector, 2345 ), NULL );
vector_destruct( &vector );
/* Adding elements */
vector_construct( &vector, sizeof( int ) );
for (i = 0; i < 9; i++)
{
integer = 9 - i;
EXPECT_EQUAL( vector_push_back( &vector, &integer ), i );
EXPECT_EQUAL( vector_size( &vector ), (i + 1) );
}
EXPECT_NOT_EQUAL( vector_at( &vector, 0 ), NULL );
EXPECT_EQUAL( *((int*)vector_at( &vector, 0 )), 9 );
EXPECT_NOT_EQUAL( vector_at( &vector, 1 ), NULL );
EXPECT_EQUAL( *((int*)vector_at( &vector, 1 )), 8 );
EXPECT_NOT_EQUAL( vector_at( &vector, 2 ), NULL );
EXPECT_EQUAL( *((int*)vector_at( &vector, 2 )), 7 );
EXPECT_NOT_EQUAL( vector_at( &vector, 3 ), NULL );
EXPECT_EQUAL( *((int*)vector_at( &vector, 3 )), 6 );
EXPECT_EQUAL( vector_at( &vector, 14 ), NULL );
EXPECT_EQUAL( vector_at( &vector, 2345 ), NULL );
i = 9;
iterator = NULL;
while ((iterator = (int*)vector_next( &vector, iterator )))
{
EXPECT_EQUAL( i, *iterator );
i--;
}
/* Erasing elements */
for (i = 9 - 1; i >= 4; i--)
{
vector_erase( &vector, vector_next( &vector, NULL ) );
EXPECT_EQUAL( vector_size( &vector ), i );
}
i = 4;
iterator = NULL;
while ((iterator = (int*)vector_next( &vector, iterator )))
{
EXPECT_EQUAL( i, *iterator );
i--;
}
vector_destruct( &vector );
/* Erase from the middle of a vector */
vector_construct( &vector, sizeof( int ) );
integer = 0x12345678; vector_push_back( &vector, &integer );
integer = 0x21436587; vector_push_back( &vector, &integer );
integer = 0x87654321; vector_push_back( &vector, &integer );
vector_erase( &vector, vector_at( &vector, 1 ) );
EXPECT_EQUAL( 0x12345678, *(int*)vector_at( &vector, 0 ) );
EXPECT_EQUAL( 0x87654321, *(int*)vector_at( &vector, 1 ) );
EXPECT_EQUAL( NULL, vector_at( &vector, 2 ) );
vector_destruct( &vector );
/* Clearing a vector */
vector_construct( &vector, sizeof( int ) );
EXPECT_EQUAL( NULL, vector_next( &vector, NULL ) );
vector_clear( &vector );
EXPECT_EQUAL( NULL, vector_next( &vector, NULL ) );
integer = 3; vector_push_back( &vector, &integer );
vector_clear( &vector );
EXPECT_EQUAL( NULL, vector_next( &vector, NULL ) );
vector_clear( &vector );
EXPECT_EQUAL( NULL, vector_next( &vector, NULL ) );
vector_destruct( &vector );
}
void* vector_pop_front(sObject* self)
{
return vector_erase(self, 0);
}
// Behaviours for LAB2
void delete_event(int z_index) { // z-index is the variable used for vector index.
vector_erase(z_index);
}
// ----------------------------------------------- texture_atlas_get_region ---
ivec4
texture_atlas_get_region( texture_atlas_t * self,
const size_t width,
const size_t height )
{
int y, best_index;
size_t best_height, best_width;
ivec3 *node, *prev;
ivec4 region = {{0,0,width,height}};
size_t i;
assert( self );
best_height = UINT_MAX;
best_index = -1;
best_width = UINT_MAX;
for( i=0; i<self->nodes->size; ++i )
{
y = texture_atlas_fit( self, i, width, height );
if( y >= 0 )
{
node = (ivec3 *) vector_get( self->nodes, i );
if( ( (y + height) < best_height ) ||
( ((y + height) == best_height) && (node->z > 0 && (size_t)node->z < best_width)) )
{
best_height = y + height;
best_index = i;
best_width = node->z;
region.x = node->x;
region.y = y;
}
}
}
if( best_index == -1 )
{
region.x = -1;
region.y = -1;
region.width = 0;
region.height = 0;
return region;
}
node = (ivec3 *) malloc( sizeof(ivec3) );
if( node == NULL)
{
fprintf( stderr,
"line %d: No more memory for allocating data\n", __LINE__ );
exit( EXIT_FAILURE );
}
node->x = region.x;
node->y = region.y + height;
node->z = width;
vector_insert( self->nodes, best_index, node );
free( node );
for(i = best_index+1; i < self->nodes->size; ++i)
{
node = (ivec3 *) vector_get( self->nodes, i );
prev = (ivec3 *) vector_get( self->nodes, i-1 );
if (node->x < (prev->x + prev->z) )
{
int shrink = prev->x + prev->z - node->x;
node->x += shrink;
node->z -= shrink;
if (node->z <= 0)
{
vector_erase( self->nodes, i );
--i;
}
else
{
break;
}
}
else
{
break;
}
}
texture_atlas_merge( self );
self->used += width * height;
return region;
}
void* vector_pop_back(sObject* self)
{
return vector_erase(self, SVECTOR(self).mCount-1);
}
int vector_pop_front(Vector* vector) {
return vector_erase(vector, 0);
}
/* ------------------------------------------------------------------------- */
Region
texture_atlas_get_region( TextureAtlas *self,
size_t width, size_t height )
{
assert( self );
/*
assert( width );
assert( height );
*/
{
int y, best_height, best_width, best_index;
Node *node, *prev;
Region region = {0,0,width,height};
size_t i;
best_height = INT_MAX;
best_index = -1;
best_width = INT_MAX;
for( i=0; i<self->nodes->size; ++i )
{
y = texture_atlas_fit( self, i, width, height );
if( y >= 0 )
{
node = (Node *) vector_get( self->nodes, i );
if( ( y + (int)height < best_height ) ||
( y + height == best_height && node->width < best_width) )
{
best_height = y + height;
best_index = i;
best_width = node->width;
region.x = node->x;
region.y = y;
}
}
}
if( best_index == -1 )
{
region.x = -1;
region.y = -1;
region.width = 0;
region.height = 0;
return region;
}
node = (Node *) malloc( sizeof(Node) );
node->x = region.x;
node->y = region.y + height;
node->width = width;
vector_insert( self->nodes, best_index, node );
free( node );
for(i = best_index+1; i < self->nodes->size; ++i)
{
node = (Node *) vector_get( self->nodes, i );
prev = (Node *) vector_get( self->nodes, i-1 );
if (node->x < (prev->x + prev->width) )
{
int shrink = prev->x + prev->width - node->x;
node->x += shrink;
node->width -= shrink;
if (node->width <= 0)
{
vector_erase( self->nodes, i );
--i;
}
else
{
break;
}
}
else
{
break;
}
}
texture_atlas_merge( self );
self->used += width * height;
return region;
}
}
int test_run (void)
{
SCL_vector_t vector;
SCL_iterator_t iterator;
void* data;
int stat;
int i;
printf ("Create vector: ");
fflush (stdout);
vector = vector_new();
printf ("(%p = vector_new()) != NULL ... ", vector);
fflush (stdout);
printf ("%s\n", ((vector!=NULL) ? "PASS" : "FAIL"));
printf (
"(%ld = vector_size (vector)) == 0 ..................... %s\n",
vector_size(vector),
((vector_size(vector)==0) ? "PASS" : "FAIL")
);
printf (
"(%ld = vector_count (vector)) == 0 .................... %s\n",
vector_count(vector),
((vector_count(vector)==0) ? "PASS" : "FAIL")
);
printf ("Push data in back vector.\n");
for (i=0 ; i<VECTOR_SIZE ; i++)
{
stat = vector_push_back (vector, (void*)g_data1[i]);
printf (
"[%d,%s] = vector_push_back (vector, %08X) .... %s\n",
stat, scl_statstr(stat), g_data1[i],
((stat==SCL_OK) ? "PASS" : "FAIL")
);
}
printf ("Iterate back through vector, changing data.\n");
for (i=7, iterator=vector_end(vector) ; iterator!=NULL ; iterator=vector_prev(iterator))
{
data = vector_data_get (iterator);
printf (
"%08X = vector_data_get (iterator=>%p) .... %s\n",
data, iterator,
(((unsigned long)data==g_data1[--i]) ? "PASS" : "FAIL")
);
vector_data_set (iterator, iterator);
printf ("%08X -> %08X\n", data, vector_data_get(iterator));
}
printf (
"(%ld = vector_size (vector)) == 16 ................... %s\n",
vector_size(vector),
((vector_size(vector)==16) ? "PASS" : "FAIL")
);
printf (
"(%ld = vector_count (vector)) == 7 .................... %s\n",
vector_count(vector),
((vector_count(vector)==7) ? "PASS" : "FAIL")
);
printf ("Foreach on vector.\n");
for (i=0 ; i<VECTOR_SIZE ; i++) g_flag[i] = 0;
g_vector = vector;
vector_foreach (vector, cbfn, NULL);
printf ("Erase vector.\n");
vector_erase (vector);
printf (
"(%ld = vector_size (vector)) == 0 ..................... %s\n",
vector_size(vector),
((vector_size(vector)==0) ? "PASS" : "FAIL")
);
printf (
"(%ld = vector_count (vector)) == 0 .................... %s\n",
vector_count(vector),
((vector_count(vector)==0) ? "PASS" : "FAIL")
);
printf ("Delete vector.\n");
vector_del (vector);
printf ("\n");
return 0;
}
void reactor_http_response_clear(reactor_http_response *response)
{
vector_erase(&response->fields, 0, vector_size(&response->fields));
}
int fuse_serve_mount_step_remove(void)
{
char b = 1;
queue_entry_t * qe;
Dprintf("%s()\n", __FUNCTION__);
if (unmount_pipe[0] == -1)
return -1;
// Read the byte from helper to zero the read fd's level
if (read(unmount_pipe[0], &b, 1) != 1)
{
perror("fuse_serve_mount_step_shutdown(): read");
if (write(unmount_pipe[1], &b, 1) != 1)
assert(0);
return -1;
}
if (vector_size(remove_queue) > 0)
{
qe = vector_elt(remove_queue, 0);
// NOTE: vector_erase() is O(|remove_queue|). If this queue
// gets to be big we can change how this removal works.
vector_erase(remove_queue, 0);
}
else
{
assert(shutdown_has_started());
if (nmounts == 1)
{
Dprintf("%s(): unmounting root\n", __FUNCTION__);
return unmount_root();
}
if (!(qe = calloc(1, sizeof(*qe))))
{
(void) write(unmount_pipe[1], &b, 1); // unzero the read fd's level
return -ENOMEM;
}
qsort(mounts, nmounts, sizeof(*mounts), mount_path_compar);
qe->mount = mounts[nmounts - 1];
qe->action = QEUNMOUNT;
}
mounts_remove(qe->mount);
fuse_session_destroy(qe->mount->session);
qe->mount->session = NULL;
(void) close(qe->mount->channel_fd);
fuse_opt_free_args(&qe->mount->args);
if (enqueue_helper_request(qe) < 0)
{
fprintf(stderr, "%s(): enqueue_helper_request failed; unmount \"%s\" is unrecoverable\n", __FUNCTION__, qe->mount->fstitch_path);
free(qe);
return -1;
}
if (ensure_helper_is_running() < 0)
{
fprintf(stderr, "%s(): ensure_helper_is_running failed; unmount \"%s\" is unrecoverable\n", __FUNCTION__, qe->mount->fstitch_path);
return -1;
}
return 0;
}
