예제 #1
0
static void test_slist (void) {
  SListEntry* list = NULL;
  int a, b, c;

  slist_prepend (&list, &a);
  slist_prepend (&list, &b);
  slist_prepend (&list, &c);

  slist_free (list);
  }
예제 #2
0
파일: test-slist.c 프로젝트: vdt/libcore
void test_slist_prepend_to_empty(void)
{
    unsigned long *val = NULL;

    assert_true(test_slist == NULL);

    test_slist = slist_create();

    assert_true(test_slist != NULL);
    assert_true(slist_is_empty(test_slist));

    val = make_ulong_ptr(9999);
    assert_true(val != NULL);

    assert_true(slist_prepend(test_slist, val) == 0);

    /* Verify */
    val = NULL;
    val = slist_index(test_slist, 0);
    assert_true(val != NULL);
    assert_ulong_equal(9999, *val);
    assert_true(slist_size(test_slist) == 1);

    slist_free_all(test_slist, NULL);
    test_slist = NULL;
}
예제 #3
0
void
register_html (const char *url, const char *file)
{
  if (!opt.convert_links)
    return;
  downloaded_html_files = slist_prepend (downloaded_html_files, file);
}
예제 #4
0
파일: slist.c 프로젝트: qgewfg/gtk-gnutella
/**
 * Move entry to the head of the slist.
 */
bool
slist_moveto_head(slist_t *slist, void *key)
{
	if (slist_remove(slist, key)) {
		slist_prepend(slist, key);
		return TRUE;
	}
	return FALSE;
}
예제 #5
0
파일: queue.c 프로젝트: tomyo/Dinic
void queue_push_head (Queue *queue, void *data) {
    /* Precondition */
    assert(queue != NULL);

    queue->head = slist_prepend (queue->head, data);
    if (queue->length == 0) {
        queue->tail = queue->head;
    }
    queue->length++;

    /* Postcondicion */
    assert((int) queue->length == slist_length(queue->head));
}
예제 #6
0
void
register_html (const char *url, const char *file)
{
  if (!downloaded_html_set)
    downloaded_html_set = make_string_hash_table (0);
  else if (hash_table_contains (downloaded_html_set, file))
    return;

  /* The set and the list should use the same copy of FILE, but the
     slist interface insists on strduping the string it gets.  Oh
     well. */
  string_set_add (downloaded_html_set, file);
  downloaded_html_list = slist_prepend (downloaded_html_list, file);
}
예제 #7
0
파일: test-slist.c 프로젝트: vdt/libcore
void test_slist_prepend_to_existing(void)
{
    unsigned long *val;
    unsigned long old_size;

    old_size = slist_size(test_slist);
    val = make_ulong_ptr(7777);
    assert_true(slist_prepend(test_slist, val) == 0);

    /* Verify */
    val = NULL;
    val = slist_index(test_slist, 0);
    assert_ulong_equal(7777, *val);
    assert_true((old_size + 1) == slist_size(test_slist));
}
예제 #8
0
파일: bloom.c 프로젝트: hagemt/bloom
void
archive(struct file_info_t *info, struct file_entry_t *entry)
{
	Set *hash_set = trie_lookup(info->hash_trie, entry->hash);
	if (hash_set == TRIE_NULL) {
		/* Otherwise, the value needs a new list */
		hash_set = set_new(&pointer_hash, &pointer_equal);
		slist_prepend(&info->duplicates, hash_set);
		trie_insert(info->hash_trie, entry->hash, hash_set);
	}
	if (!set_insert(hash_set, entry)) {
		#ifndef NDEBUG
		fprintf(stderr, "[DEBUG] '%s' (extra file)\n", entry->path);
		#endif
	}
}
예제 #9
0
/*
 * Alternate version that allows two possible names to be specified.
 * Tile/object layers have different node names ("layer" vs "objectgroup"),
 * but their order needs to be preserved. This method is a workaround
 * for that.
 */
