void command_add (command_fn_t callback,
const char *input,
const char *readable)
{
if (!commands) {
commands = tree_alloc(TREE_KEY_STRING, "TREE ROOT: commands");
}
command_t *command = (typeof(command))
myzalloc(sizeof(*command), "TREE NODE: command");
command->tree.key = dupstr(input, "TREE KEY: command");
command->callback = callback;
/*
* Convert the command into tokens for matching.
*/
tokens_tostring(input, &command->tokens);
tokens_tostring(input, &command->input_tokens);
tokens_tostring(readable, &command->readable_tokens);
if (!tree_insert(commands, &command->tree.node)) {
ERR("insert of command %s fail", input);
}
}
static int addrs_configure(backend_t *chain, hash_t *config){
ssize_t ret;
DT_UINT32T elements_per_level = 0;
DT_UINT32T read_per_calc = READ_PER_CALC_DEFAULT;
addrs_userdata *data = (addrs_userdata *)chain->userdata;
hash_data_copy(ret, TYPE_UINT32T, elements_per_level, config, HK(perlevel));
hash_data_copy(ret, TYPE_UINT32T, read_per_calc, config, HK(read_size));
if(elements_per_level <= 1)
return -EINVAL; // "chain blocks-address variable 'per-level' invalid");
if(read_per_calc < 1)
read_per_calc = READ_PER_CALC_DEFAULT;
if( (data->tree = tree_alloc(chain, elements_per_level, read_per_calc)) == NULL)
return error("chain blocks-address no memory");
if(tree_recalc(data->tree) != 0){
tree_free(data->tree);
return error("chain blocks-address tree recalc failed");
}
return 0;
}
semainfo_t
sinfo_create_type(typeinfo_t t)
{
semainfo_t ptr = (semainfo_t) tree_alloc(sizeof(struct s_type));
ptr->tag = ST_TYPE;
ptr->s_type.type = t;
return ptr;
}
semainfo_t
sinfo_create_swlab(struct sema_switem *def)
{
semainfo_t ptr = (semainfo_t) tree_alloc(sizeof(struct s_swlab));
ptr->tag = ST_SWLAB;
ptr->s_swlab.def = def;
return ptr;
}
void
sema_add_to_gotos(struct sema_scope *scope, void *ptr)
{
struct sema_list *p = (struct sema_list*) tree_alloc(sizeof (*p));
p->next = scope->gotos;
p->item = ptr;
scope->gotos = p;
}
semainfo_t
sinfo_create_scope(struct sema_scope *scope)
{
semainfo_t ptr = (semainfo_t) tree_alloc(sizeof (*ptr));
ptr->tag = ST_SCOPE;
ptr->s_scope.scope = scope;
return ptr;
}
semainfo_t
sinfo_create_iduse(struct sema_def *def)
{
semainfo_t ptr = (semainfo_t) tree_alloc(sizeof(struct s_iduse));
ptr->tag = ST_IDUSE;
ptr->s_iduse.def = def;
return ptr;
}
/*
* Create a new tree node.
*/
static TREE_NODE *new_tree_node(TREE_ROOT *root)
{
TREE_NODE *node;
int size = sizeof(TREE_NODE);
node = (TREE_NODE *)tree_alloc(root, size);
memset(node, 0, size);
node->delta_seq = -1;
return node;
}
typeinfo_t
typeinfo_create_builtin(int bits, int ind)
{
typeinfo_t np = (typeinfo_t) tree_alloc(sizeof(struct s_builtin));
np->tag = CPT_BUILTIN;
np->t_builtin.bits = bits;
np->t_builtin.ind = ind;
return np;
}
typeinfo_t
typeinfo_create_enum(int bits, ident_t id, struct sema_def *def)
{
typeinfo_t np = (typeinfo_t) tree_alloc(sizeof(struct s_enum));
np->tag = CPT_ENUM;
np->t_enum.bits = bits;
np->t_enum.id = id;
np->t_enum.def = def;
return np;
}
typeinfo_t
typeinfo_create_aggreg(int bits, ident_t id, struct sema_def *def)
{
typeinfo_t np = (typeinfo_t) tree_alloc(sizeof(struct s_aggreg));
np->tag = CPT_AGGREG;
np->t_aggreg.bits = bits;
np->t_aggreg.id = id;
np->t_aggreg.def = def;
return np;
}
typeinfo_t
typeinfo_create_pointer(int bits, typeinfo_t type)
{
typeinfo_t np = (typeinfo_t) tree_alloc(sizeof(struct s_pointer));
np->tag = CPT_POINTER;
np->t_pointer.bits = bits;
np->t_pointer.type = type;
np->t_pointer.size = 4;
return np;
}
typeinfo_t
typeinfo_create_array(typeinfo_t type, rulong_t elnum, typeinfo_t size_def)
{
typeinfo_t np = (typeinfo_t) tree_alloc(sizeof(struct s_array));
np->tag = CPT_ARRAY;
np->t_array.type = type;
np->t_array.elnum = elnum;
np->t_array.size_def = size_def;
return np;
}
typeinfo_t
typeinfo_create_typedef(int bits, ident_t id, struct sema_def *def)
{
typeinfo_t np = (typeinfo_t) tree_alloc(sizeof(struct s_typedef));
np->tag = CPT_TYPEDEF;
np->t_typedef.bits = bits;
np->t_typedef.id = id;
np->t_typedef.def = def;
return np;
}
musicp music_load (const char *file, const char *name_alias)
{
if (name_alias) {
musicp m = music_find(name_alias);
if (m) {
return (m);
}
}
if (!file) {
if (!name_alias) {
ERR("no file for music");
} else {
ERR("no file for music loading %s", name_alias);
}
}
if (!all_music) {
all_music = tree_alloc(TREE_KEY_STRING, "TREE ROOT: music");
}
musicp m = (typeof(m)) myzalloc(sizeof(*m), "TREE NODE: music");
m->tree.key = dupstr(name_alias, "TREE KEY: music");
if (!tree_insert(all_music, &m->tree.node)) {
ERR("music insert name_alias [%s] failed", name_alias);
}
m->data = ramdisk_load(file, &m->len);
if (!m->data) {
ERR("cannot load music %s", file);
}
SDL_RWops *rw;
rw = SDL_RWFromMem(m->data, m->len);
if (!rw) {
ERR("cannot make RW music %s", file);
}
#if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2 /* { */
m->music = Mix_LoadMUS_RW(rw);
#else
m->music = Mix_LoadMUS_RW(rw, false);
#endif /* } */
if (!m->music) {
MSG_BOX("Mix_LoadMUS_RW fail %s: %s %s", file, Mix_GetError(),
SDL_GetError());
SDL_ClearError();
}
DBG("Load %s", file);
return (m);
}
/*
* Add Delta part for this node
*/
void tree_add_delta_part(TREE_ROOT *root, TREE_NODE *node,
JobId_t JobId, int32_t FileIndex)
{
struct delta_list *elt = (struct delta_list *)
tree_alloc(root, sizeof(struct delta_list));
elt->next = node->delta_list;
elt->JobId = JobId;
elt->FileIndex = FileIndex;
node->delta_list = elt;
}
semainfo_t
sinfo_create_goto(struct sema_def *def, struct sema_scope *use_scope,
struct sema_scope_list *scopes)
{
semainfo_t ptr = (semainfo_t) tree_alloc(sizeof(struct s_goto));
ptr->tag = ST_GOTO;
ptr->s_goto.def = def;
ptr->s_goto.use_scope = use_scope;
ptr->s_goto.scopes = scopes;
return ptr;
}
struct sema_scope *
sema_scope_create(struct sema_scope *up)
{
struct sema_scope *ptr = (struct sema_scope*) tree_alloc(sizeof (*ptr));
ptr->up = up;
ptr->size = 0;
if (up) {
ptr->func = up->func;
}
return ptr;
}
typeinfo_t
typeinfo_create_function(int bits, typeinfo_t ret_type,
struct sema_scope *par_scope,
struct sema_scope *impl_par_scope)
{
typeinfo_t np = (typeinfo_t) tree_alloc(sizeof(struct s_function));
np->tag = CPT_FUNCTION;
np->t_function.bits = bits;
np->t_function.ret_type = ret_type;
np->t_function.par_scope = par_scope;
np->t_function.impl_par_scope = impl_par_scope;
np->t_function.size = (unsigned long) -1;
return np;
}
struct sema_scope *
sema_function_scope_create(struct sema_scope *up, struct sema_def *def)
{
struct sema_scope *ptr = 0;
ASSERT(up);
ASSERT(!up->func);
ptr = (struct sema_scope*) tree_alloc(sizeof (*ptr));
ptr->up = up;
ptr->size = 0;
ptr->func = ptr;
ptr->def = def;
return ptr;
}
int main(){
struct tree *tree = tree_alloc(compare);
int i = 1;
int j = 10;
int k = 20;
int l = 13;
int z = 12;
tree_insert(tree, &k, sizeof(int));
tree_insert(tree, &j, sizeof(int));
tree_insert(tree, &l, sizeof(int));
tree_insert(tree, &i, sizeof(int));
tree_insert(tree, &i, sizeof(int));
assert(tree_contains(tree, &i) == 1);
assert(tree_contains(tree, &z) == 0);
return 0;
}
int tree_swap(struct tree_item *root)
{
struct tree *new_tree, *old_tree;
new_tree = tree_alloc();
if (NULL == new_tree)
return -1;
new_tree->root = root;
/* Save old tree */
old_tree = tree_get();
/* Critical - swap trees */
lock_get(shared_tree_lock);
*shared_tree = new_tree;
lock_release(shared_tree_lock);
/* Flush old tree */
tree_flush(old_tree);
return 0;
}
/*
* See if the fname already exists. If not insert a new node for it.
*/
static TREE_NODE *search_and_insert_tree_node(char *fname, int type,
TREE_ROOT *root, TREE_NODE *parent)
{
TREE_NODE *node, *found_node;
node = new_tree_node(root);
node->fname = fname;
found_node = (TREE_NODE *)parent->child.insert(node, node_compare);
if (found_node != node) { /* already in list */
free_tree_node(root); /* free node allocated above */
found_node->inserted = false;
return found_node;
}
/*
* It was not found, but is now inserted
*/
node->fname_len = strlen(fname);
node->fname = tree_alloc(root, node->fname_len + 1);
strcpy(node->fname, fname);
node->parent = parent;
node->type = type;
/*
* Maintain a linear chain of nodes
*/
if (!root->first) {
root->first = node;
root->last = node;
} else {
root->last->next = node;
root->last = node;
}
node->inserted = true; /* inserted into tree */
return node;
}
int main(int argc, char **argv)
{
tree_t *tree = NULL;
treenode_t *node = NULL;
person_t *person = NULL;
if (_parse_cmd(argc, argv)) {
_usage();
return -1;
}
if (_init())
return -1;
tree = tree_alloc(NULL, person_find, person_print,
person_free, 0x1234);
person = malloc(sizeof(person_t));
if (!person)
goto out_free;
strncpy(person->name, "fz", NAMELEN - 1);
person->age = 33;
tree_add_end(tree, NULL, person);
node = tree_find(tree, person);
if (node) {
printf("find (%s:%d) in tree\n", person->name, person->age);
person = malloc(sizeof(person_t));
if (!person)
goto out_free;
strncpy(person->name, "forrest", NAMELEN -1);
person->age = 11;
tree_add_first(tree, node, person);
person = malloc(sizeof(person_t));
if (!person)
goto out_free;
strncpy(person->name, "bug", NAMELEN -1);
person->age = 13;
tree_add_end(tree, node, person);
}
tree_print(tree);
person = malloc(sizeof(person_t));
if (!person)
goto out_free;
strncpy(person->name, "fz", NAMELEN -1);
person->age = 33;
node = tree_find(tree, person);
if (node) {
printf("find (%s:%d) in tree\n", person->name, person->age);
}
tree_del(tree, person);
free(person);
tree_print(tree);
out_free:
tree_free(tree);
_release();
return 0;
}
