void list_destroy(List* list) {
Atom** p = list->items;
while (p < list->items + list->n_items) {
atom_destroy(*p++);
}
free(list);
}
int atom_eval(Atom* atom, Scope* scope) {
switch (atom->type) {
case ATOM_TYPE_UNKNOWN:
case ATOM_TYPE_INT:
case ATOM_TYPE_UINT:
case ATOM_TYPE_BOOLEAN:
case ATOM_TYPE_STRING:
case ATOM_TYPE_FUNCTION:
break;
case ATOM_TYPE_LIST: {
Atom* result;
if (list_eval(atom->list, scope, &result) != 0) {
return 0; /* cannot evaluate list */
}
atom_set_atom(atom, result);
atom_destroy(result);
} break;
case ATOM_TYPE_TOKEN:
atom_dereference_token(atom, scope);
break;
}
return 0;
}
int atom_test(void)
{
error err;
atom_set_t *d;
d = atom_create_tuned(1, 12);
if (d == NULL)
return 1;
err = test_add(d);
if (err)
return 1;
err = test_to_string(d);
if (err)
return 1;
err = test_to_string_and_len(d);
if (err)
return 1;
err = test_delete(d);
if (err)
return 1;
err = test_to_string_and_len(d);
if (err)
return 1;
err = test_add(d);
if (err)
return 1;
err = test_to_string(d);
if (err)
return 1;
err = test_rename(d);
if (err)
return 1;
err = test_to_string(d);
if (err)
return 1;
err = test_to_string_and_len(d);
if (err)
return 1;
err = test_random(d);
if (err)
return 1;
atom_destroy(d);
return 0;
}
void digestdb_fin(void)
{
if (digestdb_refcount == 0)
return;
if (--digestdb_refcount == 0)
{
/* finalise */
atom_destroy(LOCALS.digests);
}
}
void filenamedb_close(filenamedb_t *db)
{
if (db == NULL)
return;
filenamedb_commit(db);
hash_destroy(db->hash);
atom_destroy(db->filenames);
free(db->filename);
free(db);
}
Atom* atom_duplicate(const Atom* a) {
if (a->is_ref) {
Atom* ret, *tmp = atom_reference(a);;
tmp->is_ref = 0;
ret = atom_duplicate(tmp);
tmp->is_ref = 1;
atom_destroy(tmp);
return ret;
}
switch (a->type) {
case ATOM_TYPE_UNKNOWN:
return atom_new_unknown();
break;
/* value types */
case ATOM_TYPE_INT:
return atom_new_int(*a->i32);
case ATOM_TYPE_UINT:
return atom_new_uint(*a->ui32);
case ATOM_TYPE_BOOLEAN:
return atom_new_boolean(*a->boolean);
/* reference types */
case ATOM_TYPE_STRING:
return atom_new_string(a->string);
case ATOM_TYPE_LIST:
return atom_new_list(a->list);
case ATOM_TYPE_FUNCTION:
return atom_new_function(a->function);
case ATOM_TYPE_TOKEN:
return atom_new_token(a->token);
default: /* unknown */
break;
}
return NULL;
}
error filenamedb_open(const char *filename, filenamedb_t **pdb)
{
error err;
char *filenamecopy = NULL;
atom_set_t *filenames = NULL;
hash_t *hash = NULL;
filenamedb_t *db = NULL;
assert(filename);
assert(pdb);
filenamecopy = str_dup(filename);
if (filenamecopy == NULL)
{
err = error_OOM;
goto Failure;
}
filenames = atom_create_tuned(ATOMBUFSZ / ESTATOMLEN, ATOMBUFSZ);
if (filenames == NULL)
{
err = error_OOM;
goto Failure;
}
err = hash_create(HASHSIZE,
digestdb_hash,
digestdb_compare,
hash_no_destroy_key,
hash_no_destroy_value,
&hash);
if (err)
goto Failure;
db = malloc(sizeof(*db));
if (db == NULL)
{
err = error_OOM;
goto Failure;
}
db->filename = filenamecopy;
db->filenames = filenames;
db->hash = hash;
/* read the database in */
err = pickle_unpickle(filename,
db->hash,
&pickle_writer_hash,
&unformat_methods,
db);
if (err && err != error_PICKLE_COULDNT_OPEN_FILE)
goto Failure;
*pdb = db;
return error_OK;
Failure:
free(db);
hash_destroy(hash);
atom_destroy(filenames);
free(filenamecopy);
return err;
}
