int
aho_corasick_maketree(aho_corasick_t *in)
{
slist_t queue;
aho_corasick_state_t *state,*s,*r;
aho_corasick_t *g = in;
int i;
slist_init(&queue);
// Set all FAIL transition of 0 state to point to itself
for(i = 0; i < AHO_CORASICK_CHARACTERS ;i++)
{
if ( aho_corasick_goto_get(g->zerostate,i) == FAIL )
aho_corasick_goto_set(g->zerostate, i, g->zerostate);
// Construct fail()
else
{
if ( slist_append(&queue,aho_corasick_goto_get(g->zerostate,i)) < 0 )
goto fail;
aho_corasick_fail(aho_corasick_goto_get(g->zerostate,i)) = g->zerostate;
}
}
// Set fail() for depth > 0
while( (r = slist_pop_first(&queue)) != NULL )
{
for(i = 0; i < AHO_CORASICK_CHARACTERS ;i++)
{
if ( (s = aho_corasick_goto_get(r,i)) == FAIL )
continue;
if ( slist_append(&queue,s) < 0 )
goto fail;
state = aho_corasick_fail(r);
while( aho_corasick_goto_get(state,i) == FAIL )
state = aho_corasick_fail(state);
aho_corasick_fail(s) = aho_corasick_goto_get(state,i);
debug(printf("Setting f(%u) == %u\n",s->id,
aho_corasick_goto_get(state,i)->id));
// Join outputs missing
}
}
slist_destroy(&queue,SLIST_LEAVE_DATA);
return 0;
fail:
slist_destroy(&queue,SLIST_LEAVE_DATA);
return -1;
}
slist* parse_bnf(char* input)
{
if(!input)return 0;
slist* items=new_slist();
slist* lexed_in=lex_bnf(input);
lp_token** lex_arr=(lp_token**)calloc(lexed_in->_size,sizeof(lp_token*));
int last_item=0;
int i=0;
slist_elem* sle=lexed_in->_head;
for(;i<lexed_in->_size&&sle;++i,sle=sle->_next)
{
lex_arr[i]=(lp_token*)sle->_data;
if(lex_arr[i]->lex_id==SEMI_COLON)
{
__parser(&lex_arr[last_item],(i-last_item)+1);
last_item=i+1;
if(success)
slist_append(items,(void*)item);
else return 0;
}
}
free(lex_arr);
slist_destroy(lexed_in);
return items;
}
lisp_atom lp_let(slist_elem* next)
{
slist* activation=0; /* pointer to the top of the activation stack */
slist_elem* sle=0; /* general iterator */
lisp_atom ret; /* return value */
/* put a new activation record */
activation=new_slist();
/* load all parameters */
if(ATOM_CAST(next)->type!=LTLIST)
LPRETURN_NIL(ret)
sle=((slist*)ATOM_CAST(next)->data)->_head;
while(sle&&sle->_next)
{
/* load each argument*/
if(ATOM_CAST(sle)->type!=LTID)
{
slist_destroy(activation,free);
LPRETURN_NIL(ret)
}
slist_pushb(activation,(void*)ATOM_CAST(sle)->data);
slist_pushb(activation,(void*)ATOM_CAST(sle->_next));
sle=sle->_next;
}
//Private Method
void pm_destroy_state(pm_state_t* state) {
slist_node_t* p = state->slist_head(_transitions);
while(p != NULL) {
pm_state_t* nextState = ((pm_labeled_edge_t*)slist_data(p))->state;
pm_destroy_state(nextState);
p = slist_next(p);
}
slist_destroy(state->output, SLIST_LEAVE_DATA);
slist_destroy(state->_transitions, SLIST_FREE_DATA);
free(state);
}
void test__create_slist__libcstl_builtin_type(void** state)
{
slist_t* pslist = _create_slist("vector_t < int> ");
assert_true(pslist != NULL);
assert_true(strcmp(_GET_SLIST_TYPE_NAME(pslist), "vector_t<int>") == 0);
assert_true(_slist_is_created(pslist));
slist_destroy(pslist);
}
void test__create_slist_auxiliary__c_builtin(void** state)
{
slist_t* pslist = malloc(sizeof(slist_t));
assert_true(_create_slist_auxiliary(pslist, "double"));
assert_true(strcmp(_GET_SLIST_TYPE_NAME(pslist), "double") == 0);
assert_true(_slist_is_created(pslist));
slist_destroy(pslist);
}
void test__create_slist_auxiliary__libcstl_builtin(void** state)
{
slist_t* pslist = malloc(sizeof(slist_t));
assert_true(_create_slist_auxiliary(pslist, "slist_t< vector_t < string_t>> "));
assert_true(strcmp(_GET_SLIST_TYPE_NAME(pslist), "slist_t<vector_t<string_t>>") == 0);
assert_true(_slist_is_created(pslist));
slist_destroy(pslist);
}
void test__create_slist__c_builtin_type(void** state)
{
slist_t* pslist = _create_slist("unsigned int");
assert_true(pslist != NULL);
assert_true(strcmp(_GET_SLIST_TYPE_NAME(pslist), "unsigned int") == 0);
assert_true(_slist_is_created(pslist));
slist_destroy(pslist);
}
/* Deallocates the transition table. Do nothing for now. */
static void aho_corasick_goto_destroy(aho_corasick_state_t *state) {
switch (state->_transitions.type) {
case AHO_CORASICK_DENSE_TRANSITIONS:
xfree(state->_transitions.data.array);
return;
case AHO_CORASICK_SPARSE_TRANSITIONS:
slist_destroy(state->_transitions.data.slist, SLIST_FREE_DATA);
xfree(state->_transitions.data.slist);
}
}
void test__slist_iterator_next__invalid_iter_end(void** state)
{
slist_iterator_t it_iter;
slist_t* pslist = create_slist(int);
slist_init_elem(pslist, 10, 100);
it_iter = slist_end(pslist);
expect_assert_failure(_slist_iterator_next(it_iter));
slist_destroy(pslist);
}
void test__slist_iterator_get_value__invalid_data_buffer(void** state)
{
slist_iterator_t it_iter;
slist_t* pslist = create_slist(int);
slist_init_elem(pslist, 10, 100);
it_iter = slist_end(pslist);
expect_assert_failure(_slist_iterator_get_value(it_iter, NULL));
slist_destroy(pslist);
}
void test__slist_iterator_get_pointer__successfully_cstr(void** state)
{
slist_iterator_t it_iter;
slist_t* pslist = create_slist(char*);
slist_init_elem(pslist, 10, "abcdefg");
it_iter = slist_begin(pslist);
assert_true(strcmp((char*)_slist_iterator_get_pointer(it_iter), "abcdefg") == 0);
slist_destroy(pslist);
}
void test__slist_iterator_get_pointer__successfully(void** state)
{
slist_iterator_t it_iter;
slist_t* pslist = create_slist(int);
slist_init_elem(pslist, 10, 100);
it_iter = slist_begin(pslist);
assert_true(*(int*)_slist_iterator_get_pointer(it_iter) == 100);
slist_destroy(pslist);
}
void test__create_slist_auxiliary__user_defined_dup(void** state)
{
slist_t* pslist = NULL;
type_duplicate(struct _tag_test__create_slist_auxiliary__user_defined, _test__create_slist_auxiliary__user_defined_t);
pslist = malloc(sizeof(slist_t));
assert_true(_create_slist_auxiliary(pslist, "_test__create_slist_auxiliary__user_defined_t"));
assert_true(strcmp(_GET_SLIST_TYPE_NAME(pslist), "_test__create_slist_auxiliary__user_defined_t") == 0);
assert_true(_slist_is_created(pslist));
slist_destroy(pslist);
}
void test__create_slist__user_defined_type_dup(void** state)
{
slist_t* pslist = NULL;
type_duplicate(struct _tag_test__create_slist__user_defined_type, _test__create_slist__user_defined_type_t);
pslist = _create_slist("_test__create_slist__user_defined_type_t");
assert_true(pslist != NULL);
assert_true(strcmp(_GET_SLIST_TYPE_NAME(pslist), "_test__create_slist__user_defined_type_t") == 0);
assert_true(_slist_is_created(pslist));
slist_destroy(pslist);
}
void test__slist_iterator_next__invalid_iter_container_type(void** state)
{
slist_iterator_t it_iter;
slist_t* pslist = create_slist(int);
slist_init_elem(pslist, 10, 100);
it_iter = slist_begin(pslist);
it_iter._t_containertype = 245;
expect_assert_failure(_slist_iterator_next(it_iter));
slist_destroy(pslist);
}
void test__slist_iterator_next__successfully_end(void** state)
{
slist_iterator_t it_iter;
slist_t* pslist = create_slist(int);
slist_init_elem(pslist, 1, 100);
it_iter = slist_begin(pslist);
it_iter = _slist_iterator_next(it_iter);
assert_true(iterator_equal(it_iter, slist_end(pslist)));
slist_destroy(pslist);
}
void test__slist_iterator_get_pointer__invalid_iter_iterator_type(void** state)
{
slist_iterator_t it_iter;
slist_t* pslist = create_slist(int);
slist_init_elem(pslist, 10, 100);
it_iter = slist_begin(pslist);
it_iter._t_iteratortype = 9999;
expect_assert_failure(_slist_iterator_get_pointer(it_iter));
slist_destroy(pslist);
}
void test__slist_iterator_next__invalid_iter(void** state)
{
slist_iterator_t it_iter;
slist_t* pslist = create_slist(int);
slist_init_elem(pslist, 10, 100);
it_iter = slist_begin(pslist);
it_iter._t_pos._pby_corepos = (_byte_t*)0x83;
expect_assert_failure(_slist_iterator_next(it_iter));
slist_destroy(pslist);
}
void test_gen(const char* in_file,
const char* out_dir)
{
/* get the pathname to the json file*/
slist* jlist=json_decode(in_file);
if(!jlist)
return;
/*enter the json symbols into lisp symbol table*/
run_gen_script(out_dir,jlist);
//process_json(jlist);
slist_destroy(jlist,free);
}
void test__create_slist__user_defined_type(void** state)
{
slist_t* pslist = NULL;
type_register(struct _tag_test__create_slist__user_defined_type, NULL, NULL, NULL, NULL);
pslist = _create_slist("struct _tag_test__create_slist__user_defined_type");
assert_true(pslist != NULL);
assert_true(strcmp(_GET_SLIST_TYPE_NAME(pslist), "struct _tag_test__create_slist__user_defined_type") == 0);
assert_true(_slist_is_created(pslist));
slist_destroy(pslist);
}
void test__slist_iterator_get_value__invalid_iterator_end(void** state)
{
int n_value = 0;
slist_iterator_t it_iter;
slist_t* pslist = create_slist(int);
slist_init_elem(pslist, 10, 100);
it_iter = slist_end(pslist);
expect_assert_failure(_slist_iterator_get_value(it_iter, &n_value));
slist_destroy(pslist);
}
int sporth_slist(sporth_stack *stack, void *ud)
{
plumber_data *pd = ud;
char *ftname;
char *filename;
uint32_t size;
slist_d *sl;
switch(pd->mode){
case PLUMBER_CREATE:
sl = malloc(sizeof(slist_d));
sl->list = NULL;
plumber_add_ugen(pd, SPORTH_SLIST, sl);
if(sporth_check_args(stack, "sfs") != SPORTH_OK) {
plumber_print(pd,"Not enough arguments for slist\n");
return PLUMBER_NOTOK;
}
filename = sporth_stack_pop_string(stack);
size = sporth_stack_pop_float(stack);
ftname = sporth_stack_pop_string(stack);
if(slist_parse(sl, filename, size) != PLUMBER_OK) {
plumber_print(pd,
"slist: could not load file %s\n",
filename);
return PLUMBER_NOTOK;
}
plumber_ftmap_add_userdata(pd, ftname, sl);
break;
case PLUMBER_INIT:
sporth_stack_pop_string(stack);
sporth_stack_pop_float(stack);
sporth_stack_pop_string(stack);
break;
case PLUMBER_COMPUTE:
sporth_stack_pop_float(stack);
break;
case PLUMBER_DESTROY:
sl = pd->last->ud;
slist_destroy(sl);
break;
default:
plumber_print(pd,"Error: Unknown mode!");
break;
}
return PLUMBER_OK;
}
void test__slist_iterator_get_value__invalid_iterator(void** state)
{
int n_value = 0;
slist_iterator_t it_iter;
slist_t* pslist = create_slist(int);
slist_init_elem(pslist, 10, 100);
it_iter = slist_begin(pslist);
it_iter._t_pos._pby_corepos = (_byte_t*)0x998;
expect_assert_failure(_slist_iterator_get_value(it_iter, &n_value));
slist_destroy(pslist);
}
void test__slist_iterator_set_value__successfully_cstr(void** state)
{
const char* s_str = "mmmmm";
slist_iterator_t it_iter;
slist_t* pslist = create_slist(char*);
slist_init_elem(pslist, 10, "abcdefg");
it_iter = slist_begin(pslist);
_slist_iterator_set_value(it_iter, s_str);
assert_true(strcmp((char*)slist_front(pslist), "mmmmm") == 0);
slist_destroy(pslist);
}
void test__slist_iterator_get_value__invalid_iterator_container_type(void** state)
{
int n_value = 0;
slist_iterator_t it_iter;
slist_t* pslist = create_slist(int);
slist_init_elem(pslist, 10, 100);
it_iter = slist_begin(pslist);
it_iter._t_containertype = 2199;
expect_assert_failure(_slist_iterator_get_value(it_iter, &n_value));
slist_destroy(pslist);
}
void test__slist_iterator_set_value__successfully(void** state)
{
int n_value = 0;
slist_iterator_t it_iter;
slist_t* pslist = create_slist(int);
slist_init_elem(pslist, 10, 100);
it_iter = slist_begin(pslist);
_slist_iterator_set_value(it_iter, &n_value);
assert_true(*(int*)slist_front(pslist) == 0);
slist_destroy(pslist);
}
void test__slist_iterator_get_value__successfully_cstr(void** state)
{
char* s_str = NULL;
slist_iterator_t it_iter;
slist_t* pslist = create_slist(char*);
slist_init_elem(pslist, 10, "abcdefg");
it_iter = slist_begin(pslist);
_slist_iterator_get_value(it_iter, &s_str);
assert_true(strcmp(s_str, "abcdefg") == 0);
slist_destroy(pslist);
}
void chtbl_destroy(struct chtbl_t *htbl)
{
int i;
if (!htbl)
return;
for (i = 0; i < htbl->buckets; i++) {
slist_destroy(&htbl->table[i]);
}
free(htbl->table);
memset(htbl, 0, sizeof(struct chtbl_t));
return;
}
int tmodule_unload(void)
{
/* Assign the old one locally */
struct slist *mytsockets = tsockets;
struct slist_node *node = NULL;
tsockets = NULL;
node = mytsockets->head;
while (node != NULL)
{
/* Close all sockets */
tsocket_close(node->data);
node = node->next;
}
slist_destroy(mytsockets);
printf("ICS Module unloaded\n");
return 1;
}
