static Tree_s *pair (void)
{
FN;
Tree_s *tree;
Token_s s;
Token_s t;
Tree_s *v;
Tree_s *p;
s = get_token();
if (s.type != T_STRING) {
unget_token(s);
return NULL;
}
t = get_token();
if (t.type != ':') {
unget_token(t);
warn("Expecting ':'");
return NULL;
}
v = value();
if (!v) {
warn("Expecting value");
return NULL;
}
tree = new_tree();
tree->token = s;
tree->right = v;
p = new_tree();
p->token.type = T_PAIR;
p->left = tree;
return p;
}
//分析 expr
ast_tree *parser_expr(token_result *result)
{
ast_tree *tree;
token *t;
if((t = next_token(result)) == NULL)
return NULL;
if(t->type == TOKEN_NUM){
tree = new_tree();
ast_tag(tree,"expr");
return parser_num(tree, t->num);
}
if(t->type == TOKEN_SYM){
if(strcmp(t->sym, "(") == 0){
putback_token();
return parser_sexpr(result);
}
if(strcmp(t->sym, "'") == 0){
putback_token();
return parser_qexpr(result);
}
else{
tree = new_tree();
ast_tag(tree,"expr");
return parser_sym(tree, t->sym);
}
}
}
/* arguments tree.
* set argtree to NULL when first called.
*/
Tree arg_tree(Tree argtree, Symtab function, Symbol arg, Tree expr) {
Tree t, right;
if (arg != NULL && arg->type->type_id != expr->result_type->type_id)
{
/* do conversions, left for excises. */
parse_error("type miss match.", "");
}
if (argtree == NULL)
{
if (arg != NULL)
t = new_tree(ARG, arg->type, expr, NULL);
else
t = new_tree(ARG, expr->result_type, expr, NULL);
t->u.arg.sym = arg;
t->u.arg.symtab = function;
return t;
}
/* append to right tree. */
right = right_tree(&(argtree->kids[1]), expr);
right->u.arg.sym = arg;
right->u.arg.symtab = function;
return argtree;
}
struct suffixtree_s create_suffixtree(const char* text)
{
int laenge = strlen(text);
struct suffixtree_s rt;
const char* pos;
tree t;
int i;
rt.text = text;
rt.root = new_tree(text, text, NULL, NULL, 0);
rt.table = (int*)malloc((laenge + 1) * sizeof(int));
if (NULL == rt.table) {
perror(__func__);
abort();
}
for (i = 0; i <= laenge; i++) {
pos = text + i;
t = walk(rt.root, &pos, true);
t->child = new_tree(pos, text + laenge + 1,
t->child, NULL, i);
}
rt.size = renumber(rt.root, 0, rt.table);
assert(rt.size == laenge + 1);
return rt;
}
bst* build123()
{
bst *root = new_tree(2);
root->left = new_tree(1);
root->right = new_tree(3);
return root;
}
/* get value of id tree. */
Tree id_factor_tree(Tree source, Symbol sym) {
Tree t;
if (source)
t = new_tree(LOAD, source->result_type, source, NULL);
else
t = new_tree(LOAD, sym->type, NULL, NULL);
t->u.generic.sym = sym;
return t;
}
/* get address tree */
Tree address_tree(Tree source, Symbol sym) {
Tree t;
if (source)
t = new_tree(ADDRG, source->result_type, source, NULL);
else
t = new_tree(ADDRG, sym->type, NULL, NULL);
t->u.generic.sym = sym;
return t;
}
void tree_splitNode(TreeNode *node)
{
int i;
Rect child_space;
//fprintf(stderr,">> Node splitting !\n");
// Creation des fils
child_space.x = node->node_space.x;
child_space.y = node->node_space.y;
child_space.w = node->node_space.w/2;
child_space.h = node->node_space.h/2;
node->childs[0] = new_tree(child_space);
child_space.x = node->node_space.x + node->node_space.w/2;
child_space.y = node->node_space.y;
child_space.w = node->node_space.w/2;
child_space.h = node->node_space.h/2;
node->childs[1] = new_tree(child_space);
child_space.x = node->node_space.x;
child_space.y = node->node_space.y + node->node_space.h/2;
child_space.w = node->node_space.w/2;
child_space.h = node->node_space.h/2;
node->childs[2] = new_tree(child_space);
child_space.x = node->node_space.x + node->node_space.w/2;
child_space.y = node->node_space.y + node->node_space.h/2;
child_space.w = node->node_space.w/2;
child_space.h = node->node_space.h/2;
node->childs[3] = new_tree(child_space);
node->nb_dynamicObjects = node->nb_staticObjects = 0;
// Remplissage
for(i=0; i<NODE_MAX_STATIC_ACTOR; ++i)
{
if(node->staticObjects[i] != NULL)
{
tree_moveActorToChild(node, node->staticObjects[i], 0);
node->staticObjects[i] = NULL;
}
}
for(i=0; i<NODE_MAX_DYNAMIC_ACTOR; ++i)
{
if(node->dynamicObjects[i] != NULL)
{
tree_moveActorToChild(node, node->dynamicObjects[i], 1);
node->dynamicObjects[i] = NULL;
}
}
//fprintf(stderr,">> Node splitted.\n");
}
/* system call */
Tree sys_tree(int sys_id, Tree argstree) {
Tree t;
Symtab ptab;
ptab = find_sys_routine(sys_id);
if (ptab)
t = new_tree(SYS, ptab->type, argstree, NULL);
else
t = new_tree(SYS, find_type_by_id(TYPE_VOID), argstree, NULL);
t->u.sys.sys_id = sys_id;
return t;
}
string& new_value() {
if (stack.empty()) return new_tree().data();
layer& l = stack.back();
switch (l.k) {
case leaf:
stack.pop_back();
return new_value();
case object:
l.k = key;
key_buffer.clear();
return key_buffer;
default:
return new_tree().data();
}
}
/* conditional condition.*/
Tree cond_jump_tree(Tree cond, int boolean, Symbol label)
{
Tree t = new_tree(COND, label->type, cond, NULL);
t->u.cond_jump.label = label;
t->u.cond_jump.true_or_false = boolean;
return t;
}
int check_tree_or_cmd(t_param *param, int i)
{
int j;
t_param *tmp_param;
t_cmd *tmp_cmd;
tmp_param = param->next;
while (tmp_param != param)
{
j = i;
while (g_parse_tree[j])
{
tmp_cmd = tmp_param->cmd->next;
while (tmp_cmd != tmp_param->cmd)
{
if (tmp_cmd->type == g_parse_tree[j])
if (new_tree(&tmp_cmd, tmp_param, &j) == -1)
return (-1);
tmp_cmd = tmp_cmd->next;
}
j++;
}
tmp_param = tmp_param->next;
}
return (0);
}
/*
* Checks to see if an IP is client or server by finding it in the tree
* returns SERVER or CLIENT.
* if mode = UNKNOWN, then abort on unknowns
* if mode = CLIENT, then unknowns become clients
* if mode = SERVER, then unknowns become servers
*/
int
check_ip_tree(const int mode, const unsigned long ip)
{
struct tree_type *node = NULL, *finder = NULL;
finder = new_tree();
finder->ip = ip;
node = RB_FIND(data_tree, &treeroot, finder);
if (node == NULL && mode == UNKNOWN)
errx(1, "%s (%lu) is an unknown system... aborting.!\n"
"Try a different auto mode (-n router|client|server)",
libnet_addr2name4(ip, RESOLVE), ip);
#ifdef DEBUG
if (node->type == SERVER) {
dbg(1, "Server: %s", libnet_addr2name4(ip, RESOLVE));
}
else if (node->type == CLIENT) {
dbg(1, "Client: %s", libnet_addr2name4(ip, RESOLVE));
}
else {
dbg(1, "Unknown: %s", libnet_addr2name4(ip, RESOLVE));
}
#endif
/* return node type if we found the node, else return the default (mode) */
if (node != NULL) {
return (node->type);
}
else {
return mode;
}
}
Tree * duplicate_tree(const Tree * src)
{
if (!src) return NULL;
return new_tree(duplicate_tree(src->left),
duplicate_tree(src->right), src->val);
}
MathTree* clone_tree(MathTree* orig)
{
MathTree* clone = new_tree(orig->num_levels, orig->num_constants);
// Clone the constants into the new tree.
for (int c=0; c < orig->num_constants; ++c) {
clone->constants[c] = clone_node(orig->constants[c]);
}
// Then clone all of the nodes into the new tree:
// Iterate over levels
for (int level=0; level < orig->num_levels; ++level) {
int active = orig->active[level];
clone->active[level] = active;
if (active) {
clone->nodes[level] = malloc(sizeof(Node*)*active);
} else {
clone->nodes[level] = NULL;
}
// Clone each node in this level and opcode.
for (int n=0; n < active; ++n) {
Node* clone_ = clone_node(orig->nodes[level][n]);
clone->nodes[level][n] = clone_;
}
}
clone->head = orig->head->clone_address;
return clone;
}
static bool build_directory_tree(UAContext *ua, RESTORE_CTX *rx)
{
TREE_CTX tree;
JobId_t JobId, last_JobId;
char *p;
bool OK = true;
char ed1[50];
memset(&tree, 0, sizeof(TREE_CTX));
/*
* Build the directory tree containing JobIds user selected
*/
tree.root = new_tree(rx->TotalFiles);
tree.ua = ua;
tree.all = rx->all;
last_JobId = 0;
/*
* For display purposes, the same JobId, with different volumes may
* appear more than once, however, we only insert it once.
*/
p = rx->JobIds;
tree.FileEstimate = 0;
if (get_next_jobid_from_list(&p, &JobId) > 0) {
/* Use first JobId as estimate of the number of files to restore */
Mmsg(rx->query, uar_count_files, edit_int64(JobId, ed1));
if (!db_sql_query(ua->db, rx->query, restore_count_handler, (void *)rx)) {
ua->error_msg("%s\n", db_strerror(ua->db));
}
if (rx->found) {
/* Add about 25% more than this job for over estimate */
tree.FileEstimate = rx->JobId + (rx->JobId >> 2);
tree.DeltaCount = rx->JobId/50; /* print 50 ticks */
}
void s_test_tree_balance(void) {
int items = 500;
int sizeOfElement = sizeof(int);
Tree tree = new_tree(sizeOfElement, navigateItem, NULL, NULL, NULL);
int b = 0;
double d = 1.44;
double f = 0.328;
double g = log2(items+2);
double res = (d*g) - f;
for (int i = 0; i < items; i++) {
b = i;
tree_insert(&tree, &b, NULL);
CU_ASSERT_TRUE(get_tree_height(tree) <= res);
}
//An AVL tree height should be strictly lower than 1.44log2(n+2)-0.328 where n = the number of items.
//printTest(&tree, printInt);
if (tree != NULL) {
destroy_tree(&tree);
}
}
int main(void)
{
tree start = *new_tree(int_compare).value;
print_tree(start);
start = insert(start, FatPointer<int>(1)).out;
print_tree(start);
start = insert(start, FatPointer<int>(3)).out;
print_tree(start);
start = insert(start, FatPointer<int>(5)).out;
print_tree(start);
start = insert(start, FatPointer<int>(7)).out;
print_tree(start);
start = insert(start, FatPointer<int>(0)).out;
print_tree(start);
start = insert(start, FatPointer<int>(4)).out;
print_tree(start);
insert(start, FatPointer<int>(2));
print_tree(start);
start = find(start, FatPointer<int>(7)).out;
print_tree(start);
start = find(start, FatPointer<int>(2)).out;
print_tree(start);
start = _delete(start, FatPointer<int>(5)).out;
print_tree(start);
start = _delete(start, FatPointer<int>(2)).out;
print_tree(start);
}
/* get value of a field of record. */
Tree field_tree(Symbol record, Symbol field) {
Tree t = new_tree(FIELD, field->type, NULL, NULL);
t->u.field.record = record;
t->u.field.field = field;
return t;
}
Ptree& new_tree() {
if (stack.empty()) {
layer l = {leaf, &root};
stack.push_back(l);
return root;
}
layer& l = stack.back();
switch (l.k) {
case array: {
l.t->push_back(std::make_pair(string(), Ptree()));
layer nl = {leaf, &l.t->back().second};
stack.push_back(nl);
return *stack.back().t;
}
case object:
assert(false); // must start with string, i.e. call new_value
case key: {
l.t->push_back(std::make_pair(key_buffer, Ptree()));
l.k = object;
layer nl = {leaf, &l.t->back().second};
stack.push_back(nl);
return *stack.back().t;
}
case leaf:
stack.pop_back();
return new_tree();
}
assert(false);
}
static Tree_s *object (void)
{
FN;
Tree_s *tree = NULL;
Tree_s *obj;
Tree_s *p;
Token_s t;
t = get_token();
if (t.type != '{') return NULL;
for (;;) {
p = pair();
if (!p) break;
if (tree) {
tree->right = p;
} else {
tree = p;
}
t = get_token();
if (t.type == ',') continue;
}
t = get_token();
aver(t.type == '}');
obj = new_tree();
obj->token.type = T_OBJECT;
obj->left = tree;
return obj;
}
static Tree_s *value (void)
{
FN;
Token_s t;
Tree_s *tree;
t = get_token();
switch (t.type) {
case T_STRING:
case T_NUMBER:
case T_TRUE:
case T_FALSE:
case T_NULL:
tree = new_tree();
tree->token = t;
return tree;
case '[':
return array();
case '{':
unget_token(t);
return object();
default:
PRd(t.type);
return NULL;
}
}
static Tree_s *array (void)
{
FN;
Tree_s *tree = NULL;
Token_s t;
Tree_s *v;
Tree_s *a;
for (;;) {
t = get_token();
if (t.type == ']') break;
unget_token(t);
v = value();
if (!v) break;
if (tree) {
tree->right = v;
} else {
tree = v;
}
t = get_token();
if (t.type == ',') continue;
}
a = new_tree();
a->token.type = T_ARRAY;
a->left = tree;
return a;
}
void c_test_ins_tree_height(void) {
int sizeOfElement = sizeof(struct complexThing);
Tree tree = new_tree(sizeOfElement, navigateComplex, copyComplex, destroyComplex, NULL);
CU_ASSERT_TRUE(get_tree_height(tree) == 0);
Complex *c = malloc(sizeof(struct complexThing));
c->int_regular = 10;
c->int_pointer = malloc(sizeof(int));
*c->int_pointer = 15;
tree_insert(&tree, c, NULL);
CU_ASSERT_TRUE(get_tree_height(tree) == 1);
if (tree != NULL) {
destroy_tree(&tree);
}
if (c != NULL) {
if (c->int_pointer != NULL) {
free(c->int_pointer);
}
free(c);
}
}
void c_test_ins_tree_equal(void) {
int sizeOfElement = sizeof(struct complexThing);
Tree tree = new_tree(sizeOfElement, navigateComplex, copyComplex, destroyComplex, eq_handler);
Complex *c = malloc(sizeof(struct complexThing));
c->int_regular = 10;
c->int_pointer = malloc(sizeof(int));
*c->int_pointer = 15;
tree_insert(&tree, c, NULL);
*c->int_pointer = 25;
tree_insert(&tree, c, NULL);
void *upd = tree_search(&tree, cb, c, NULL);
CU_ASSERT_EQUAL(*c->int_pointer, *(((Complex*)upd)->int_pointer));
if (tree != NULL) {
destroy_tree(&tree);
}
if (c != NULL) {
if (c->int_pointer != NULL) {
free(c->int_pointer);
}
free(c);
}
}
// 分析 qexpr
ast_tree *parser_qexpr(token_result *result)
{
token *t;
ast_tree *tree = new_tree(), *temp;
ast_tag(tree, "qexpr");
//读取引号
t = next_token(result);
ast_tree_add(tree, parser_char(t->sym));
//检查是否为Q_EXPR
t = next_token(result);
if( t->type != TOKEN_SYM || strcmp(t->sym, "(") != 0)
return parser_err("QEXPRSSION miss left brace");
else
ast_tree_add(tree, parser_char(t->sym));
while((t = next_token(result))){
if(t->type == TOKEN_SYM && strcmp(t->sym, ")") == 0){
ast_tree_add(tree, parser_char(t->sym));
return tree;
}
putback_token();
temp = parser_expr(result);
if(strstr(temp->tag, "error"))
return temp;
ast_tree_add(tree, temp);
}
return parser_err("miss the back quote!");
}
void c_test_tree_delete(void) {
int items = 2;
int sizeOfElement = sizeof(struct complexThing);
Tree tree = new_tree(sizeOfElement, navigateComplex, copyComplex, destroyComplex, NULL);
for (int i = 1; i < items; i++) {
Complex *c = malloc(sizeof(struct complexThing));
c->int_regular = i;
c->int_pointer = malloc(sizeof(int));
*c->int_pointer = i+i;
tree_insert(&tree, c, NULL);
if (c != NULL) {
if (c->int_pointer != NULL) {
free(c->int_pointer);
}
free(c);
}
}
for (int d = items - 1; d >= 0; d--) {
tree_delete(&tree, &d, navigateSearchComplex);
}
CU_ASSERT_EQUAL(get_tree_height(tree), 0);
if (tree != NULL) {
destroy_tree(&tree);
}
}
void
add_tree_first_ipv6(const u_char *data)
{
tcpr_tree_t *newnode = NULL, *findnode;
ipv6_hdr_t ip6_hdr;
assert(data);
/*
* first add/find the source IP/client
*/
newnode = new_tree();
/* prevent issues with byte alignment, must memcpy */
memcpy(&ip6_hdr, (data + TCPR_ETH_H), TCPR_IPV6_H);
/* copy over the source ip, and values to gurantee this a client */
newnode->family = AF_INET6;
newnode->u.ip6 = ip6_hdr.ip_src;
newnode->type = DIR_CLIENT;
newnode->client_cnt = 1000;
findnode = RB_FIND(tcpr_data_tree_s, &treeroot, newnode);
/* if we didn't find it, add it to the tree, else free it */
if (findnode == NULL) {
RB_INSERT(tcpr_data_tree_s, &treeroot, newnode);
} else {
safe_free(newnode);
}
/*
* now add/find the destination IP/server
*/
newnode = new_tree();
memcpy(&ip6_hdr, (data + TCPR_ETH_H), TCPR_IPV6_H);
newnode->family = AF_INET6;
newnode->u.ip6 = ip6_hdr.ip_dst;
newnode->type = DIR_SERVER;
newnode->server_cnt = 1000;
findnode = RB_FIND(tcpr_data_tree_s, &treeroot, newnode);
if (findnode == NULL) {
RB_INSERT(tcpr_data_tree_s, &treeroot, newnode);
} else {
safe_free(newnode);
}
}
//语法分析错误
ast_tree *parser_err(char *err)
{
ast_tree *tree = new_tree();
ast_tag(tree, "error");
tree->contents = malloc(strlen(err) + 1);
strcpy(tree->contents, err);
return tree;
}
ast_tree *parser_char(char *s)
{
ast_tree *tree = new_tree();
ast_tag(tree, "char");
tree->contents = malloc(strlen(s) + 1);
strcpy(tree->contents, s);
return tree;
}