SList *get_children_for_either_name(xmlNode *parent, char *name1, char *name2)
{
	SList *list = NULL;
	
	if(!parent->children)
		return list;

	xmlNode *child = parent->children->next;
	while (child) {
		if(streq((const char*)child->name, name1) || streq((const char*)child->name, name2)) {
			list = slist_prepend(list, child);
		}

		child = child->next;
	}

	return list;
}
예제 #10
0
파일: joystick_sdl.c 프로젝트: jedie/XRoar
static struct device *open_device(int joystick_index) {
	// If the device is already open, just up its count and return it
	for (struct slist *iter = device_list; iter; iter = iter->next) {
		struct device *d = iter->data;
		if (d->joystick_index == joystick_index) {
			d->open_count++;
			return d;
		}
	}
	// Otherwise open and throw it on the list
	SDL_Joystick *j = SDL_JoystickOpen(joystick_index);
	if (!j)
		return NULL;
	struct device *d = xmalloc(sizeof(*d));
	d->joystick_index = joystick_index;
	d->joystick = j;
	d->num_axes = SDL_JoystickNumAxes(j);
	d->num_buttons = SDL_JoystickNumButtons(j);
	d->open_count = 1;
	device_list = slist_prepend(device_list, d);
	return d;
}
예제 #11
0
void aho_corasick_goto_set(aho_corasick_state_t *from_state,
			   unsigned char symbol,
			   aho_corasick_state_t *to_state) {
	aho_corasick_labeled_edge_t *edge;
	switch (from_state->_transitions.type) {
	case AHO_CORASICK_DENSE_TRANSITIONS:
		from_state->_transitions.data.array[symbol] = to_state;
		return;
	case AHO_CORASICK_SPARSE_TRANSITIONS:
		edge = xalloc(sizeof(aho_corasick_labeled_edge_t));
		if (edge == NULL) {
			/* fixme: check memory allocation! */
		}
		edge->label = symbol;
		edge->state = to_state;
		
		if (slist_prepend(from_state->_transitions.data.slist, edge) < 0) {
			/* fixme: check memory allocation! */
		}
		return;
	}

}
예제 #12
0
int main(int argc, char *argv[])
{
	SList *l1=NULL, *l2=NULL, *l3=NULL;
	int i;

	l1 = slist_prepend(l1, 96);
	l1 = slist_prepend(l1, 39);
	l1 = slist_prepend(l1, 28);
	l1 = slist_prepend(l1, 65);
	l1 = slist_prepend(l1, 61);
	l1 = slist_prepend(l1, 00);
	l1 = slist_prepend(l1, 34);
	l1 = slist_prepend(l1, 21);
	l1 = slist_prepend(l1, 43);
	l1 = slist_prepend(l1, 48);

	l2 = slist_prepend(l2, 71);
	l2 = slist_prepend(l2, 00);
	l2 = slist_prepend(l2, 02);
	l2 = slist_prepend(l2, 62);
	l2 = slist_prepend(l2, 22);
	l2 = slist_prepend(l2, 14);
	l2 = slist_prepend(l2, 59);
	l2 = slist_prepend(l2, 28);
	l2 = slist_prepend(l2, 71);
	l2 = slist_prepend(l2, 21);
	l2 = slist_prepend(l2, 89);
	l2 = slist_prepend(l2, 94);

	l3 = slist_prepend(l3, 11);
	l3 = slist_prepend(l3, 81);
	l3 = slist_prepend(l3, 99);
	l3 = slist_prepend(l3, 47);
	l3 = slist_prepend(l3, 72);
	l3 = slist_prepend(l3, 79);
	l3 = slist_prepend(l3, 30);
	l3 = slist_prepend(l3, 66);
	l3 = slist_prepend(l3, 96);
	
	
	printf("len(l1) = %i\n", slist_length(l1));
	printf("len(l2) = %i\n", slist_length(l2));
	printf("len(l3) = %i\n", slist_length(l3));
	puts("");

	printf("l1 = "); printlist(l1);
	printf("l2 = "); printlist(l2);
	printf("l3 = "); printlist(l3);
	puts("");

	/* NOTA:
	    Si tu función concat modifica las listas pasadas (es decir, hace
	   que el último nodo de la primera apunte al primero de la segunda),
	   vas a obtener resultados distintos ya que l1 se estaría modificando.
	    Cambiar el argumento 'l1' por 'clonar(l1)' para que no se
	   modifique la lista. */
	printf("l1 ++ l2 = "); printlist(slist_concat(l1, l2));
	printf("l1 ++ [] = "); printlist(slist_concat(l1, NULL));
	printf("[] ++ l2 = "); printlist(slist_concat(NULL, l2));
	puts("");

	/* Si tu intersect cambia las listas, hacer lo mismo explicado para
	   concat.. */
	printf("l1 <inter> l2 = "); printlist(slist_intersect(l1, l2));
	printf("l1 <inter> l3 = "); printlist(slist_intersect(l1, l3));
	puts("");
	
//	slist_sort(l1,icmpM);
	printf("sort(l1) = "); printlist(slist_sort(l1,icmpM));
	puts("");

	/* NOTA:
	    Si tu lista quedó ordenada al revés, o no queda ordenada puede ser
	   por confusiones en como opera la función de comparación. Lo que debe
	   cumplir la función de comparación es:
	   		icmp(a, b) >  0   si y solo si    a > b
			icmp(a, b) == 0   si y solo si    a == b
			icmp(a, b) <  0   si y solo si    a < b

	   Los valores no son necesariamente 1 y -1. */
	   		
    return 0;
}