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);
}
