inline List *List_merge(List *left, List *right, List_val_compare cmp) { check((left != NULL) || (right != NULL), "Tried to merge NULL."); List *merged = List_create(); void *val = NULL; while(List_count(left) > 0 || List_count(right) > 0) { if(List_count(left) > 0 && List_count(right) > 0) { if(cmp(List_first(left), List_first(right)) <= 0) { val = List_fpop(left); } else { val = List_fpop(right); } List_push(merged, val); } else if(List_count(left) > 0) { merged = List_join(merged, left); break; } else if(List_count(right) > 0) { merged = List_join(merged, right); break; } } return merged; error: return NULL; }
List *List_merge(List *left, List *right, List_compare cmp) { List *result = List_create(); void *val = NULL; while(List_count(left) != 0 && List_count(right) != 0) { if(cmp(List_first(left), List_first(right)) <= 0) { val = List_shift(left); List_push(result, val); } else { val = List_shift(right); List_push(result, val); } } while(List_count(left) != 0) { val = List_shift(left); List_push(result, val); } while(List_count(right) != 0) { val = List_shift(right); List_push(result, val); } return result; }
int List_cmp(List *a, List *b) { List_check(a); List_check(b); int equal = 0; int i; if(a == NULL && b == NULL) { equal = 1; } else if(a->count == 0 && b->count == 0) { equal = 1; } else if(a->count == b->count){ equal = 1; ListNode *a_cur = List_first(a); ListNode *b_cur = List_first(b); for (i = 0; i < a->count - 1; i++) { if(List_node_cmp(a_cur, b_cur)) { a_cur = a_cur->next; b_cur = b_cur->next; } else { equal = 0; break; } } } return equal; error: return -1; }
char *test_unshift() { List_unshift(list, test1); mu_assert(List_first(list) == test1, "Wrong first value"); List_unshift(list, test2); mu_assert(List_first(list) == test2, "Wrong first value"); List_unshift(list, test3); mu_assert(List_first(list) == test3, "Wrong last value."); mu_assert(List_count(list) == 3, "Wrong count on unshift."); return NULL; }
void push_shift(List *list) { List_push(list, 12); List_push(list, 7); List_push(list, 2); assert(List_index(list, 0)->data == 12); assert(List_index(list, 1)->data == 7); assert(List_first(list)->data == 12); assert(List_last(list)->data == 2); List_shift(list); assert(List_first(list)->data == 7); List_shift(list); assert(List_first(list)->data == 2); List_shift(list); assert(List_first(list) == NULL); }
List *List_merge(List *list1, List *list2, List_compare cmp) { List *result = List_create(); // 存放排序好的List // 数据域 void *val = NULL; // 如果list1的数据小,则push之,并unshift list1 // 否则,push list2的数据,并unshift list2 while(List_count(list1) > 0 && List_count(list2) > 0) { if(cmp((char *)List_first(list1) , (char *)List_first(list2)) >= 0) { val = List_unshift(list2); List_push(result, val); } else { val = List_unshift(list1); List_push(result, val); } } // push剩余的数据 if(List_count(list1) > 0) { while(List_count(list1) > 0) { val =List_unshift(list1); List_push(result, val); } } else { while(List_count(list2) > 0) { val =List_unshift(list2); List_push(result, val); } } List_destroy(list1); List_destroy(list2); return result; }
void remove_mid(List *list) { List_push(list, 12); List_push(list, 7); List_push(list, 8); List_remove(list, List_index(list, 1)); assert(List_size(list) == 2); assert(List_first(list)->data == 12); assert(List_last(list)->data == 8); }
char *test_remove() { //only test middle case since push shift test other cases char *val = List_remove(list, list->first->next); mu_assert(val == test2, "Wrong removed element."); mu_assert(List_count(list) == 2, "Wrong count after remove."); mu_assert(List_first(list) == test3, "Wrong first after remove."); mu_assert(List_last(list) == test1, "Wrong last after remove."); return NULL; }
char *test_remove() { char *val = List_remove(list, list->first->next); mu_assert(val == test2, "Wrong removed element."); mu_assert(List_count(list) == 2, "Wrong count after remove."); mu_assert(List_first(list) == test3, "Wrong first after remove."); mu_assert(List_last(list) == test1, "Wrong last after remove."); return NULL; }
void str_push_pop(List *list) { SET_TYPE(list, string); List_push(list, "hello world"); List_push(list, "bad boy"); assert(strcmp(List_index(list, 0)->data, "hello world") == 0); assert(strcmp(List_index(list, 1)->data, "bad boy") == 0); assert(strcmp(List_first(list)->data, "hello world") == 0); assert(strcmp(List_last(list)->data, "bad boy") == 0); List_pop(list); List_pop(list); }
void IoLexer_print(IoLexer *self) { IoToken *first = List_first(self->tokenStream); if (first) { IoToken_print(first); } printf("\n"); }
char *test_remove() { /*only need to test middle remove case since push/shift already tests the other cases*/ char *val = List_remove(list, list->first->next); mu_assert(val == test2, "Wrong removed element."); mu_assert(List_count(list) == 2, "Wrong count after remove."); mu_assert(List_first(list) == test3, "Wrong first after remove."); mu_assert(List_last(list) == test1, "Wrong last after remove."); return NULL; }
char *test_remove() { List_push(list, tv1); List_push(list, tv2); List_push(list, tv3); char *out = List_remove(list, list->first->next); mu_assert(out == tv2, "Removed wrong thing."); mu_assert(List_first(list) == tv1, "Wrong first ref."); mu_assert(List_last(list) == tv3, "Wrong last ref."); return NULL; }
inline List *List_merge(List *left, List *right, List_compare cmp) { List *result = List_create(); void *val = NULL; while(List_count(left) > 0 || List_count(right) > 0) { if(List_count(left) > 0 && List_count(right) > 0) { if(cmp(List_first(left), List_first(right)) <= 0) { val = List_shift(left); } else { val = List_shift(right); } List_push(result, val); } else if(List_count(left) > 0) { List_join(result, left); } else if(List_count(right) > 0) { List_join(result, right); } } return result; }
void DD_DependenceTest (FuncDcl func) { List expr_list; Expr expr1, expr2; /* * JWS: There is no reason to do this for the whole function at once. * Why not do it for one loop nest at a time? */ /* * Find all the expressions which access memory. The resulting list * is stored in expr_list. */ if (!(expr_list = FindAllExprWithMemAcc (func))) return; /* no expressions to examine */ if (DD_DEBUG_OMEGA) fprintf (stderr, "DD_DependenceTest func=%s\n", func->name); DD_Preprocess (func); initializeOmega (); /* do pairwise comparison between expressions which access memory. */ List_start (expr_list); while ((expr1 = List_first (expr_list))) { expr_list = List_delete_current (expr_list); while ((expr2 = List_next (expr_list))) { if ((PD_IsMemWriteExpr (expr1) || PD_IsMemWriteExpr (expr2)) && PD_ExprsMayAlias (expr1, expr2)) PD_produce_cyclic_sync_arc (expr1, expr2); } } expr_list = List_reset (expr_list); if (DD_DEBUG_OMEGA) DD_PrintFuncDepInfo (stderr, func); return; }
char *test_unshift_shift() { List_unshift(list, tv1); mu_assert(List_first(list) == tv1, "Bad first value."); List_unshift(list, tv2); mu_assert(List_first(list) == tv2, "Bad first value."); List_unshift(list, tv3); mu_assert(List_first(list) == tv3, "Bad first value."); mu_assert(List_size(list) == 3, "Wrong size"); char *out = List_shift(list); mu_assert(out == tv3, "Bad shifted value."); out = List_shift(list); mu_assert(out == tv2, "Bad shifted value."); out = List_shift(list); mu_assert(out == tv1, "Bad shifted value."); mu_assert(List_size(list) == 0, "Wrong size"); return NULL; }
char* test_copy() { src = List_create(); dest = List_create(); List_push(src, test1); List_push(src, test2); List_push(src, test3); List_copy(dest, src); mu_assert(List_count(dest) == 3, "Wrong copy - count."); mu_assert(List_first(dest) == test1, "Wrong copy - first."); mu_assert(List_last(dest) == test3, "Wrong copy - last."); return NULL; }
/* check for recursive includes, call error callback and return FALSE abort if found returns TRUE if callback not defined */ static Bool check_recursive_include( SrcFile *self, char *filename ) { ListElem *iter; FileStackElem *elem; if ( incl_recursion_err_cb != NULL ) { for ( iter = List_first( self->file_stack ) ; iter != NULL ; iter = List_next( iter ) ) { elem = iter->data; if ( elem->filename != NULL && strcmp( filename, elem->filename ) == 0 ) { incl_recursion_err_cb( filename ); return FALSE; } } } return TRUE; }
void do_write(evutil_socket_t fd, short events, void *arg) { (void) events; struct fd_state *state = arg; printf("Want to write %d blocks\n", List_count(state->outputs)); while (List_count(state->outputs) > 0) { RtmpOutputMessage *this_output = List_first(state->outputs); printf("Block write: %u\n", this_output->data_left); while (this_output->data_left > 0) { ssize_t result = send(fd, rtmp_output_message_start_at(this_output), this_output->data_left, 0); if (result < 0) { if (errno == EAGAIN) // XXX use evutil macro return; free_fd_state(state); return; } assert(result != 0); this_output->data_left -= result; printf("\tWritten: %d\n", result); if (this_output->data_left == 0) { List_unshift(state->outputs); rtmp_destroy_output_message(this_output); break; } } } event_del(state->write_event); }