int slist_prepend(slist_t *list,void *Value) { if (Value == NULL) { // if no have Value return 0; } slist_node_t *temp_p; temp_p=(slist_node_t *)calloc(1,sizeof(slist_node_t)); if(temp_p==NULL) { return -1; } slist_data(temp_p)=Value; temp_p->next = NULL; if (slist_head(list)==NULL) // the list is empty { slist_head(list) = temp_p; slist_tail(list) = temp_p; slist_next(temp_p) = NULL; slist_size(list) = 1; return 0; } slist_next(temp_p) = slist_head(list); slist_head(list) = temp_p; if (slist_tail(list)==NULL) { slist_tail(list)=temp_p; } slist_size(list)++; return 0; }
int slist_append(slist_t *list,void *Value) { slist_node_t *temp_p=NULL; if (Value == NULL) { // if no have Value return 0; } temp_p=(slist_node_t *)calloc(1,sizeof(slist_node_t)); if(temp_p==NULL) { return -1; } slist_data(temp_p) = Value; slist_next(temp_p)=NULL; if (slist_head(list)==NULL) { slist_head(list) = temp_p; slist_tail(list) = temp_p; slist_size(list)++; return 0; } slist_next(slist_tail(list)) = temp_p; slist_tail(list) = temp_p; slist_size(list)++; return 0; }
static void test_empty(void) { struct list_node *spos, *ssafe; struct node *pos, *safe; check(!slist_is_empty(&slist), "slist is empty but slist_is_empty returned false"); check(!list_is_empty(&list), "list is empty but list_is_empty returned false"); check(slist_head(&slist) != &slist, "slist is empty but slist_head returned non-self"); check(list_head(&list) != NULL, "list is empty but list_head returned non-NULL"); check(slist_tail(&slist) != &slist, "slist is empty but slist_tail returned non-self"); check(list_tail(&list) != NULL, "list is empty but list_tail returned non-NULL"); check_loop_never(slist_for_each(spos, &slist), "slist is empty, but slist_for_each looped"); check_loop_never(list_for_each(pos, &list), "list is empty, but list_for_each looped"); check_loop_never(slist_for_each_safe(spos, ssafe, &slist), "slist is empty, but slist_for_each_safe looped"); check_loop_never(list_for_each_safe(pos, safe, &list), "list is empty, but list_for_each_safe looped"); check_loop_never(slist_for_each_entry(pos, &slist, node), "slist is empty, but slist_for_each_entry looped"); check_loop_never(slist_for_each_entry_safe(pos, safe, &slist, node), "slist is empty, but slist_for_each-entry_safe looped"); }
int slist_append_list(slist_t* listOne, slist_t* listSec) { if (slist_tail(listSec) == NULL && slist_head(listOne) == NULL) { // both of list is NULL return 0; } if (slist_head(listSec) == NULL) { // list two is NULL return 0; } if(!listOne || !listSec) {return -1;} if(slist_size(listSec) == 0) {return 0;} slist_node_t* p = slist_head(listSec); while(p) { if( slist_append(listOne, p->data) == -1 ) {return -1;} p = slist_next(p); } slist_size(listOne) += slist_size(listSec); /* slist_destroy(l2, SLIST_LEAVE_DATA);*/ return 0; }
void *slist_pop_first(slist_t *list) { if (slist_head(list)==NULL) { return NULL; } slist_node_t *temp_p=NULL; void *PopValue; temp_p = slist_head(list); PopValue= slist_data(temp_p); slist_head(list) =slist_next(temp_p); free(temp_p); int countSize = slist_size(list) -1; if (countSize==0) // if the list have one node { slist_tail(list)=NULL; slist_head(list)=NULL; slist_size(list)=0; } return(PopValue); // return the Value of head list }
void slist_destroy(slist_t *list_p ,slist_destroy_t flag) { if (list_p==NULL) { return; } slist_node_t *temp_p; temp_p = slist_head(list_p); while(temp_p!= NULL) { slist_head(list_p) = slist_next(temp_p); if (flag==SLIST_FREE_DATA) { free(slist_data(temp_p)); } free(temp_p); temp_p = slist_head(list_p); } free(temp_p); slist_size(list_p) = 0; return; }
static struct ConfigItem * find_item(uint32_t hash) { SLIST_ITERATOR p = slist_head(configs, NULL); while(p != NULL) { struct ConfigItem *item = *(struct ConfigItem **)slist_get(p); if (item->hash == hash) return item; p = slist_next(p); } return NULL; }
int chtbl_lookup(const struct chtbl_t *htbl, void **data) { struct slist_node *elem; int bucket; bucket = htbl->hash(*data) % htbl->buckets; for (elem = slist_head(&htbl->table[bucket]); elem; elem = slist_next(elem)) { if (htbl->match(*data, slist_data(elem))) { *data = slist_data(elem); return 0; } } return -1; }
void configs_cleanup(void) { if (!configs) return; SLIST_ITERATOR p = slist_head(configs, NULL); while(p != NULL) { struct ConfigItem *item = *(struct ConfigItem **)slist_get(p); free(item); p = slist_next(p); } slist_free(configs); }
//Private Method int contains(slist_t* list, char* string) { if(list == NULL) { return -1; } slist_node_t* p; for(p = slist_head(list); p != NULL; p = slist_next(p)) { if(slist_data(p) == string) { return -1; } } return 0; }
int chtbl_remove(struct chtbl_t *htbl, void **data) { struct slist_node *elem, *prev; int bucket; bucket = htbl->hash(*data) % htbl->buckets; prev = NULL; for (elem = slist_head(&htbl->table[bucket]); elem; elem = slist_next(elem)) { if (htbl->match(*data, slist_data(elem))) { if (slist_rem_next(&htbl->table[bucket], prev, data) == 0) { htbl->size--; return 0; } else { return -1; } } prev = elem; } return -1; }
/* Follows the transition arrow from the state, along the edge labeled by the symbol. If no such transition exists, returns FAIL. */ aho_corasick_state_t* aho_corasick_goto_get(aho_corasick_state_t *state, unsigned char symbol) { slist_node_t *node; switch (state->_transitions.type) { case AHO_CORASICK_DENSE_TRANSITIONS: return state->_transitions.data.array[symbol]; case AHO_CORASICK_SPARSE_TRANSITIONS: node = slist_head(state->_transitions.data.slist); while (node != NULL) { if (((aho_corasick_labeled_edge_t *) node->data) ->label == symbol) { return ((aho_corasick_labeled_edge_t *) node->data)->state; } node = node->next; } return FAIL; } /* FIXME: We should never get here. */ return FAIL; }
void print(slist_t *list) { if(slist_size(list) == 0) return; slist_node_t *p = slist_head(list); while( p != NULL) { pm_labeled_edge_t* edge = (pm_labeled_edge_t*)slist_data(p); pm_state_t* nextState = edge->state; if (slist_size(nextState->_transitions) == 0) printf("s: %d , l: %c -> " , nextState->id , edge->label); else { printf("s: %d , l: %c -> " , nextState->id , edge->label); print(nextState->_transitions); } p = slist_next(p); } }
void slist_init(slist_t *pointer_list) { slist_head(pointer_list)=NULL; slist_tail(pointer_list)=NULL; slist_size(pointer_list)=0; }