/* If it returns NULL, there was a memory error and the node couldn't be inserted * Otherwise, the tree's root is returned */ struct tree_node *tree_insert(struct tree_node *root, int k) { struct tree_node *prev = NULL; struct tree_node *curr = root; while (curr != NULL) { prev = curr; if (k < curr->key) { curr = curr->left; } else { curr = curr->right; } } if (prev == NULL) return new_tree_node(k, NULL, NULL, NULL); struct tree_node *to_insert = new_tree_node(k, NULL, NULL, prev); if (to_insert == NULL) { return NULL; } if (k < prev->key) { prev->left = to_insert; } else { prev->right = to_insert; } return root; }
// 表达式 tree_node* syn_exp_def(token_list* t_lt) { tree_node* op_l = syn_logic_exp(t_lt); // 左操作数 tree_node* rt_n = op_l; if(op_l == NULL) return NULL; while(type_token(t_lt) == token_type_ass) // 赋值 { rt_n = new_tree_node(get_line(t_lt), bnf_type_ass); rt_n->childs_p[0] = op_l; rt_n->b_v.op_t = token_type_ass; next_token(t_lt); rt_n->childs_p[1] = syn_logic_exp(t_lt); if(rt_n->childs_p[1] == NULL) { a_free(rt_n); return NULL; } op_l=rt_n; // 迭代解析 } return rt_n; }
static void check_and_store (GNode* node, gpointer data) { TreeElement* temp = (TreeElement*) node -> data; STOCKINFO* stock_data = (STOCKINFO*) temp -> userdata; /* 얕은 복사 */ regex_t_and_node* temp_data = (regex_t_and_node*) malloc (sizeof (regex_t_and_node)); *temp_data = *(regex_t_and_node*) data; int status = regexec (&(temp_data -> state), stock_data -> symbol, 0, NULL, 0); if (status == 0 || g_node_depth (node) == 2) { /* 얕은 복사 */ /* TreeElement* copy_data = (TreeElement*) malloc (sizeof (TreeElement)); *copy_data = *temp; */ GNode* copy_node = new_tree_node (stock_data, IS_OPENED | IS_ACTIVATED, temp_data -> array); g_node_insert (temp_data -> array, -1, copy_node); temp_data -> array = copy_node; if (!G_NODE_IS_LEAF (node)) { g_node_children_foreach (node, G_TRAVERSE_ALL, check_and_store, (gpointer) temp_data); } /* Recursive call */ } free (temp_data); return; }
// * / % tree_node* syn_term_exp(token_list* t_lt) { tree_node* op_l = syn_factor_exp(t_lt); tree_node* rt_n = op_l; if(op_l == NULL) return NULL; while(type_token(t_lt)==token_type_mul || type_token(t_lt)==token_type_div || type_token(t_lt)==token_type_mod ) { rt_n = new_tree_node(get_line(t_lt), bnf_type_value); rt_n->childs_p[0]=op_l; rt_n->b_v.op_t = type_token(t_lt); next_token(t_lt); rt_n->childs_p[1] = syn_factor_exp(t_lt); if(rt_n->childs_p[1] == NULL) { free_tree(rt_n); return NULL; } op_l = rt_n; } return rt_n; }
tree_node* syn_relop_exp(token_list* t_lt) { tree_node* op_l = syn_add_exp(t_lt); tree_node* rt_n = op_l; if(op_l == NULL) return NULL; while( type_token(t_lt)==token_type_big || type_token(t_lt)==token_type_bige || type_token(t_lt)==token_type_lit || type_token(t_lt)==token_type_lite || type_token(t_lt)==token_type_equ || type_token(t_lt)==token_type_nequ ) { rt_n = new_tree_node(get_line(t_lt), bnf_type_logic); rt_n->childs_p[0]=op_l; rt_n->b_v.op_t = type_token(t_lt); next_token(t_lt); rt_n->childs_p[1] = syn_add_exp(t_lt); if(rt_n->childs_p[1] == NULL) { free_tree(rt_n); return NULL; } op_l = rt_n; } return rt_n; }
tree_node* syn_al_def(token_list* t_lt) { tree_node* rt_n = new_tree_node(get_line(t_lt), bnf_type_aldef); tree_node** nrt_n = &(rt_n->childs_p[0]); token* n_t = NULL; while(type_token(t_lt)!=token_type_ral) { switch(type_token(t_lt)) { case token_type_lal: syn_watch(t_lt, token_type_lal); *nrt_n = syn_al_def(t_lt); syn_watch(t_lt, token_type_ral); break; default: *nrt_n = syn_exp_def(t_lt); break; } nrt_n = &((*nrt_n)->next); n_t = at_token(t_lt); if(n_t->token_type==token_type_comma) syn_watch(t_lt, token_type_comma); else if(n_t->token_type != token_type_ral) { free_tree(rt_n); return NULL; } } return rt_n; }
// 定义变量 tree_node* syn_var_def(token_list* t_lt) { tree_node* rt_n = new_tree_node(get_line(t_lt), bnf_type_vardef); tree_node** t_rt_n = &(rt_n->childs_p[0]); syn_watch(t_lt, token_type_var); // check key "var" do { tree_node* n_t = syn_vardef_def(t_lt); if(n_t) { *t_rt_n = n_t; t_rt_n = &((*t_rt_n)->next); } else { free_tree(rt_n); return NULL; } if(type_token(t_lt) != token_type_comma) break; next_token(t_lt); }while(1); // if , while syn_watch(t_lt, token_type_end); if(error_flag) { free_tree(rt_n); return NULL; } return rt_n; }
// func call tree_node* syn_func_call(token_list* t_lt) { tree_node* rt_n = new_tree_node(get_line(t_lt), bnf_type_funccall); tree_node** nrt_n = &(rt_n->childs_p[1]); syn_watch(t_lt, token_type_lbra); while(type_token(t_lt) != token_type_rbra) { *nrt_n = syn_exp_def(t_lt); nrt_n = &((*nrt_n)->next); if(type_token(t_lt)==token_type_comma) syn_watch(t_lt, token_type_comma); else break; } syn_watch(t_lt, token_type_rbra); if(error_flag) { free_tree(rt_n); return NULL; } return rt_n; }
/* * Creates a priority queue (pq_node) of nodes in the Huff tree (tree_node) */ struct pq_node * make_pq (struct frequency table[]) { int i; int node_count = 0; // keep track of the number of nodes in the tree for length of huffman tree struct pq_node *head = NULL; // start of pq struct pq_node *prev = NULL; // prev initially NULL //get all character frequencies in file // and add to priority queue for (i = 0; i < 256; i++) { node_count = node_count + table[i].count; tree_node * new_tnode = new_tree_node(NULL, NULL, NULL, table[i].count, (int)table[i].character); struct pq_node * current = new_pq_node(new_tnode->weight, NULL, new_tnode); if (head == NULL) head = current; else prev->next = current; prev = current; } return head; }
// return tree_node* syn_return_def(token_list* t_lt) { tree_node* rt_n = new_tree_node(get_line(t_lt), bnf_type_return); tree_node** nrt_n = &(rt_n->childs_p[0]); syn_watch(t_lt, token_type_return); if(type_token(t_lt)==token_type_end) goto RETURN_NED; do { *nrt_n = syn_exp_def(t_lt); nrt_n = &((*nrt_n)->next); if(type_token(t_lt) != token_type_comma) break; else syn_watch(t_lt, token_type_comma); } while (1); RETURN_NED: syn_watch(t_lt, token_type_end); if(error_flag) { free_tree(rt_n); return NULL; } return rt_n; }
// 逻辑表达式 tree_node* syn_logic_exp(token_list* t_lt) { tree_node* op_l = syn_relop_exp(t_lt); tree_node* rt_n = op_l; if(op_l == NULL) return NULL; while( (type_token(t_lt)==token_type_or) || (type_token(t_lt)==token_type_and) ) // watch || && { rt_n = new_tree_node(get_line(t_lt), bnf_type_logic); rt_n->childs_p[0] = op_l; rt_n->b_v.op_t = type_token(t_lt); next_token(t_lt); rt_n->childs_p[1] = syn_relop_exp(t_lt); if(rt_n->childs_p[1]==NULL) { free_tree(rt_n); return NULL; } op_l = rt_n; } return rt_n; }
// arg list def tree_node* syn_arg_def(token_list* t_lt) { tree_node* rt_n = new_tree_node(get_line(t_lt), bnf_type_argdef); tree_node** nrt_n = &(rt_n->childs_p[0]); do { token* n_t = NULL; if(type_token(t_lt) == token_type_var) { syn_watch(t_lt, token_type_var); } else { if(type_token(t_lt) == token_type_rbra) return rt_n; a_free(rt_n); rt_n = NULL; break; } n_t = at_token(t_lt); if(type_token(t_lt) == token_type_ide) { (rt_n->b_v.number)++; *nrt_n = new_tree_node(get_line(t_lt), bnf_type_var); (*nrt_n)->b_v.name = alex_string(n_t->token_name.s_ptr); nrt_n = &((*nrt_n)->next); } syn_watch(t_lt, token_type_ide); if(type_token(t_lt) != token_type_comma) break; else syn_watch(t_lt, token_type_comma); } while (1); if(error_flag) { free_tree(rt_n); return NULL; } return rt_n; }
/* 中序遍历 */ int main(int argc, char *argv[]) { /* Test new tree node */ BinaryTreeNode *treeroot = new_tree_node(5); assert(treeroot); assert(treeroot->key == 5); add_tree_node(treeroot, 15); return 0; }
// 变量语法树 tree_node* syn_getvar_exp(token_list* t_lt) { tree_node* rt_n = NULL; token* n_t = at_token(t_lt); rt_n = new_tree_node(get_line(t_lt), bnf_type_var); rt_n->b_v.name = alex_string(n_t->token_name.s_ptr); next_token(t_lt); return rt_n; }
void compute_all_status(Position *pos, int owner_map[BOARDSIZE], int score_count[], Status block_status[], Status point_status[]) // Compute status of of points and blocks (based on owner_map) // - the points : OWN_BY_BLACK, OWN_BY_WHITE or UNKNOWN // - the blocks : DEAD, ALIVE or UNKNOWN { Color c; int b; Status new_g_st, p_st; TreeNode *tree=new_tree_node(); // Launch a full depth MCTS search in order to compute owner_map double FASTPLAY20_THRES_sav = FASTPLAY20_THRES; double FASTPLAY5_THRES_sav = FASTPLAY5_THRES; memset(owner_map, 0, BOARDSIZE*sizeof(int)); nplayouts_real = 0; tree_search(pos, tree, 2*N_SIMS, owner_map, score_count, 0); FASTPLAY20_THRES = FASTPLAY20_THRES_sav; FASTPLAY5_THRES = FASTPLAY5_THRES_sav; sprintf(buf, "nsims: %d", nplayouts_real); log_fmt_s('I',buf,NULL); // Reset status of points and blocks FORALL_POINTS(pos, pt) point_status[pt] = UNKNOWN; for (b=1 ; b<MAX_BLOCKS ; b++) block_status[b] = UNKNOWN; // Try to evaluate block status FORALL_POINTS(pos, pt) { b = point_block(pos, pt); if (b != 0) { c = point_color(pos, pt); point_status[pt] = p_st = mcts_point_status(pt, owner_map); if (p_st == UNKNOWN) block_status[b] = UNKNOWN; else { new_g_st = UNKNOWN; if ((p_st == OWN_BY_WHITE && c==BLACK) || (p_st == OWN_BY_BLACK && c==WHITE)) new_g_st = DEAD; else if ((p_st == OWN_BY_BLACK && c==BLACK) || (p_st == OWN_BY_WHITE && c == WHITE)) new_g_st = ALIVE; if(block_status[b] == UNKNOWN) block_status[b] = new_g_st; else if (block_status[b] != new_g_st) block_status[b] = UNKNOWN; } } else point_status[pt] = mcts_point_status(pt, owner_map); }
// arraylist al[EXP] tree_node* syn_at_al(token_list* t_lt) { tree_node* rt_n = new_tree_node(get_line(t_lt), bnf_type_al); tree_node** nrt_n = &(rt_n->childs_p[1]); token* n_t = at_token(t_lt); syn_watch(t_lt, token_type_lal); *nrt_n = syn_exp_def(t_lt); nrt_n = &((*nrt_n)->next); syn_watch(t_lt, token_type_ral); return rt_n; }
kld_tree_node_t * tree_heap_ordered_insert_recursive(kld_tree_t * t, kld_tree_node_t * current, unsigned char * key, void * data) { if(current == NULL) { // Insert into root if root is null current = (kld_tree_node_t *) new_tree_node(key, data); } else if(byte_cmp(current->key, key) > 0) { // If the current key is less than our desired insertion point // make a new node, and kld_tree_node_t * n = (kld_tree_node_t *) new_tree_node(key, data); n->children = (kld_vector_t *) new_vector(); vector_append(n->children, current); current->parent = n; current = n; } else { // Otherwise if the current key is greater than zero and we // need to find an insertion point in the children // If children are null, we have to make them. if(current->children == NULL) { current->children = (kld_vector_t *) new_vector(); } if(current->children->size < t->num_children) { kld_tree_node_t * n = (kld_tree_node_t *) new_tree_node(key, data); vector_append(current->children, n); } else { // Iterate through children left to right and try to find insertion point. int i; for(i = 0; i < t->num_children; i++) { kld_tree_node_t * child = (kld_tree_node_t *) vector_get(current->children, i); tree_heap_ordered_insert_recursive(t, child , key, data); } } } return current; }
// continue tree_node* syn_continue_def(token_list* t_lt) { tree_node* rt_n = new_tree_node(get_line(t_lt), bnf_type_continue); syn_watch(t_lt, token_type_continue); syn_watch(t_lt, token_type_end); if(error_flag) { free_tree(rt_n); return NULL; } return rt_n; }
BinaryTreeNode * add_tree_node(BinaryTreeNode *tree, int value) { if(value < tree->key){ if (!tree->left) { BinaryTreeNode *node = new_tree_node(value); tree->left = node; return node; } else { return add_tree_node(tree->left, value); } } else if(value > tree->key){ if (!tree->right) { BinaryTreeNode *node = new_tree_node(value); tree->right = node; return node; } else return add_tree_node(tree->right, value); } return 0; }
// while tree_node* syn_while_def(token_list* t_lt) { tree_node* rt_n = new_tree_node(get_line(t_lt), bnf_type_while); syn_watch(t_lt, token_type_while); // watch while syn_watch(t_lt, token_type_lbra); // watch ( rt_n->childs_p[0] = syn_exp_def(t_lt); // while 条件 syn_watch(t_lt, token_type_rbra); // watch ) rt_n->childs_p[1] = syn_seg_def(t_lt); // while seg if(error_flag) { free_tree(rt_n); return NULL; } return rt_n; }
tree_node* syn_using(token_list* t_lt) { tree_node* rt_n = NULL; if(syn_watch(t_lt, token_type_using)) { if(type_token(t_lt)==token_type_string) { token* tk = at_token(t_lt); rt_n = new_tree_node(get_line(t_lt), bnf_type_using); rt_n->b_v.str = alex_string(tk->token_value.str.s_ptr); syn_watch(t_lt, token_type_string); } } return rt_n; }
GNode* search_by_regex (GNode* node, char* pattern, GNode* empty_GNode) { TreeElement* root_data; root_data = (TreeElement*) node -> data; STOCKINFO* userdata = (STOCKINFO*) root_data -> userdata; empty_GNode = new_tree_node (userdata, IS_OPENED | IS_ACTIVATED, NULL); GNode* fulled_GNode = empty_GNode; regex_t_and_node data; regex_t* state = &(data.state); int res = regcomp (state, pattern, REG_EXTENDED); char str [100]; regerror (res, state, str, sizeof (str)); data.array = fulled_GNode; g_node_children_foreach (node, G_TRAVERSE_ALL, check_and_store, (gpointer) &data); regfree (&data.state); return fulled_GNode; }
void insert_itemset_into_tree(TreeNode **root, ItemSet *item_set, int level, int k) { if (*root == NULL) { *root = new_tree_node(); (*root)->level = level; append_to_list(&((*root)->item_sets), item_set); } else if (get_size_of_list((*root)->item_sets) == MAX_NODE_SIZE && level < k) { ItemSetNode *tmp = NULL, *l; append_to_list(&tmp, (*root)->item_sets->data); append_to_list(&tmp, (*root)->item_sets->next->data); append_to_list(&tmp, item_set); (*root)->item_sets = NULL; (*root)->flag = 0; for (l = tmp; l != NULL; l = l->next) { if ((*(l->data->item_set + level)) % 3 == 0) insert_itemset_into_tree(&((*root)->left), l->data, 1 + level, k); else if ((*(l->data->item_set + level)) % 3 == 1) insert_itemset_into_tree(&((*root)->middle), l->data, 1 + level, k); else if ((*(l->data->item_set + level)) % 3 == 2) insert_itemset_into_tree(&((*root)->right), l->data, 1 + level, k); } } else if ((*root)->flag) { append_to_list(&((*root)->item_sets), item_set); } else { if ((*(item_set->item_set + level)) % 3 == 0) insert_itemset_into_tree(&((*root)->left), item_set, 1 + level, k); else if ((*(item_set->item_set + level)) % 3 == 1) insert_itemset_into_tree(&((*root)->middle), item_set, 1 + level, k); else if ((*(item_set->item_set + level)) % 3 == 2) insert_itemset_into_tree(&((*root)->right), item_set, 1 + level, k); } }
int sess_add(session *sess) { rb_node *node; if (sess == NULL) { printf("null sess \n"); return -1; } node = new_tree_node(); if (node == NULL) { printf("new node failed\n"); return -1; } node->key = sess->fd; node->data = (void*)sess; tree_insert(&sess_head, node); display_tree(sess_head); return 0; }
// function def tree_node* syn_func_def(token_list* t_lt) { tree_node* rt_n = new_tree_node(get_line(t_lt), bnf_type_func); syn_watch(t_lt, token_type_func); // key function if(type_token(t_lt) == token_type_ide) // ide { token* n_t = at_token(t_lt); if(look_table(global_table, n_t->token_name.s_ptr)) { print("parsing[error line %d] the func redef!\n", n_t->token_line); free_tree(rt_n); return NULL; } else { rt_n->b_v.name = alex_string(n_t->token_name.s_ptr); } } else { print("parsing[error line %d] can not find function name!\n", get_line(t_lt)); free_tree(rt_n); return NULL; } syn_watch(t_lt, token_type_ide); // watch func name syn_watch(t_lt, token_type_lbra); // watch ( rt_n->childs_p[0] = syn_arg_def(t_lt); // get arg list syn_watch(t_lt, token_type_rbra); // watch ) rt_n->childs_p[1] = syn_seg_def(t_lt); // rt_n->childs_p[2] return vale if(error_flag) { free_tree(rt_n); return NULL; } return rt_n; }
/* * Builds a Huffman tree for each character in terms of bit codes */ struct tree_node build_tree (struct pq_node * pq) { struct pq_node *head = pq; struct tree_node * root = NULL; // start building tree while (head->next != NULL) { // grab 2 smallest nodes struct tree_node *lt = dequeue(head); head = head->next; struct tree_node *rt = dequeue(head); head = head->next; // create a new node with smallest nodes as children struct tree_node *pt = new_tree_node (NULL, lt, rt, lt->weight + rt->weight, -1); if (head == NULL) { root = pt; break; } // associate children with parent lt->parent = pt; rt->parent = pt; // enqueue new node to priority queue struct pq_node *new_node = new_pq_node(pt->weight, NULL, pt); head = enqueue(head, new_node); // SEG FAULTS HERE } if (root == NULL) { // when the loop ends, set remaining node as tree at root root = dequeue(head); } return (*root); }
// if tree_node* syn_if_def(token_list* t_lt) { tree_node* rt_n = new_tree_node(get_line(t_lt), bnf_type_if); syn_watch(t_lt, token_type_if); // watch if syn_watch(t_lt, token_type_lbra); // watch ( rt_n->childs_p[0] = syn_exp_def(t_lt); syn_watch(t_lt, token_type_rbra); // watch ) rt_n->childs_p[1] = syn_seg_def(t_lt); // if seg if(type_token(t_lt) == token_type_else) // find else { syn_watch(t_lt, token_type_else); rt_n->childs_p[2] = syn_seg_def(t_lt); } if(error_flag) { free_tree(rt_n); return NULL; } return rt_n; }
/* * 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; }
// ( const value var value tree_node* syn_factor_exp(token_list* t_lt) { tree_node* rt_n = NULL; token* n_t = NULL; switch(type_token(t_lt)) { case token_type_lbra: // ( { syn_watch(t_lt, token_type_lbra); // jump ( rt_n = syn_exp_def(t_lt); syn_watch(t_lt, token_type_rbra); // jump ) } break; case token_type_lal: { syn_watch(t_lt, token_type_lal); // jump [ rt_n = syn_al_def(t_lt); syn_watch(t_lt, token_type_ral); // jump ] } break; case token_type_ide: // var ide { switch(look_token(t_lt)) // if token=='(' func call { case token_type_lbra: // func call case token_type_lal: // arraylist { rt_n = syn_funcal_exp(t_lt); } break; default: // var { rt_n = syn_getvar_exp(t_lt); } break; } } break; case token_type_num: // const number { token* n_t = at_token(t_lt); rt_n = new_tree_node(get_line(t_lt), bnf_type_const); rt_n->b_v.number = n_t->token_value.number; next_token(t_lt); } break; case token_type_string: // const string { token* n_t = at_token(t_lt); rt_n = new_tree_node(get_line(t_lt), bnf_type_string); rt_n->b_v.str = alex_string(n_t->token_value.str.s_ptr); next_token(t_lt); } break; case token_type_sadd: // ++number case token_type_ssub: // --number case token_type_sub: // - { rt_n = new_tree_node(get_line(t_lt), bnf_type_value); rt_n->b_v.op_t = type_token(t_lt); next_token(t_lt); rt_n->childs_p[1] = syn_factor_exp(t_lt); } break; default: { token* n_t = at_token(t_lt); next_token(t_lt); print("factor[error line %d]: token \"%s\" is not allow!\n", n_t->token_line, n_t->token_name.s_ptr); } return NULL; } if(type_token(t_lt) == token_type_sadd || type_token(t_lt) == token_type_ssub) // if number-- number++ { tree_node* n_rt_n = new_tree_node(get_line(t_lt), bnf_type_value); n_rt_n->b_v.op_t = type_token(t_lt); n_rt_n->childs_p[0] = rt_n; rt_n = n_rt_n; next_token(t_lt); } if(error_flag) { free_tree(rt_n); return NULL; } return rt_n; }
// segment def tree_node* syn_seg_def(token_list* t_lt) { tree_node* rt_n = new_tree_node(get_line(t_lt), bnf_type_seg); tree_node** nrt_n = &rt_n->childs_p[0]; byte seg_flag = 0; if(type_token(t_lt) == token_type_lseg) { seg_flag = 1; syn_watch(t_lt, token_type_lseg); } do{ switch(type_token(t_lt)) { case token_type_lseg: // if { { syn_watch(t_lt, token_type_lseg); // watch { *nrt_n = syn_seg_def(t_lt); nrt_n = (*nrt_n)?(&((*nrt_n)->next)):(NULL); syn_watch(t_lt, token_type_rseg); // watch } } break; case token_type_var: { *nrt_n = syn_var_def(t_lt); nrt_n = (*nrt_n)?(&((*nrt_n)->next)):(NULL); } break; case token_type_if: { *nrt_n = syn_if_def(t_lt); nrt_n = (*nrt_n)?(&((*nrt_n)->next)):(NULL); } break; case token_type_while: { *nrt_n = syn_while_def(t_lt); nrt_n = (*nrt_n)?(&((*nrt_n)->next)):(NULL); } break; case token_type_continue: { *nrt_n = syn_continue_def(t_lt); nrt_n = (*nrt_n)?(&((*nrt_n)->next)):(NULL); } break; case token_type_break: { *nrt_n = syn_break_def(t_lt); nrt_n = (*nrt_n)?(&((*nrt_n)->next)):(NULL); } break; case token_type_return: { *nrt_n = syn_return_def(t_lt); nrt_n = (*nrt_n)?(&((*nrt_n)->next)):(NULL); } break; case token_type_rseg: break; default: { *nrt_n = syn_exp_stmt(t_lt); nrt_n = (*nrt_n)?(&((*nrt_n)->next)):(NULL); } break; } }while( nrt_n && seg_flag && (type_token(t_lt) != token_type_rseg) ); // if not find { is loop if(seg_flag) syn_watch(t_lt, token_type_rseg); if(error_flag) { free_tree(rt_n); return NULL; } return rt_n; }