/* 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;
}
