/**
* trie_destroy_node:
* @trie: A #Trie.
* @node: A #TrieNode.
* @value_destroy: A #GDestroyNotify or %NULL.
*
* Removes @node from the #Trie and releases all memory associated with it.
* If the nodes value is set, @value_destroy will be called to release it.
*
* The reclaimation happens as such:
*
* 1) the node is unlinked from its parent.
* 2) each of the children are destroyed, leaving us an empty chain.
* 3) each of the allocated chain links are freed.
* 4) the value pointer is freed.
* 5) the structure itself is freed.
*/
static void
trie_destroy_node (Trie *trie,
TrieNode *node,
GDestroyNotify value_destroy)
{
TrieNodeChunk *iter;
TrieNodeChunk *tmp;
g_assert(node);
trie_node_unlink(node);
while (node->chunk.count) {
trie_destroy_node(trie, node->chunk.children[0], value_destroy);
}
for (iter = node->chunk.next; iter;) {
tmp = iter;
iter = iter->next;
trie_free(trie, tmp);
}
if (node->value && value_destroy) {
value_destroy(node->value);
}
trie_free(trie, node);
}
int build_graph(const char *depfile, struct node_list **headp)
{
FILE *f;
int err;
unsigned int nnodes = 0;
struct trie nodes;
trie_init(&nodes);
f = fopen(depfile, "r");
if (!f) {
perror("failed to open dependency file");
return -1;
}
err = read_depfile(f, &nodes, &nnodes);
fclose(f);
if (err) {
trie_free(&nodes);
return -1;
}
err = trie_iter(&nodes, add_to_list_from_trie, headp);
if (err) {
free_node_list(*headp);
nnodes = -1;
}
trie_free(&nodes);
return nnodes;
}
Trie* parse_Towns(FILE* f) {
Trie* my_towns = trie_new();
if(f != NULL) {
rewind(f);
char* line = NULL;
size_t n;
while(getline(&line, &n, f) != -1) {
strtok(line, ":");
char* split = strtok(NULL, ":");
if(split == NULL) {
trie_free(my_towns);
return NULL;
}
split[-1] = '\0'; /* Élimination du ':' */
float x, y;
int found;
found = sscanf(split, " %f; %f!", &x, &y);
if(found != 2) {
trie_free(my_towns);
return NULL;
}
my_towns = trie_addTown(my_towns, line, x, y);
}
free(line);
}
return my_towns;
}
int
main (void)
{
AlphaMap *alpha_map;
Trie *test_trie;
AlphaChar key[3];
TrieData data;
msg_step ("Preparing alpha map");
alpha_map = alpha_map_new ();
if (!alpha_map) {
printf ("Fail to allocate alpha map\n");
goto err_alpha_map_not_created;
}
if (alpha_map_add_range (alpha_map, 0x00, 0xff) != 0) {
printf ("Fail to add full alpha map range\n");
goto err_alpha_map_created;
}
msg_step ("Preparing trie");
test_trie = trie_new (alpha_map);
alpha_map_free (alpha_map);
if (!test_trie) {
printf ("Fail to create test trie\n");
goto err_alpha_map_created;
}
msg_step ("Storing key to test trie");
key[0] = 0xff;
key[1] = 0xff;
key[2] = 0;
if (!trie_store (test_trie, key, TEST_DATA)) {
printf ("Fail to store key to test trie\n");
goto err_trie_created;
}
msg_step ("Retrieving data from test trie");
if (!trie_retrieve (test_trie, key, &data)) {
printf ("Fail to retrieve key from test trie\n");
goto err_trie_created;
}
if (TEST_DATA != data) {
printf ("Retrieved data = %d, not %d\n", data, TEST_DATA);
goto err_trie_created;
}
msg_step ("Freeing test trie");
trie_free (test_trie);
return 0;
err_trie_created:
trie_free (test_trie);
err_alpha_map_created:
alpha_map_free (alpha_map);
err_alpha_map_not_created:
return 1;
}
void
trie_free(trie_t trie)
{
if(trie != NULL_TRIE)
{
trie_free(trie->left);
trie_free(trie->right);
trie_free(trie->children);
free(trie);
}
}
int
main (void)
{
Trie *test_trie;
DictRec *dict_p;
const AlphaChar **nonalpha_key;
TrieData trie_data;
Bool is_fail;
msg_step ("Preparing trie");
test_trie = en_trie_new ();
if (!test_trie) {
fprintf (stderr, "Fail to create test trie\n");
goto err_trie_not_created;
}
/* store */
msg_step ("Adding data to trie");
for (dict_p = dict_src; dict_p->key; dict_p++) {
if (!trie_store (test_trie, dict_p->key, dict_p->data)) {
printf ("Failed to add key '%ls', data %d.\n",
(wchar_t *)dict_p->key, dict_p->data);
goto err_trie_created;
}
}
/* test storing keys with non-alphabet chars */
is_fail = FALSE;
for (nonalpha_key = nonalpha_src; *nonalpha_key; nonalpha_key++) {
if (trie_retrieve (test_trie, *nonalpha_key, &trie_data)) {
printf ("False duplication on key '%ls', with existing data %d.\n",
(wchar_t *)*nonalpha_key, trie_data);
is_fail = TRUE;
}
if (trie_store (test_trie, *nonalpha_key, TRIE_DATA_UNREAD)) {
printf ("Wrongly added key '%ls' containing non-alphanet char\n",
(wchar_t *)*nonalpha_key);
is_fail = TRUE;
}
}
if (is_fail)
goto err_trie_created;
trie_free (test_trie);
return 0;
err_trie_created:
trie_free (test_trie);
err_trie_not_created:
return 1;
}
void test_trie_remove(void)
{
Trie *trie;
char buf[10];
int i;
unsigned int entries;
trie = generate_trie();
/* Test remove on non-existent values. */
assert(trie_remove(trie, "000000000000000") == 0);
assert(trie_remove(trie, "") == 0);
entries = trie_num_entries(trie);
assert(entries == NUM_TEST_VALUES);
/* Remove all values */
for (i=0; i<NUM_TEST_VALUES; ++i) {
sprintf(buf, "%i", i);
/* Remove value and check counter */
assert(trie_remove(trie, buf) != 0);
--entries;
assert(trie_num_entries(trie) == entries);
}
trie_free(trie);
}
void test_trie_lookup(void)
{
Trie *trie;
char buf[10];
int *val;
int i;
trie = generate_trie();
/* Test lookup for non-existent values */
assert(trie_lookup(trie, "000000000000000") == TRIE_NULL);
assert(trie_lookup(trie, "") == TRIE_NULL);
/* Look up all values */
for (i=0; i<NUM_TEST_VALUES; ++i) {
sprintf(buf, "%i", i);
val = (int *) trie_lookup(trie, buf);
assert(*val == i);
}
trie_free(trie);
}
void test_trie_insert(void)
{
Trie *trie;
unsigned int entries;
size_t allocated;
trie = generate_trie();
/* Test insert of NULL value has no effect */
entries = trie_num_entries(trie);
assert(trie_insert(trie, "hello world", NULL) == 0);
assert(trie_num_entries(trie) == entries);
/* Test out of memory scenario */
allocated = alloc_test_get_allocated();
alloc_test_set_limit(0);
assert(trie_insert(trie, "a", "test value") == 0);
assert(trie_num_entries(trie) == entries);
/* Test rollback */
alloc_test_set_limit(5);
assert(trie_insert(trie, "hello world", "test value") == 0);
assert(alloc_test_get_allocated() == allocated);
assert(trie_num_entries(trie) == entries);
trie_free(trie);
}
void
brk_maximal_on_unload ()
{
if (brk_dict) {
trie_free (brk_dict);
}
}
void trie_free( Trie *t,
void (*free_data_callback) (void*) ) {
int i;
if ( t == NULL ) {
return;
}
if ( t->children ) {
Trie *child;
for ( i = 0; i < TRIE_ALPHABET_SIZE; ++i ) {
if ( ( child = t->children[i] ) != 0 ) {
trie_free( child, free_data_callback );
}
}
}
if ( t->prefix ) {
free( t->prefix );
}
if ( t->children ) {
free( t->children );
}
if ( t->data && free_data_callback ) {
free_data_callback( t->data );
}
free( t );
}
void test_trie_insert_binary(void)
{
Trie *trie;
char *value;
trie = generate_binary_trie();
/* Overwrite a value */
assert(trie_insert_binary(trie,
bin_key, sizeof(bin_key),
"hi world") != 0);
/* Insert NULL value doesn't work */
assert(trie_insert_binary(trie, bin_key3, sizeof(bin_key3), NULL) == 0);
/* Read them back */
value = trie_lookup_binary(trie, bin_key, sizeof(bin_key));
assert(!strcmp(value, "hi world"));
value = trie_lookup_binary(trie, bin_key2, sizeof(bin_key2));
assert(!strcmp(value, "goodbye world"));
trie_free(trie);
}
void test_trie_remove_binary(void)
{
Trie *trie;
void *value;
trie = generate_binary_trie();
/* Test look up and remove of invalid values */
value = trie_lookup_binary(trie, bin_key3, sizeof(bin_key3));
assert(value == NULL);
assert(trie_remove_binary(trie, bin_key3, sizeof(bin_key3)) == 0);
assert(trie_lookup_binary(trie, bin_key4, sizeof(bin_key4)) == 0);
assert(trie_remove_binary(trie, bin_key4, sizeof(bin_key4)) == 0);
/* Remove the two values */
assert(trie_remove_binary(trie, bin_key2, sizeof(bin_key2)) != 0);
assert(trie_lookup_binary(trie, bin_key2, sizeof(bin_key2)) == NULL);
assert(trie_lookup_binary(trie, bin_key, sizeof(bin_key)) != NULL);
assert(trie_remove_binary(trie, bin_key, sizeof(bin_key)) != 0);
assert(trie_lookup_binary(trie, bin_key, sizeof(bin_key)) == NULL);
trie_free(trie);
}
void falcon_cache_free(falcon_cache_t *cache)
{
g_return_if_fail(cache);
trie_free(cache->objects, (trie_free_func)falcon_object_free);
g_mutex_free(cache->lock);
g_free(cache);
}
void trie_free(trie_t * top){
for(int i = 0; i < 1<<STRIDE; i++){
if(top->children[i] != NULL){
trie_free(top->children[i]);
}
}
free(top);
}
void trie_free(trie* t) {
int i = 0;
for (i = 0; i < t->count; i++) {
trie* x = &(t->children[i]);
trie_free(x);
}
free(t->children);
}
ATTrie :: ~ATTrie()
{
if (data->trie != NULL)
trie_free(data->trie);
if (data->amap != NULL)
alpha_map_free(data->amap);
delete data;
}
static void atms_node_free(atms_node node)
{
array_free(node->consequences);
trie_free(node->label);
free(node);
}
static void propagate(atms tms, atms_justification J, atms_node a, trie I)
{
trie L = weave(tms, a, I, J->antecedents);
if (!trie_is_empty(L)) {
update(tms, L, J->consequent);
}
trie_free(L);
}
void trie_free(trie_t *t)
{
int i;
for (i = /*skip sentinel*/ 1; i < TRIE_SIZE; i++) {
if (t->chars[i] != NULL) {
trie_free(t->chars[i]);
}
}
free(t);
}
void falcon_cache_clear(falcon_cache_t *cache)
{
g_return_if_fail(cache);
g_mutex_lock(cache->lock);
trie_free(cache->objects, (trie_free_func)falcon_object_free);
cache->objects = trie_new(G_DIR_SEPARATOR_S, 1);
cache->count = 0;
g_mutex_unlock(cache->lock);
}
int main(int argc, char **argv, char **env) {
debug("int main(int argc, char **argv, char **env)");
unsigned char buffer[PACKET_SIZE];
#ifndef USE_GLOBAL
Trie* trie = NULL
#endif
trie = trie_try_new(trie);
for(;;) {
/**
Читаем сообщение из буфера,
до тех пор пока можем их читать,
и пока не получили неизвестную нам команду
**/
if (1 != read_cmd(buffer)){
trie_free(trie);
exit(1);
}
switch (*buffer) {
case CMD_VERSION:
/**
Запрос версии
**/
cmd_version();
break;
case CMD_APPLY_XSL:
/**
Запрос на преобразование
**/
cmd_apply_xsl(trie);
break;
default:
/**
Неведомая фигня
**/
trie_free(trie);
fprintf(stderr, "unknown command %c in adapter\n",
*buffer);
exit(1);
}
}
}
void
trie_free(trie_ptr * r, void (*func) (void *))
{
trie_ptr p;
while ((p = *r)) {
trie_free(&p->more, func);
*r = p->otherwise;
if (func)
(*func) (p->value);
free(p);
}
}
void test_trie_new_free(void)
{
Trie *trie;
/* Allocate and free an empty trie */
trie = trie_new();
assert(trie != NULL);
trie_free(trie);
/* Add some values before freeing */
trie = trie_new();
assert(trie_insert(trie, "hello", "there") != 0);
assert(trie_insert(trie, "hell", "testing") != 0);
assert(trie_insert(trie, "testing", "testing") != 0);
assert(trie_insert(trie, "", "asfasf") != 0);
trie_free(trie);
/* Add a value, remove it and then free */
trie = trie_new();
assert(trie_insert(trie, "hello", "there") != 0);
assert(trie_remove(trie, "hello") != 0);
trie_free(trie);
/* Test out of memory scenario */
alloc_test_set_limit(0);
trie = trie_new();
assert(trie == NULL);
}
/* Generates a file containing pairs of deligatured & "real" words,
one pair per line. This file can then be used to efficiently load
the ligatures into memory via the load_ligatures() function.
Allows ligature generation to be performed as one-time
preprocessing step. */
int generate_ligatures( char *dictionary_file,
char *ligature_file ) {
Trie *trie;
if ( trie = find_ligatures( dictionary_file ) ) {
FILE *ligatures_fp = fopen( ligature_file, "w" );
if ( ligatures_fp ) {
trie_iterate_dfs( trie,
write_ligature_callback,
ligatures_fp );
}
fclose( ligatures_fp );
}
trie_free( trie, _free_ligature_data_callback2 );
}
void trie_free(struct trie *t)
{
unsigned int i;
if (!t)
return;
for (i = 0; i < NELMS; i += 1) {
if (t->kids[i]) {
trie_free(t->kids[i]);
free((void *) t->kids[i]->key);
free(t->kids[i]);
}
}
}
void test_trie_insert_out_of_memory(void)
{
Trie *trie;
trie = generate_binary_trie();
alloc_test_set_limit(3);
assert(trie_insert_binary(trie,
bin_key4, sizeof(bin_key4),
"test value") == 0);
assert(trie_lookup_binary(trie, bin_key4, sizeof(bin_key4)) == NULL);
assert(trie_num_entries(trie) == 2);
trie_free(trie);
}
void test_trie_replace(void)
{
Trie *trie;
int *val;
trie = generate_trie();
/* Test replacing values */
val = malloc(sizeof(int));
*val = 999;
assert(trie_insert(trie, "999", val) != 0);
assert(trie_num_entries(trie) == NUM_TEST_VALUES);
assert(trie_lookup(trie, "999") == val);
free(val);
trie_free(trie);
}
void
rsynth_term(rsynth_t * rsynth)
{
if (rsynth) {
rsynth_flush(rsynth, 0);
trie_free(&phtoelm, &free);
#ifdef DO_RANGE_CHECKS
fprintf(stderr, "Max range %g @ %s:%d\n", range_max, __FILE__,
range_ln);
#endif
if (rsynth->voice_file)
fclose(rsynth->voice_file);
if (rsynth->parm_file)
fclose(rsynth->parm_file);
free(rsynth->pvt);
free(rsynth);
}
}
void test_trie_insert_empty(void)
{
Trie *trie;
char buf[10];
trie = trie_new();
/* Test insert on empty string */
assert(trie_insert(trie, "", buf) != 0);
assert(trie_num_entries(trie) != 0);
assert(trie_lookup(trie, "") == buf);
assert(trie_remove(trie, "") != 0);
assert(trie_num_entries(trie) == 0);
trie_free(trie);
}
