void mu_test_sort()
{
my_t n1 = {{{2}, {3}}, 1};
my_t n2 = {{{10}, {6}}, 2};
my_t n3 = {{{11}, {34}}, 2};
my_t n4 = {{{1}, {33}}, 3};
list_t list;
list_init(&list);
// 2 -> 1 -> 3 -> 2
list_push_back(&n2.link, &list);
list_push_back(&n1.link, &list);
list_push_back(&n4.link, &list);
list_push_back(&n3.link, &list);
mu_check(list_front(&list) == &n2.link);
mu_check(list_next(&n2.link) == &n1.link);
mu_check(list_next(&n1.link) == &n4.link);
mu_check(list_next(&n4.link) == &n3.link);
mu_check(list_back(&list) == &n3.link);
puts("pre sort:");
print(list_first(&n1.link));
list_sort(&list, my_cmp);
mu_check(list_front(&list) == &n1.link);
mu_check(list_next(&n1.link) == &n2.link);
mu_check(list_next(&n2.link) == &n3.link);
mu_check(list_next(&n3.link) == &n4.link);
mu_check(list_back(&list) == &n4.link);
puts("post sort:");
print(list_first(&n1.link));
}
/* Removes the back element from LIST and returns it.
Undefined behavior if LIST is empty before removal. */
struct list_elem *
list_pop_back (struct list *list)
{
struct list_elem *back = list_back (list);
list_remove (back);
return back;
}
static int syscall_open(char *filename){
if(filename == NULL || strlen(filename) == 0)
return -1;
struct thread *cur = thread_current ();
struct file_elem *fe, *fe_prev;
struct list_elem *le;
int fd;
fe = filesys_open_file(filename);
if(fe == NULL)
return -1;
if(fe->file == NULL && fe->dir == NULL) {
/* Error occured while opening file */
return -1;
}
// If some files are opened already, fd will be fd of last opened file + 1.
if(!list_empty(&cur->open_files)) {
le = list_back(&cur->open_files);
fe_prev = list_entry(le, struct file_elem, elem);
fd = fe_prev->fd + 1;
}
/* Removes the back element from LIST and returns it.
Undefined behavior if LIST is empty before removal. */
struct list_elem *
list_pop_back (struct list *list)
{
struct list_elem *back = list_back (list);
list_remove (back);
back->magic = BAD_LIST_ELEM_MAGIC__;
return back;
}
list* search_breadth_first(void* state,
void* state_world,
search_is_goal state_goal_func,
search_gen_successors state_gen_func,
search_link_parent state_link_func,
search_goal_backtrace state_back_func,
hash_func state_hash_alg,
generic_comp state_comp_func,
generic_cpy state_copy_func,
generic_op state_free_func) {
int found;
void* current_state, *successor_state;
list* state_queue, *successor_list, *path;
hash_table* state_closed_set;
state_queue = list_create(NULL,
NULL,
state_free_func);
state_closed_set = hash_table_create(89,
.75,
state_hash_alg,
state_comp_func,
state_copy_func,
state_free_func);
current_state = state;
list_push_front(state_queue, current_state);
hash_table_insert(state_closed_set, current_state, 0);
path = NULL;
found = 0;
while(!list_is_empty(state_queue) && !found) {
current_state = list_back(state_queue);
list_deque(state_queue);
if(state_goal_func(current_state, state_world)) {
current_state = state_copy_func(current_state);
path = state_back_func(current_state);
found = 1;
} else {
successor_list = state_gen_func(current_state, state_world);
while(!list_is_empty(successor_list)) {
successor_state = list_front(successor_list);
if(!hash_table_contains(state_closed_set, successor_state)) {
state_link_func(successor_state, current_state);
hash_table_insert(state_closed_set, successor_state, 0);
list_push_front(state_queue, successor_state);
list_pop(successor_list);
} else {
list_remove_front(successor_list);
}
}
list_kill(successor_list);
}
}
hash_table_kill(state_closed_set);
list_dissolve(state_queue);
return path;
}
List *list_push_back(List *l, void *data)
{
l = list_back(l);
l->next = (List *) malloc(sizeof(List));
l->next->data = data;
l->next->next = 0;
l->next->prev = l;
return l->next;
}
/**
* Access queue last data.
*/
void* queue_back(const queue_t* cpque_queue)
{
assert(cpque_queue != NULL);
#ifdef CSTL_QUEUE_LIST_SEQUENCE
return list_back(&cpque_queue->_t_sequence);
#else
return deque_back(&cpque_queue->_t_sequence);
#endif
}
TEST_F(ListTest, test_list_back) {
int x[] = { 1, 2, 3, 4, 5 };
list_t *list = list_new(NULL);
for (size_t i = 0; i < ARRAY_SIZE(x); ++i)
list_append(list, &x[i]);
EXPECT_EQ(list_back(list), &x[ARRAY_SIZE(x) - 1]);
list_free(list);
}
/**
* Access stack top data.
*/
void* stack_top(const cstl_stack_t* cpsk_stack)
{
assert(cpsk_stack != NULL);
#if defined (CSTL_STACK_VECTOR_SEQUENCE)
return vector_back(&cpsk_stack->_t_sequence);
#elif defined (CSTL_STACK_LIST_SEQUENCE)
return list_back(&cpsk_stack->_t_sequence);
#else
return deque_back(&cpsk_stack->_t_sequence);
#endif
}
struct frame_table_entry*
frame_evict_choose_fifo (void)
{
lock_acquire (&frame_table_lock);
struct list_elem *back = list_back (&frame_table);
struct frame_table_entry *fte
= list_entry (back, struct frame_table_entry, elem);
lock_release (&frame_table_lock);
if (fte->pin)
{
lock_acquire (&frame_table_lock);
list_remove (&fte->elem);
list_push_front (&frame_table, &fte->elem);
lock_release (&frame_table_lock);
return frame_evict_choose_fifo ();
}
return fte;
}
void list_pop_back(List *l)
{
list_erase(list_back(l));
}
void list_popd_back(List *l)
{
list_erased(list_back(l));
}
void list_pop (struct func_list *list) {
struct func_elem *back = list_back (list);
list_remove (back);
}
void mu_test_list()
{
my_t n1 = {{{0}, {0}}, 1};
my_t n2 = {{{0}, {0}}, 2};
my_t n3 = {{{0}, {0}}, 3};
my_t n4 = {{{0}, {0}}, 4};
my_t n5 = {{{0}, {0}}, 5};
my_t n6 = {{{0}, {0}}, 6};
list_t list;
list_init(&list);
// 5 -> 1
list_push_back(&n5.link, &list);
list_insert_after(&n5.link, &n1.link, &list);
mu_check( list_next(&n5.link) == &n1.link);
mu_check( list_last(&n5.link) == &n1.link);
mu_check( list_last(&n1.link) == &n1.link);
mu_check( list_first(&n1.link) == &n5.link);
// 5 -> 3 -> 1
list_insert_befor(&n1.link, &n3.link, &list);
mu_check( list_next(&n5.link) == &n3.link);
mu_check( list_last(&n5.link) == &n1.link);
mu_check( list_prev(&n1.link) == &n3.link);
mu_check( list_first(&n3.link) == &n5.link);
// 1 -> 3 -> 5
list_swap(&n5.link, &n1.link, &list);
mu_check( list_next(&n1.link) == &n3.link);
mu_check( list_last(&n1.link) == &n5.link);
mu_check( list_prev(&n5.link) == &n3.link);
mu_check( list_first(&n3.link) == &n1.link);
// 5 -> 3 -> 1
list_swap(&n5.link, &n1.link, &list);
mu_check( list_next(&n5.link) == &n3.link);
mu_check( list_last(&n5.link) == &n1.link);
mu_check( list_prev(&n1.link) == &n3.link);
mu_check( list_first(&n3.link) == &n5.link);
// 2 -> 5 -> 3 -> 1
list_push_front(&n2.link, &list);
mu_check( !list_prev(&n2.link));
mu_check( list_last(&n2.link) == &n1.link);
mu_check( list_prev(&n5.link) == &n2.link);
mu_check( list_first(&n3.link) == &n2.link);
// 2 -> 5 -> 3 -> 1 -> 4
list_push_back(&n4.link, &list);
print(list_first(&n2.link));
mu_check( !list_next(&n4.link));
mu_check( list_last(&n2.link) == &n4.link);
mu_check( list_prev(&n4.link) == &n1.link);
mu_check( list_next(&n1.link) == &n4.link);
mu_check( list_first(&n4.link) == &n2.link);
// 2 -> 5 -> 1 -> 4
list_remove(&n3.link, &list);
mu_check( list_next(&n5.link) == &n1.link);
mu_check( list_prev(&n1.link) == &n5.link);
// 2 -> 6 -> 1 -> 4
list_replace(&n5.link, &n6.link, &list);
mu_check( list_next(&n6.link) == &n1.link);
mu_check( list_prev(&n1.link) == &n6.link);
mu_check( list_prev(&n6.link) == &n2.link);
// 2 -> 1 -> 6 -> 4
list_swap(&n6.link, &n1.link, &list);
mu_check( list_next(&n1.link) == &n6.link);
mu_check( list_prev(&n6.link) == &n1.link);
mu_check( list_next(&n6.link) == &n4.link);
// 2 -> 6 -> 1 -> 4
list_swap(&n6.link, &n1.link, &list);
mu_check( list_next(&n6.link) == &n1.link);
mu_check( list_prev(&n1.link) == &n6.link);
mu_check( list_next(&n1.link) == &n4.link);
mu_check( list_prev(&n6.link) == &n2.link);
mu_check( list_front(&list) == &n2.link);
mu_check( list_back(&list) == &n4.link);
puts("pre sort:");
print(list_first(&n1.link));
list_sort(&list, my_cmp);
puts("post sort:");
print(list_first(&n1.link));
}
static si_t deal_with_mouse(struct input_device * self, struct list* msg_list)
{
union message msg;
int get_msg_res;
if(0 > (get_msg_res=basic_mouse(self, &msg)))
{
EGUI_PRINT_ERROR("failed to get mouse msg");
return -1;
}
if(1==get_msg_res) return 0;
list_push_back(msg_list, &msg, sizeof(union message));
if(msg.mouse.type == MESSAGE_TYPE_MOUSE_PRESS)
{
/* 更改鼠标各个键的状态 */
if(msg.mouse.code == INPUT_CODE_MOUSE_L_KEY)
{
mouse_click.l_key = 1;
}
else if(msg.mouse.code == INPUT_CODE_MOUSE_M_KEY)
{
mouse_click.m_key = 1;
}
else if(msg.mouse.code == INPUT_CODE_MOUSE_R_KEY)
{
mouse_click.r_key = 1;
}
}
else if(msg.mouse.type == MESSAGE_TYPE_MOUSE_RELEASE)
{
union message click_message;
/* 更改鼠标各个键的状态 */
if(msg.mouse.code == INPUT_CODE_MOUSE_L_KEY)
{
mouse_click.l_key = 0;
}
else if(msg.mouse.code == INPUT_CODE_MOUSE_M_KEY)
{
mouse_click.m_key = 0;
}
else if(msg.mouse.code == INPUT_CODE_MOUSE_R_KEY)
{
mouse_click.r_key = 0;
}
/* 以前没有 */
if(mouse_click.has_previous_click == 0)
{
mouse_click.has_previous_click = 1;
mouse_click.previous_click_key = msg.mouse.code;
mouse_previous_click_time = msg.mouse.time;
memcpy(&click_message, &msg, sizeof(union message));
click_message.mouse.type = MESSAGE_TYPE_MOUSE_SINGLE_CLICK;
list_push_back(msg_list, &click_message, sizeof(union message));
}
/* 以前有过 */
else if(mouse_click.has_previous_click == 1)
{
/* 两次的键一致 */
if(mouse_click.previous_click_key == msg.mouse.code)
{
struct timeval difference = {0};
/* difference = basic->mouse.time - mouse_previous_click_time */
diff_timeval(&(msg.mouse.time),&mouse_previous_click_time, &difference);
memcpy(&click_message, &msg, sizeof(union message));
/* 在规定的时间内 */
if(difference.tv_sec == 0 && difference.tv_usec < mouse_double_click_delay)
{
click_message.mouse.type = MESSAGE_TYPE_MOUSE_DOUBLE_CLICK;
mouse_click.has_previous_click = 0;
}
else
{
click_message.mouse.type = MESSAGE_TYPE_MOUSE_SINGLE_CLICK;
mouse_previous_click_time = msg.mouse.time;
}
list_push_back(msg_list, &click_message, sizeof(union message));
}
/* 两次的键不一致 */
else
{
mouse_click.previous_click_key = msg.mouse.code;
mouse_previous_click_time = msg.mouse.time;
memcpy(&click_message, &msg, sizeof(union message));
click_message.mouse.type = MESSAGE_TYPE_MOUSE_SINGLE_CLICK;
list_push_back(msg_list, &click_message, sizeof(union message));
}
}
}
else if(msg.mouse.type == MESSAGE_TYPE_MOUSE_MOVE)
{
union message* msg_ptr = list_back(msg_list);
if(mouse_click.l_key == 1)
{
/*
INPUT_MODIFIER_BIT_SET(INPUT_MODIFIER_MASK_MOUSE_L_KEY, &(msg_ptr->mouse.mask));
*/
msg_ptr->mouse.mask = INPUT_MODIFIER_MASK_MOUSE_L_KEY | msg_ptr->mouse.mask;
}
if(mouse_click.m_key == 1)
{
/*
INPUT_MODIFIER_BIT_SET(INPUT_MODIFIER_MASK_MOUSE_M_KEY, &(msg_ptr->mouse.mask));
*/
msg_ptr->mouse.mask = INPUT_MODIFIER_MASK_MOUSE_M_KEY | msg_ptr->mouse.mask;
}
if(mouse_click.r_key == 1)
{
/*
INPUT_MODIFIER_BIT_SET(INPUT_MODIFIER_MASK_MOUSE_R_KEY, &(msg_ptr->mouse.mask));
*/
msg_ptr->mouse.mask = INPUT_MODIFIER_MASK_MOUSE_R_KEY | msg_ptr->mouse.mask;
}
}
return 0;
}
