minic 动作句型处理

#include "lex_define.h"
enum keywords_type//代表一些关键字
{
    loop_for=3,//代表for关键字
    loop_while,//代表while关键字
    branch_if,//代表if关键字
    branch_else,//代表else关键字
    break,
};
//这里sizeof被分到运算符里了，而main被分到函数名里面去了，基本数据类型和符号前缀被分到数据类型名之中了
enum delimit_type
{    
    open_brace,//开大括号
    close_brace,//闭大括号
    semicolon//分号
};
//现在开始描述运算符的优先级
//0级: [ ] ( ) -> . 结合性 从左到右
//1级:! ~  $ @ - (cast)  sizeof 这些都是单目运算符，注意cast的意思是强制类型转换
//2级: * / % 这些运算符都是从左到右 
//3级: + - 这些也是从左到右 
//4级: >> << 按道理木有结合性
//5级：> < >= <= 从左到右
//6级: == != 从左到右
//7级: & 从左到右
//8级：^ 从左到右
//9级：| 从左到右
//10级： && 从左到右
//11级： ||从左到右

struct operator_token//这个是操作符栈中的token,注意我们在处理数组运算符的时候采取了特殊的方法
{
    enum basic_operator_type current_op_type;//这个域可以提供所有的信息
    int priority;//运算符优先级
    int sub_number;//代表有几个操作数
    //我们可以根据前面的那个枚举类型得到所有的信息，但是我们另外提出这个优先级域，是为了简化判断的操作
}
//现在我们来定义一个抽象语法树的结构
//首先考虑的是语法树节点的种类
//这个域比较复杂，主要是因为各种不同的语法节点有大小不一的子节点个数
//首先对于没有子节点的情况，这里代表的是那些关键字，因为关键字不需要产生式
//然后还有所有的名字和常量，
//还有单字符和字符串，
//然后讨论的是只有一个子节点的情况，这里对应的是单目运算符
//然后讨论的是两个子节点的情况，这里代表了所有的运算符和赋值符和函数调用节点
//这里的函数调用节点包括两个子节点，一个是函数名，另外一个是参数列表
//而参数列表也是拥有两个域的节点，这两个节点中最多有一个是参数列表属性，其他的都是名字
//对于单语句块节点，这个也是拥有两个子节点的节点，构造方式与参数列表节点一样
//有三个子节点的是while语句，分别是while节点，判断节点，和代码块节点
//有五个子节点的是for语句，分别是for节点，初始化节点，判断节点，修改节点和代码块节点
//这里还有if else节点也是五个节点 if节点 判断节点 代码块节点，else节点，代码块节点
//但是我们采取的是双栈，所以这些节点会被分成两种。
//一种是单语句，即全部都是算术操作的那些节点，即expression
//另外一种是多语句，即所有的单语句即控制结构
//注意我们这里在调用函数的时候，参数里面不允许有变量值的修改操作，因此只能是变量与数组运算，结构运算
//指针运算这三种的结合，这样处理函数的时候就简单多了
//因此，我们这里有两棵语法分析树，第一个是句型树，第二个是表达式树，函数调用放在表达式树之中
//对于表达式树，我们只需要考虑操作符的种类，这里我们把赋值符放在操作符里面去考虑，这样
//还要提到一点就是句型树中的判断节点属于表达式树,break语句也属于表达式树

//这里我们来处理类型声明
typedef struct _phrase_tree_node//表达式语法树的节点
{
    union
    {
        int phrase_type；
    //0代表break，1代表常数，2代表名字，3代表函数调用，4代表单个参数，5代表参数列表
    //6代表赋值运算，7代表单字符，8代表字符串，9及以后的代表操作符
        enum basic_operator_type current_op_type;//因为我们定义操作符编号是从5开始的，所以不会与前面的那个重合
    };
    union
    {
        char* constant_str;//代表常量
        char* var_name;//代表名字
        struct
        {
            struct _phrase_tree_node* left_son;
            struct _phrase_tree_node* right_son;
        };//代表有两个分量的类型，包括函数调用，函数参数，双目运算符，赋值操作
        struct _phrase_tree_node* original_node;//代表除了强制类型转换之外的单目运算符
        struct
        {
            struct _phrase_tree_node* token_for_cast;//代表单目运算符
            struct _type_description* cast_type_description;//这个是为了强制类型转换用的....不爽
            int pointer_layer;//代表指针的层数
        };
    };
}phrase_tree_node;
//这里对于操作数栈，我们不需要再去定义其他的数据类型，可以直接在栈中使用上面定义的表达式语法树节点
//我们还需要去管理一个赋值id栈和id操作符栈，这样来处理是因为我们把赋值符从操作符中独立出来了，
//所以不得不这样做，规范化的代价啊。。。
//在处理赋值语句的时候id栈中存放的是id，在处理完expression后，最后处理赋值语句，生成赋值语法节点
//而对于函数调用，也是需要处理id的，这个时候也需要使用id栈。为了弄清楚我们使用的是赋值id还是参数id
//我们利用另外的一个指针来处理赋值id，因为赋值id之只有一个，而参数id可以有很多个
//我们在遇到=号的时候，把id栈中的语法节点的指针取出放在copytopointer这个指针中，然后清空id栈。
//所以在expression表达式处理完的时候，检查这个指针是不是空，如果不是，则需要生成赋值节点
//对于函数参数的处理，每次遇到函数名，把函数名压入操作数栈，把之后的括号压入操作符栈，
//然后对于之后的处理，都在id栈与id操作符栈中进行，
//对于遇到分号的时候，如果id栈不为空，则把id栈中所有的id节点合并成一个参数列表节点，当然当前只有一个就
//算了，
//因此我们需要四个栈，还有为了支持强制类型转化操作和sizeof操作，我们还需要一个类型参数变量来供使用
//为了支持赋值，我们还需要赋值的语法树节点，为了支持函数参数我们需要一个参数语法树节点
struct operator_token* phrase_operator_stack[40];//优先级也就只有12个，40个足够了

struct _phrase_tree_node* phrase_token_stack[40];//给40个是看他面子了

//id_0: name |(id)| id_0[constant] | id_0.name | id_0->name |id_0[name]
//id_1: id_0 | @id_0 
//id : id_1
struct _phrase_tree_node* id_token_stack[10];//打发叫花子
enum basic_operator_type id_operator_stack[10];//id里面的运算符就更少了，因此10个也是足够了
int id_token_stack_pointer;
int id_operator_stack_pointer;
int phrase_token_stack_pointer;
int phrase_operator_stack_pointer;
struct _type_description* temp_cast_one;//这个是为强制类型转换而使用的
int cast_pointer_layer;//代表强制类型转换的指针层数
int predecent;
//这个是用来说明前面遇到的是操作符还是操作数，这个变量主要是为了处理负号和指针和取地址
void tackle_id_op(char* input_op)//这个函数是用来处理id的操作符栈
{
    struct _phrase_tree_node* temp_node_one;
    enum basic_operator_type current_top_op;
    switch(*input_op)
    {
    case '(':
        id_operator_stack_pointer++;
        id_operator_stack[id_operator_stack_pointer]=parenthesis;
        break;
    case '[':
        id_operator_stack_pointer++;
        id_operator_stack[id_operator_stack_pointer]=array_op;
        break;
    case '.':
        if(id_operator_stack_pointer==0)//如果目前为空栈，则入栈
        {
            id_operator_stack_pointer++;
            id_operator_stack[id_operator_stack_pointer]=str_sub;
        }
        else
        {
            current_top_op=id_operator_stack[id_operator_stack_pointer];
            switch(current_top_op)
            {
            case parenthesis:
            case array_op:
            case get_mem:
                id_operator_stack_pointer++;
                id_operator_stack[id_operator_stack_pointer]=str_sub;
                break;
            case str_sub:
            case p_str_sub:
                temp_node_one=malloc(sizeof(struct _phrase_tree_node));
                temp_node_one->current_op_type=current_top_op;
                if(id_token_stack_pointer>=2)
                {
                    temp_node_one->left_son=id_token_stack[id_token_stack_pointer-1];
                    temp_node_one->right=id_token_stack[id_token_stack_pointer];
                    id_token_stack_pointer--;
                    id_token_stack[id_token_stack_pointer]=temp_node_one;
                    id_operator_stack_pointer++;
                    id_operator_stack[id_operator_stack_pointer]=str_sub;
                }
                else
                {
                    printf("insufficient id token during pop operator
");
                    exit();
                }
                break;
            default:
                printf("unknown op in id_op_stack
");
                exit();
                break;
            }
        }
        break;
    case '>':
        if(id_operator_stack_pointer==0)//如果目前为空栈，则入栈
        {
            id_operator_stack_pointer++;
            id_operator_stack[id_operator_stack_pointer]=p_str_sub;
        }
        else
        {
            current_top_op=id_operator_stack[id_operator_stack_pointer];
            switch(current_top_op)
            {
            case parenthesis:
            case array_op:
            case get_mem:
                id_operator_stack_pointer++;
                id_operator_stack[id_operator_stack_pointer]=p_str_sub;
                break;
            case str_sub:
            case p_str_sub:
                temp_node_one=malloc(sizeof(struct _phrase_tree_node));
                temp_node_one->current_op_type=current_top_op;
                if(id_token_stack_pointer>=2)
                {
                    temp_node_one->left_son=id_token_stack[id_token_stack_pointer-1];
                    temp_node_one->right=id_token_stack[id_token_stack_pointer];
                    id_token_stack_pointer--;
                    id_token_stack[id_token_stack_pointer]=temp_node_one;
                    id_operator_stack[id_operator_stack_pointer]=p_str_sub;
                }
                else
                {
                    printf("insufficient id token during pop operator
");
                    exit();
                }
                break;
            default:
                printf("unknown op in id_op_stack
");
                exit();
                break;
            }
        }
        break;
    case '@':
        id_operator_stack_pointer++;
        id_operator_stack[id_operator_stack_pointer]=get_mem;
        break;
    case ')':
        while(id_operator_stack[id_operator_stack_pointer]!=parenthesis)
            //这里我们之所以加上这个大于0，是因为在函数的参数列表的形式下，会有一个多余的闭括号
        {
            current_top_op=id_operator_stack[id_operator_stack_pointer];
            switch(current_top_op)
            {
            case get_mem:
                temp_node_one=malloc(sizeof(struct _phrase_tree_node));
                temp_node_one->current_op_type=get_mem;
                if(id_token_stack_pointer>=1)
                {
                    temp_node_one->original_node=id_token_stack[id_token_stack_pointer];
                    id_token_stack[id_token_stack_pointer]=temp_node_one;
                }
                else
                {
                    printf("null token stack while pop operator
");
                    exit();
                }
                break;
            case p_str_sub:
            case str_sub:
                temp_node_one=malloc(sizeof(struct _phrase_tree_node));
                temp_node_one->current_op_type=current_top_op;
                if(id_token_stack_pointer>=2)
                {
                    temp_node_one->left_son=id_token_stack[id_token_stack_pointer-1];
                    temp_node_one->right=id_token_stack[id_token_stack_pointer];
                    id_token_stack_pointer--;
                    id_token_stack[id_token_stack_pointer]=temp_node_one;
                }
                else
                {
                    printf("insufficient id token during pop operator
");
                    exit();
                }
                break;
            case array_op:
                printf("unmatched array_op during parenthesis
");
                exit();
                break;
            default:
                printf("unknowd op in id_op_stack
");
                break;
            }
            id_operator_stack_pointer--;
        }
        if(id_token_stack_pointer<1)
        {
            printf("null id token in stack during pop
");
            exit();
        }
        else
        {
            id_operator_stack_pointer--;
        }
        break;
    case ']':
        while(id_operator_stack[id_operator_stack_pointer]!=array_op)
        {
            current_top_op=id_operator_stack[id_operator_stack_pointer];
            switch(current_top_op)
            {
            case get_mem:
                temp_node_one=malloc(sizeof(struct _phrase_tree_node));
                temp_node_one->current_op_type=get_mem;
                if(id_token_stack_pointer>=1)
                {
                    temp_node_one->original_node=id_token_stack[id_token_stack_pointer];
                    id_token_stack[id_token_stack_pointer]=temp_node_one;
                }
                else
                {
                    printf("null token stack while pop operator
");
                    exit();
                }
                break;
            case p_str_sub:
            case str_sub:
                temp_node_one=malloc(sizeof(struct _phrase_tree_node));
                temp_node_one->current_op_type=current_top_op;
                if(id_token_stack_pointer>=2)
                {
                    temp_node_one->left_son=id_token_stack[id_token_stack_pointer-1];
                    temp_node_one->right=id_token_stack[id_token_stack_pointer];
                    id_token_stack_pointer--;
                    id_token_stack[id_token_stack_pointer]=temp_node_one;
                }
                else
                {
                    printf("insufficient id token during pop operator
");
                    exit();
                }
                break;
            case parenthesis:
                printf("unmatched parenthesis during array_op
");
                exit();
                break;
            default:
                printf("unknowd op in id_op_stack
");
                exit();
                break;
            }
            id_operator_stack_pointer--;
        }
        if(id_token_stack_pointer<2)
        {
            printf("insufficient id token in stack during pop array_op
");
            exit();
        }
        else
        {
            id_operator_stack_pointer--;
            temp_node_one=malloc(sizeof(struct _phrase_tree_node));
            temp_node_one->current_op_type=array_op;
            temp_node_one->left_son=id_token_stack[id_token_stack_pointer-1];
            temp_node_one->right=id_token_stack[id_token_stack_pointer];
            id_token_stack_pointer--;
            id_token_stack[id_token_stack_pointer]=temp_node_one;
        }
        break;
    default:
        printf("unknown op_type when tackcle_id_op
");
        break;
    }
}
phrase_tree_node* get_id(void)//这个函数是用来得到id的
{

    struct _phrase_tree_node* temp_node_one;
    struct first_token_chain* temp_first_one;
    struct first_token_chain* temp_first_two;
    struct first_lex_token* current_lex_token;
    struct first_lex_token* temp_lex_token;
    struct operator_token* temp_op;
    id_operator_stack_pointer=id_token_stack_pointer=0;
    temp_first_one=first_chain_head;
    current_lex_token=temp_first_one->current_first_token;
    while(1)
    {
        if(current_lex_token->current_lex_type==an_operator)//对于是操作符的时候
        {
            if(*(current_lex_token->token_name)!='=')//如果不是等于号
            {
                switch(*(current_lex_token->token_name))
                {
                case '-'://如果第一个字符是-.这个情况我们需要特殊考虑
                    temp_first_two=temp_first_one->next;
                    temp_lex_token=temp_first_two->current_first_token;
                    if(temp_lex_token->current_lex_type!=an_operator)//如果后面搭配的不是操作符,报错
                    {
                        printf("invalid - during id recognise
");
                        exit();
                    }
                    else
                    {
                        if(*(temp_lex_token->token_name)!='>')//如果后面搭配的不是>,则报错
                        {
                            printf("invalid match operator %s after -
",temp_lex_token->token_name);
                            exit();
                        }
                        else//如果刚好组成了搭配
                        {
                            free(current_lex_token->token_name);
                            free(current_lex_token);
                            free(temp_first_one);
                            first_chain_head=temp_first_two->next;
                            tackle_id_op(temp_lex_token->token_name);//这个是处理id操作符栈的主体函数
                            free(temp_lex_token->token_name);
                            free(temp_lex_token);
                            free(temp_first_two);
                            temp_first_one=first_chain_head;
                            current_lex_token=temp_first_one->current_first_token;
                        }
                    }
                    break;
                case '(':
                case ')':
                case '[':
                case ']':
                case '@':
                case '.':
                    tackle_id_op(*(current_lex_token->token_name));
                    first_chain_head=temp_first_one->next;
                    free(current_lex_token->token_name);
                    free(current_lex_token);
                    free(temp_first_one);
                    temp_first_one=first_chain_head;
                    current_lex_token=temp_first_one->current_first_token;
                    break;
                default:
                    printf("invalid operator %s during id recognisation
",current_lex_token->token_name);
                    break;
                }
            }    
            else
                //如果是等于号
                //则我们需要将操作符栈里面的东西全都弹出
            {
                while(id_operator_stack_pointer>0)
                {
                    switch(id_operator_stack[id_operator_stack_pointer])
                    {
                    case p_str_sub:
                    case str_sub:
                        temp_node_one=malloc(sizeof(struct _phrase_tree_node));
                        temp_node_one->current_op_type=id_operator_stack[id_operator_stack_pointer];
                        if(id_token_stack_pointer>=2)
                        {
                            temp_node_one->left_son=id_token_stack[id_token_stack_pointer-1];
                            temp_node_one->right=id_token_stack[id_token_stack_pointer];
                            id_token_stack_pointer--;
                            id_token_stack[id_token_stack_pointer]=temp_node_one;
                            id_operator_stack_pointer--;
                        }
                        else
                        {
                            printf("insufficient id token during pop operator
");
                            exit();
                        }
                        break;
                    case get_mem:
                        temp_node_one=malloc(sizeof(struct _phrase_tree_node));
                        temp_node_one->current_op_type=id_operator_stack[id_operator_stack_pointer];
                        temp_node_one->original_node=id_token_stack[id_token_stack_pointer];
                        id_token_stack[id_token_stack_pointer]=temp_node_one;
                        id_operator_stack_pointer--;
                        break;
                    case array_op:
                        printf("unmatched array_op in id_token
");
                        exit();
                        break;
                    case parenthesis:
                        printf("unmatched parenthesis in id_token
");
                        exit();
                        break;
                    default:
                        printf("unexpected op in id token
");
                        exit();
                        break;
                    }


                }//至此，操作符栈处理完毕
                //然后修正好词法链的头节点，使得这个=号被抛弃
                first_chain_head=temp_first_one->next;
                free(current_lex_token->token_name);
                free(current_lex_token);
                free(temp_first_one);
                id_token_stack_pointer--;
                return id_token_stack[1];
            }
        }
        else
            //对于是常量或者名字的情况,我们直接入栈，
            //对于是分号的情况，我们要采取与等号相同的操作
        {
            if(current_lex_token->current_lex_type!=delimit)
            {
                switch(current_lex_token->current_lex_type)
            {
            case constant:
                temp_node_one=malloc(sizeof(struct _phrase_tree_node));
                temp_node_one->constant_str=current_lex_token->token_name;
                temp_node_one->phrase_type=1;
                id_token_stack_pointer++;
                id_token_stack[id_token_stack_pointer]=temp_node_one;
                first_chain_head=fisrt_chain_head->next;
                free(current_lex_token);
                free(temp_first_one);
                temp_first_one=first_chain_head;
                current_lex_token=temp_first_one->current_first_token;
                break;
            case name:
                temp_node_one=malloc(sizeof(struct _phrase_tree_node));
                temp_node_one->var_name=current_lex_token->token_name;
                temp_node_one->phrase_type=2;
                id_token_stack_pointer++;
                id_token_stack[id_token_stack_pointer]=temp_node_one;
                first_chain_head=fisrt_chain_head->next;
                free(current_lex_token);
                free(temp_first_one);
                temp_first_one=first_chain_head;
                current_lex_token=temp_first_one->current_first_token;
                break;
            default:
                printf("invalid token %s in id recognization
",current_lex_token->token_name);
                exit();
                break;
            }
            }
            else//如果是分号
            {
                while(id_operator_stack_pointer>0)//清空操作符栈
                {
                    switch(id_operator_stack[id_operator_stack_pointer])
                    {
                    case p_str_sub:
                    case str_sub:
                        temp_node_one=malloc(sizeof(struct _phrase_tree_node));
                        temp_node_one->current_op_type=id_operator_stack[id_operator_stack_pointer];
                        if(id_token_stack_pointer>=2)
                        {
                            temp_node_one->left_son=id_token_stack[id_token_stack_pointer-1];
                            temp_node_one->right=id_token_stack[id_token_stack_pointer];
                            id_token_stack_pointer--;
                            id_token_stack[id_token_stack_pointer]=temp_node_one;
                            id_operator_stack_pointer--;
                        }
                        else
                        {
                            printf("insufficient id token during pop operator
");
                            exit();
                        }
                        break;
                    case get_mem:
                        temp_node_one=malloc(sizeof(struct _phrase_tree_node));
                        temp_node_one->current_op_type=id_operator_stack[id_operator_stack_pointer];
                        temp_node_one->original_node=id_token_stack[id_token_stack_pointer];
                        id_token_stack[id_token_stack_pointer]=temp_node_one;
                        id_operator_stack_pointer--;
                        break;
                    case array_op:
                        printf("unmatched array_op in id_token
");
                        exit();
                        break;
                    case parenthesis:
                        printf("unmatched parenthesis in id_token
");
                        exit();
                        break;
                    default:
                        printf("unexpected op in id token
");
                        exit();
                        break;
                    }


                }//至此，操作符栈处理完毕
                //然后修正好词法链的头节点，使得这个=号被抛弃
                first_chain_head=temp_first_one->next;
                free(current_lex_token->token_name);
                free(current_lex_token);
                free(temp_first_one);
                id_token_stack_pointer--;
                return id_token_stack[1];
            }
        }
    }
}
phrase_tree_node* get_func(void)
{
    phrase_tree_node* tree_node_one;
    phrase_tree_node* tree_node_two;
    phrase_tree_node* tree_node_three;
    phrase_tree_node* tree_node_four;
    phrase_tree_node* tree_node_five;
    first_token_chain* chain_node_one;
    first_token_chain* chain_node_two;
    first_lex_token* current_token;
    tree_node_three=malloc(sizeof(struct _phrase_tree_node));//这个是函数名称节点
    tree_node_three->phrase_type=2;
    tree_node_three->var_name=first_chain_head->current_first_token->token_name;
    chain_node_one=first_chain_head;
    first_chain_head=chain_node_one->next;
    free(chain_node_one->current_first_token);
    free(chain_node_one);
    chain_node_one=first_chain_head;
    first_chain_head=chain_node_one->next;
    free(chain_node_one->current_first_token->token_name);
    free(chain_node_one->current_first_token);
    free(chain_node_one);
    tree_node_two=get_id();//获得第一个参数，
    tree_node_five=malloc(sizeof(struct _phrase_tree_node));
    tree_node_five->phrase_type=4;
    tree_node_five->original_node=tree_node_two;
    tree_node_two=tree_node_five;
    //由于不带参数的函数在调用的时候一定会有一个void参数，所以这个一定会成功
    while(*(first_chain_head->current_first_token->token_name)!=')')//这里闭括号预示着参数列表的结尾
    {
        tree_node_four=get_id();
        tree_node_five=malloc(sizeof(struct _phrase_tree_node));
        tree_node_five->phrase_type=4;
        tree_node_five->original_node=tree_node_four;
        tree_node_four=malloc(sizeof(struct _phrase_tree_node));
        tree_node_four->phrase_type=5;
        tree_node_four->left_son=tree_node_two;
        tree_node_four->right_son=tree_node_five;
        tree_node_two=tree_node_four;
    }

    chain_node_one=first_chain_head;
    first_chain_head=chain_node_one->next;
    free(chain_node_one->current_first_token->token_name);
    free(chain_node_one->current_first_token);
    free(chain_node_one);
    //这里把输入指针下移一个
    tree_node_one=malloc(sizeof(struct _phrase_tree_node));
    tree_node_one->phrase_type=3;
    tree_node_one->left_son=tree_node_three;
    tree_node_one->right_son=tree_node_two;
    return tree_node_one;
}

void phrase_operator_pop(int current_priority)//这个函数是为了从操作符栈中弹出一个操作符,对于是开括号的时候什么也不做
{
    phrase_tree_node* tree_node_one;
    int number_of_arg;
    while(phrase_operator_stack[phrase_operator_stack_pointer]->priority<=current_priority)
    {
        number_of_arg=phrase_operator_stack[phrase_operator_stack_pointer]->sub_number;
        tree_node_one=malloc(sizeof(struct _phrase_tree_node));
        tree_node_one->current_op_type=phrase_operator_stack[phrase_operator_stack_pointer]->current_op_type;
        if(number_of_arg==2)
        {
            if(tree_node_one->current_op_type!=array_op)//如果是数组运算符就什么都不干
            {
                if(phrase_token_stack_pointer<2)
                {
                    printf("need more token in phrase token stack
");
                    free(tree_node_one);
                    exit();
                }
                else
                {
                    tree_node_one->left_son=phrase_token_stack[phrase_token_stack_pointer-1];
                    tree_node_one->right_son=phrase_token_stack[phrase_token_stack_pointer];
                    phrase_token_stack_pointer--;
                    phrase_token_stack[phrase_token_stack_pointer]=tree_node_one;
                    phrase_operator_stack_pointer--;
                }
            }
            else
            {
                //do nothing
            }
        }
        else//这里有三种种特殊情况，一个是括号，一个就是强制类型转换,还有一个是sizeof
        {
            switch(tree_node_one->current_op_type)
            {
            case parenthesis:
                //do nothing 因为是开括号
                break;
            case type_cast:
                tree_node_one->token_for_cast=phrase_token_stack[phrase_token_stack_pointer];
                tree_node_one->cast_type_description=temp_cast_one;
                temp_cast_one=NULL;
                cast_pointer_layer=0;
                tree_node_one->pointer_layer=cast_pointer_layer;
                phrase_token_stack[phrase_token_stack_pointer]=tree_node_one;
                phrase_operator_stack_pointer--;
                break;
            case get_size://对于sizeof有两种形式
                if(temp_cast_one!=NULL)//对应的是声明头形式
                {
                    tree_node_one->token_for_cast=phrase_token_stack[phrase_token_stack_pointer];
                    tree_node_one->cast_type_description=temp_cast_one;
                    tree_node_one->pointer_layer=cast_pointer_layer;
                    temp_cast_one=NULL;
                    cast_pointer_layer=0;
                    phrase_token_stack[phrase_token_stack_pointer]=tree_node_one;
                    phrase_operator_stack_pointer--;
                }
                else//对应的是变量形式
                {
                    tree_node_one->original_node=phrase_token_stack[phrase_token_stack_pointer];
                    phrase_token_stack[phrase_token_stack_pointer]=tree_node_one;
                    phrase_operator_stack_pointer--;
                }
                break;
            default:
                if(phrase_token_stack_pointer==0)
                {
                    printf("need token in phrase token stack
");
                    free(tree_node_one);
                    exit();
                }
                else
                {
                    tree_node_one->original_node=phrase_token_stack[phrase_token_stack_pointer];
                    phrase_token_stack[phrase_token_stack_pointer]=tree_node_one;
                    phrase_operator_stack_pointer--;
                }
                break;
            }
        }
    }
}


void tackle_phrase_op(char* in_op)
{
    struct first_lex_token* current_lex_token;
    struct first_lex_token* next_lex_token;
    struct _phrase_tree_node* temp_tree_node;
    struct first_token_chain* current_chain_node;
    struct first_token_chain* next_chain_node;
    struct operator_token* current_operator_token;
    switch(*in_op)
    {
    case '(':
        //这里就有点复杂了因为要处理强制类型转换这个蛋疼的东西
        current_chain_node=first_chain_head;
        next_chain_node=current_chain_node->next;
        next_lex_token=next_chain_node->current_first_token;
        if(next_lex_token->current_lex_type==name)//准备强制类型转换
        {
            temp_cast_one=search_avl_tree(next_lex_token->token_name);
            if(temp_cast_one->type_type==4)//这里就意味着强制类型转换
            {
                first_chain_head=next_chain_node->next;
                free(current_chain_node->current_first_chain->token_name);
                free(current_chain_node->current_first_chain);
                free(current_chain_node);
                free(next_lex_token->token_name);
                free(next_lex_token);
                free(next_chain_node);
                if(first_chain_head->current_first_chain->current_lex_type==name)//这个对应的是符合类型的转换
                {
                    current_chain_node=first_chain_head;
                    current_lex_token=current_chain_node->current_first_token;
                    temp_cast_one=search_avl_tree(current_lex_token->token_name);//找出这个名字的类型
                    first_chain_head=first_chain_head->next;
                    free(current_lex_token->token_name);
                    free(current_lex_token);
                    free(current_chain_node);
                }
                cast_pointer_layer=0;
                while(*(first_chain_head->current_first_token->token_name)!=')')//吃掉所有的指针符号
                {
                    current_lex_token=first_chain_head->current_first_token;
                    if(*(current_lex_token->token_name)!='*')
                    {
                        printf("encount an unexpected token %s during cast_recognise
",current_lex_token->token_name);
                        exit();
                    }
                    else
                    {
                        cast_pointer_layer=cast_pointer_layer<<1 + 1;
                        current_chain_node=first_chain_head;
                        first_chain_head=first_chain_head->next;
                        free(current_lex_token->token_name);
                        free(current_lex_token);
                        free(current_chain_node);
                        //这里我们就先不纠结指针层数的限制了
                    }
                }
                //现在遇到的是括号

                //直接把这个括号丢弃，然后生成一个强制类型转换操作符
                current_chain_node=first_chain_head;
                first_chain_head=first_chain_head->next;
                free(current_lex_token->token_name);
                free(current_lex_token);
                free(current_chain_node);
                current_operator_token=malloc(sizeof(struct operator_token));
                current_operator_token->priority=2;
                current_operator_token->sub_number=1;
                current_operator_token->current_op_type=type_cast;
                phrase_operator_pop(2);
                phrase_operator_stack_pointer++;
                phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
                predecent=1;
            }
            else//遇到没有被识别的名称类型
            {
                printf("unexpected type %s during cast_recognisation
",next_lex_token->token_name);
                exit();
            }
        }
        else
            //对应的是普通的括号
        {
            current_operator_token=malloc(sizeof(struct operator_token));
            current_operator_token->priority=1;
            current_operator_token->sub_number=1;
            current_operator_token->current_op_type=parenthesis;
            //注意一旦碰到开括号，前面的优先级自动停止，因此不会碰到操作符出栈的情况
            //所以这里不需要考虑优先级了
            current_chain_node=first_chain_head;
            first_chain_head=first_chain_head->next;
            current_lex_token=current_chain_node->current_first_token;
            free(current_lex_token->token_name);
            free(current_lex_token);
            free(current_chain_node);
            phrase_operator_stack_pointer++;
            phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
            predecent=1;
        }
        //这里两种情况都被处理完毕了,累
        break;
    case '[':
        current_operator_token=malloc(sizeof(struct operator_token));
        current_operator_token->priority=1;
        current_operator_token->sub_number=2;
        current_operator_token->current_op_type=array_op;
        //这里数组运算符与括号不一样，数组运算符是一个运算符和界定符，而括号只是一个界定符。。。
        phrase_operator_pop(1);
        current_chain_node=first_chain_head;
        first_chain_head=first_chain_head->next;
        current_lex_token=current_chain_node->current_first_token;
        free(current_lex_token->token_name);
        free(current_lex_token);
        free(current_chain_node);
        phrase_operator_stack_pointer++;
        phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
        predecent=1;
        break;
    case '.':
        current_operator_token=malloc(sizeof(struct operator_token));
        current_operator_token->priority=1;
        current_operator_token->sub_number=2;
        current_operator_token->current_op_type=str_sub;
        phrase_operator_pop(1);
        current_chain_node=first_chain_head;
        first_chain_head=first_chain_head->next;
        current_lex_token=current_chain_node->current_first_token;
        free(current_lex_token->token_name);
        free(current_lex_token);
        free(current_chain_node);
        phrase_operator_stack_pointer++;
        phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
        predecent=1;
        break;
    case '-':
        if(predecent==0)//代表前面是操作数的情况
        {
            next_chain_node=current_chain_node->next;
            next_lex_token=next_chain_node->current_first_token;
            if(next_lex_token->current_lex_type==an_operator)//如果后面跟的也是操作符
            {
                if((*(next_lex_token->token_name))=='>')//对应的是p_str_sub
                {
                    current_operator_token=malloc(sizeof(struct operator_token));
                    current_operator_token->priority=1;
                    current_operator_token->sub_number=2;
                    current_operator_token->current_op_type=p_str_sub;
                    phrase_operator_pop(1);
                    phrase_operator_stack_pointer++;
                    phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
                    predecent=1;
                    first_chain_head=next_chain_node->next;
                    free(current_lex_node->token_name);
                    free(current_lex_node);
                    free(current_chain_node);
                    free(next_lex_node->token_name);
                    free(next_lex_node);
                    free(next_chain_node);
                    current_chain_node=first_chain_head;
                    current_lex_token=current_chain_node->current_first_token;
                }
                else//对应的不是结构体指针运算的情况,那就是减号
                {
                    current_operator_token=malloc(sizeof(struct operator_token));
                    current_operator_token->priority=4;
                    current_operator_token->sub_number=2;
                    current_operator_token->current_op_type=minus;
                    phrase_operator_pop(4);
                    current_chain_node=first_chain_head;
                    first_chain_head=first_chain_head->next;
                    current_lex_token=current_chain_node->current_first_token;
                    free(current_lex_token->token_name);
                    free(current_lex_token);
                    free(current_chain_node);
                    phrase_operator_stack_pointer++;
                    phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
                    predecent=1;
                }
            }
            else//对应的不是结构体指针运算的情况,那就是减号
            {
                current_operator_token=malloc(sizeof(struct operator_token));
                current_operator_token->priority=4;
                current_operator_token->sub_number=2;
                current_operator_token->current_op_type=minus;
                phrase_operator_pop(4);
                current_chain_node=first_chain_head;
                first_chain_head=first_chain_head->next;
                current_lex_token=current_chain_node->current_first_token;
                free(current_lex_token->token_name);
                free(current_lex_token);
                free(current_chain_node);
                phrase_operator_stack_pointer++;
                phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
                predecent=1;
            }
        }
        else//对应的是前面的是操作符的情况,则这里是当作负号来使用的
        {
            current_operator_token=malloc(sizeof(struct operator_token));
            current_operator_token->priority=2;
            current_operator_token->sub_number=1;
            current_operator_token->current_op_type=negative;
            if(phrase_operator_stack[phrase_operator_stack_pointer]->priority<=2)
            {
                phrase_operator_pop();
            }
            current_chain_node=first_chain_head;
            first_chain_head=first_chain_head->next;
            current_lex_token=current_chain_node->current_first_token;
            free(current_lex_token->token_name);
            free(current_lex_token);
            free(current_chain_node);
            phrase_operator_stack_pointer++;
            phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
            predecent=1;
        }



        break;
    case ')':
        //对于闭括号和闭方括号，我们需要一直弹出栈，直到遇到开括号和开方括号
        phrase_operator_pop(1);
        phrase_operator_stack_pointer--;
        current_chain_node=first_chain_head;
        first_chain_head=first_chain_head->next;
        current_lex_token=current_chain_node->current_first_token;
        free(current_lex_token->token_name);
        free(current_lex_token);
        free(current_chain_node);
        precedent=0;
        break;
    case ']':
        //处理方法同上，不过需要建立一个token节点
        phrase_operator_pop(1);
        temp_tree_node=malloc(sizeof(struct _phrase_tree_node));
        temp_tree_node->current_op_type=array_op;
        temp_tree_node->right_son=phrase_token_stack[phrase_token_stack_pointer];
        phrase_token_stack_pointer--;
        temp_tree_node->left_son=phrase_token_stack[phrase_token_stack_pointer];
        phrase_token_stack[phrase_token_stack_pointer]=temp_tree_node;
        phrase_operator_stack_pointer--;
        current_chain_node=first_chain_head;
        first_chain_head=first_chain_head->next;
        current_lex_token=current_chain_node->current_first_token;
        free(current_lex_token->token_name);
        free(current_lex_token);
        free(current_chain_node);
        precedent=0;
        break;
    case '!':
        current_chain_node=first_chain_head;
        first_chain_head=first_chain_head->next;
        free(current_chain_node->current_first_token->token_name);
        free(current_chain_node->current_first_token);
        free(current_chain_node);
        current_chain_node=first_chain_head;
        current_lex_token=current_chain_node->current_first_token;
        if(*(current_lex_token->token_name)!='=')
        {
            current_operator_token=malloc(sizeof(struct operator_token));
            current_operator_token->priority=2;
            current_operator_token->sub_number=1;
            current_operator_token->current_op_type=not;
            phrase_operator_pop(2);
            phrase_operator_stack_pointer++;
            phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
            predecent=1;
        }
        else//对应的是不等号
        {
            current_operator_token=malloc(sizeof(struct operator_token));
            current_operator_token->priority=7;
            current_operator_token->sub_number=2;
            current_operator_token->current_op_type= nequal;
            phrase_operator_pop(7);
            current_chain_node=first_chain_head;
            first_chain_head=first_chain_head->next;
            current_lex_token=current_chain_node->current_first_token;
            free(current_lex_token->token_name);
            free(current_lex_token);
            free(current_chain_node);
            phrase_operator_stack_pointer++;
            phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
            predecent=1;
        }
        break;
    case '~':
        current_operator_token=malloc(sizeof(struct operator_token));
        current_operator_token->priority=2;
        current_operator_token->sub_number=1;
        current_operator_token->current_op_type=bit_rev;
        phrase_operator_pop(2);
        current_chain_node=first_chain_head;
        first_chain_head=first_chain_head->next;
        current_lex_token=current_chain_node->current_first_token;
        free(current_lex_token->token_name);
        free(current_lex_token);
        free(current_chain_node);
        phrase_operator_stack_pointer++;
        phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
        predecent=1;
        break;
    case '&':
        if(predecent==1)//如果前面已经有操作符了，说明这个是取地址运算
        {
            current_operator_token=malloc(sizeof(struct operator_token));
            current_operator_token->priority=2;
            current_operator_token->sub_number=1;
            current_operator_token->current_op_type=get_adr;
            while(phrase_operator_stack[phrase_operator_stack_pointer]->priority<=2)
            {
                phrase_operator_pop();
            }
            current_chain_node=first_chain_head;
            first_chain_head=first_chain_head->next;
            current_lex_token=current_chain_node->current_first_token;
            free(current_lex_token->token_name);
            free(current_lex_token);
            free(current_chain_node);
            phrase_operator_stack_pointer++;
            phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
            predecent=1;
        }
        else//说明这个不是取地址运算，而是布尔运算或者位运算
        {
            current_chain_node=first_chain_head;
            next_chain_node=current_chain_node->next;
            next_lex_token=next_chain_node->current_first_token;
            if(next_lex_token->current_lex_type==an_operator)//如果后面跟的是操作符
            {
                if(*(next_lex_token->token_name)=='&')//如果是布尔运算
                {
                    current_operator_token=malloc(sizeof(struct operator_token));
                    current_operator_token->priority=11;
                    current_operator_token->sub_number=2;
                    current_operator_token->current_op_type=and;
                    phrase_operator_pop(11);
                    //这里需要吃掉两个字符
                    first_chain_head=first_chain_head->next;
                    current_lex_token=current_chain_node->current_first_token;
                    free(current_lex_token->token_name);
                    free(current_lex_token);
                    free(current_chain_node);
                    first_chain_head=first_chain_head->next;
                    free(next_lex_token->token_name);
                    free(next_lex_token);
                    free(next_chain_node);
                    phrase_operator_stack_pointer++;
                    phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
                    predecent=1;
                }

                else//这里是位运算
                {
                    current_operator_token=malloc(sizeof(struct operator_token));
                    current_operator_token->priority=7;
                    current_operator_token->sub_number=2;
                    current_operator_token->current_op_type=bit_and;
                    while(phrase_operator_stack[phrase_operator_stack_pointer]->priority<=7)
                    {
                        phrase_operator_pop();
                    }
                    current_chain_node=first_chain_head;
                    first_chain_head=first_chain_head->next;
                    current_lex_token=current_chain_node->current_first_token;

                    free(current_lex_token->token_name);
                    free(current_lex_token);
                    free(current_chain_node);
                    phrase_operator_stack_pointer++;
                    phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
                    predecent=1;
                }

            }
            else//这里还是位运算
            {
                current_operator_token=malloc(sizeof(struct operator_token));
                current_operator_token->priority=7;
                current_operator_token->sub_number=2;
                current_operator_token->current_op_type=bit_and;
                while(phrase_operator_stack[phrase_operator_stack_pointer]->priority<=7)
                {
                    phrase_operator_pop();
                }
                current_chain_node=first_chain_head;
                first_chain_head=first_chain_head->next;
                current_lex_token=current_chain_node->current_first_token;
                free(current_lex_token->token_name);
                free(current_lex_token);
                free(current_chain_node);
                phrase_operator_stack_pointer++;
                phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
                predecent=1;
            }
        }
        break;
    case '*':
        if(predecent==1)//这里对应的是指针运算
        {
            current_operator_token=malloc(sizeof(struct operator_token));
            current_operator_token->priority=2;
            current_operator_token->sub_number=1;
            current_operator_token->current_op_type=get_mem;
            phrase_operator_pop(2);
            current_chain_node=first_chain_head;
            first_chain_head=first_chain_head->next;
            current_lex_token=current_chain_node->current_first_token;
            free(current_lex_token->token_name);
            free(current_lex_token);
            free(current_chain_node);
            phrase_operator_stack_pointer++;
            phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
            predecent=1;
        }
        else//对应的是乘法运算
        {
            current_operator_token=malloc(sizeof(struct operator_token));
            current_operator_token->priority=3;
            current_operator_token->sub_number=2;
            current_operator_token->current_op_type=multi;
            phrase_operator_pop(3);
            current_chain_node=first_chain_head;
            first_chain_head=first_chain_head->next;
            current_lex_token=current_chain_node->current_first_token;
            free(current_lex_token->token_name);
            free(current_lex_token);
            free(current_chain_node);
            phrase_operator_stack_pointer++;
            phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
            predecent=1;
        }
        break;
    case 's'://对应sizeof运算,这里又需要类型头部或者变量，这里我们强制要求有括号
        current_chain_node=first_chain_head;
        first_chain_head=first_chain_head->next;
        free(current_chain_node->current_first_chain->token_name);
        free(current_chain_node->current_first_chain);
        free(current_chain_node);
        current_chain_node=first_chain_head;
        current_lex_token=current_chain_node->current_first_token;
        if(*(current_lex_token->token_name)=='(')//准备sizeof,至于括号里面的东西就交给括号去处理
        {
            current_operator_token=malloc(sizeof(struct operator_token));
            current_operator_token->priority=2;
            current_operator_token->sub_number=1;
            current_operator_token->current_op_type=get_size;
            phrase_operator_pop(2);
            current_chain_node=first_chain_head;
            first_chain_head=first_chain_head->next;
            current_lex_token=current_chain_node->current_first_token;
            free(current_lex_token->token_name);
            free(current_lex_token);
            free(current_chain_node);
            phrase_operator_stack_pointer++;
            phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
            predecent=1;
        }
        else
        {
            printf("missing ( after sizeof
");
            exit();
        }
        break;
    case '/':
        current_operator_token=malloc(sizeof(struct operator_token));
        current_operator_token->priority=3;
        current_operator_token->sub_number=2;
        current_operator_token->current_op_type=div;
        phrase_operator_pop(3);
        current_chain_node=first_chain_head;
        first_chain_head=first_chain_head->next;
        current_lex_token=current_chain_node->current_first_token;
        free(current_lex_token->token_name);
        free(current_lex_token);
        free(current_chain_node);
        phrase_operator_stack_pointer++;
        phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
        predecent=1;
        break;
    case '%':
        current_operator_token=malloc(sizeof(struct operator_token));
        current_operator_token->priority=3;
        current_operator_token->sub_number=2;
        current_operator_token->current_op_type=module;
        phrase_operator_pop(3);
        current_chain_node=first_chain_head;
        first_chain_head=first_chain_head->next;
        current_lex_token=current_chain_node->current_first_token;
        free(current_lex_token->token_name);
        free(current_lex_token);
        free(current_chain_node);
        phrase_operator_stack_pointer++;
        phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
        predecent=1;
        break;
    case '+':
        current_operator_token=malloc(sizeof(struct operator_token));
        current_operator_token->priority=4;
        current_operator_token->sub_number=2;
        current_operator_token->current_op_type=get_mem;
        phrase_operator_pop(4);
        current_chain_node=first_chain_head;
        first_chain_head=first_chain_head->next;
        current_lex_token=current_chain_node->current_first_token;
        free(current_lex_token->token_name);
        free(current_lex_token);
        free(current_chain_node);
        phrase_operator_stack_pointer++;
        phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
        predecent=1;
        break;
    case '<'://这里有三种情况。。。 移位和两个判断
        current_chain_node=first_chain_head;
        first_chain_head=first_chain_head->next;
        free(current_chain_node->current_first_token->token_name);
        free(current_chain_node->current_first_token);
        free(current_chain_node);
        current_chain_node=first_chain_head;
        current_lex_token=current_chain_node->current_first_token;
        if(current_lex_token->current_lex_type==an_operator)//如果后面接的是操作符
        {
            switch(*(current_lex_token->token_name))
            {
            case '<':
                current_operator_token=malloc(sizeof(struct operator_token));
                current_operator_token->priority=5;
                current_operator_token->sub_number=2;
                current_operator_token->current_op_type=left_shift;
                phrase_operator_pop(5);
                first_chain_head=first_chain_head->next;
                free(current_lex_token->token_name);
                free(current_lex_token);
                free(current_chain_node);
                phrase_operator_stack_pointer++;
                phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
                predecent=1;
                break;
            case '=':
                current_operator_token=malloc(sizeof(struct operator_token));
                current_operator_token->priority=6;
                current_operator_token->sub_number=2;
                current_operator_token->current_op_type=sma_eqa;
                phrase_operator_pop(6);
                first_chain_head=first_chain_head->next;
                free(current_lex_token->token_name);
                free(current_lex_token);
                free(current_chain_node);
                phrase_operator_stack_pointer++;
                phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
                predecent=1;
                break;
            default:
                current_operator_token=malloc(sizeof(struct operator_token));
                current_operator_token->priority=6;
                current_operator_token->sub_number=2;
                current_operator_token->current_op_type=smaller;
                phrase_operator_pop(6);
                phrase_operator_stack_pointer++;
                phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
                predecent=1;
                break;
            }
        }
        else
        {
            current_operator_token=malloc(sizeof(struct operator_token));
            current_operator_token->priority=6;
            current_operator_token->sub_number=2;
            current_operator_token->current_op_type=smaller;
            phrase_operator_pop(6);
            first_chain_head=first_chain_head->next;
            phrase_operator_stack_pointer++;
            phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
            predecent=1;
        }
        break;
    case '>':
        current_chain_node=first_chain_head;
        first_chain_head=first_chain_head->next;
        free(current_chain_node->current_first_token->token_name);
        free(current_chain_node->current_first_token);
        free(current_chain_node);
        current_chain_node=first_chain_head;
        current_lex_token=current_chain_node->current_first_token;
        if(current_lex_token->current_lex_type==an_operator)//如果后面接的是操作符
        {
            switch(*(current_lex_token->token_name))
            {
            case '>':
                current_operator_token=malloc(sizeof(struct operator_token));
                current_operator_token->priority=5;
                current_operator_token->sub_number=2;
                current_operator_token->current_op_type=right_shift;
                phrase_operator_pop(5);
                first_chain_head=first_chain_head->next;
                free(current_lex_token->token_name);
                free(current_lex_token);
                free(current_chain_node);
                phrase_operator_stack_pointer++;
                phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
                predecent=1;
                break;
            case '=':
                current_operator_token=malloc(sizeof(struct operator_token));
                current_operator_token->priority=6;
                current_operator_token->sub_number=2;
                current_operator_token->current_op_type=lar_eqa;
                phrase_operator_pop(6);
                first_chain_head=first_chain_head->next;
                free(current_lex_token->token_name);
                free(current_lex_token);
                free(current_chain_node);
                phrase_operator_stack_pointer++;
                phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
                predecent=1;
                break;
            default:
                current_operator_token=malloc(sizeof(struct operator_token));
                current_operator_token->priority=6;
                current_operator_token->sub_number=2;
                current_operator_token->current_op_type=larger;
                phrase_operator_pop(6);
                first_chain_head=first_chain_head->next;
                free(current_lex_token->token_name);
                free(current_lex_token);
                free(current_chain_node);
                phrase_operator_stack_pointer++;
                phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
                predecent=1;
                break;
            }
        }
        else
        {
            current_operator_token=malloc(sizeof(struct operator_token));
            current_operator_token->priority=6;
            current_operator_token->sub_number=2;
            current_operator_token->current_op_type=larger;
            phrase_operator_pop(6);
            phrase_operator_stack_pointer++;
            phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
            predecent=1;
        }
        break;
    case '=':
        current_chain_node=first_chain_head;
        current_lex_token=current_chain_node->current_first_token;
        free(current_lex_token->token_name);
        free(current_lex_token);
        free(current_chain_node);
        first_chain_head=first_chain_head->next;
        current_chain_node=first_chain_head;
        current_lex_token=current_chain_node->current_first_token;
        if(*(current_lex_token->token_name)=='=')
        {
            current_operator_token=malloc(sizeof(struct operator_token));
            current_operator_token->priority=7;
            current_operator_token->sub_number=2;
            current_operator_token->current_op_type=equal;
            phrase_operator_pop(2);
            free(current_lex_token->token_name);
            free(current_lex_token);
            free(current_chain_node);
            phrase_operator_stack_pointer++;
            phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
            predecent=1;
        }
        else
        {
            printf("stand alone = is encounted
");
            exit();
        }
        break;
    case '^':
        current_operator_token=malloc(sizeof(struct operator_token));
        current_operator_token->priority=9;
        current_operator_token->sub_number=2;
        current_operator_token->current_op_type=bit_xor;
        phrase_operator_pop(9);
        current_chain_node=first_chain_head;
        first_chain_head=first_chain_head->next;
        current_lex_token=current_chain_node->current_first_token;
        free(current_lex_token->token_name);
        free(current_lex_token);
        free(current_chain_node);
        phrase_operator_stack_pointer++;
        phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
        predecent=1;
        break;
    case '|':
        current_chain_node=first_chain_head;
        current_lex_token=current_chain_node->current_first_token;
        free(current_lex_token->token_name);
        free(current_lex_token);
        free(current_chain_node);
        first_chain_head=first_chain_head->next;
        current_chain_node=first_chain_head;
        current_lex_token=current_chain_node->current_first_token;
        if(*(current_lex_token->token_name)=='|')
        {
            current_operator_token=malloc(sizeof(struct operator_token));
            current_operator_token->priority=12;
            current_operator_token->sub_number=2;
            current_operator_token->current_op_type=or;
            phrase_operator_pop(12);
            free(current_lex_token->token_name);
            free(current_lex_token);
            free(current_chain_node);
            phrase_operator_stack_pointer++;
            phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
            predecent=1;
        }
        else
        {
            current_operator_token=malloc(sizeof(struct operator_token));
            current_operator_token->priority=10;
            current_operator_token->sub_number=2;
            current_operator_token->current_op_type=bit_or;
            phrase_operator_pop(10);
            phrase_operator_stack_pointer++;
            phrase_operator_stack[phrase_operator_stack_pointer]=current_operator_token;
            predecent=1;
        }
        break;
    default:
        printf("unknown operator  %s is encounted
",in_op);
        exit();
        break;
    }

}
phrase_tree_node* get_expression(void)//这里才是他妈的重头戏啊，12级运算符不弄死你
{
    phrase_tree_node* tree_node_one;
    first_lex_token* current_lex_token;
    first_lex_token* next_lex_token;
    first_token_chain* current_chain_node;
    first_token_chain* next_chain_node;
    current_token_chain=first_chain_head;
    predecent=1;
    phrase_token_stack_pointer=0;
    phrase_operator_stack_pointer=0;
    current_lex_token=current_token_chain->current_first_token;
    while(current_lex_token->current_lex_type!=delimit)
    {
        switch(current_lex_token->current_lex_type)
        {
        case char_type:
            tree_node_one=malloc(sizeof(struct _phrase_tree_node));
            tree_node_one->phrase_type=7;
            tree_node_one->var_name=current_lex_token->token_name;
            free(curren_lex_token);
            first_chain_head=first_chain_head->next;
            free(current_token_chain);
            current_token_chain=first_chain_head;
            current_lex_token=current_token_chain->current_first_token;
            predecent=0;
            break;
        case string_phrase:
            tree_node_one=malloc(sizeof(struct _phrase_tree_node));
            tree_node_one->phrase_type=8;
            tree_node_one->var_name=current_lex_token->token_name;
            free(curren_lex_token);
            first_chain_head=first_chain_head->next;
            free(current_token_chain);
            current_token_chain=first_chain_head;
            current_lex_token=current_token_chain->current_first_token;
            predecent=0;
            break;
        case constant:
            tree_node_one=malloc(sizeof(struct _phrase_tree_node));
            tree_node_one->phrase_type=1;
            tree_node_one->var_name=current_lex_token->token_name;
            free(curren_lex_token);
            first_chain_head=first_chain_head->next;
            free(current_token_chain);
            current_token_chain=first_chain_head;
            current_lex_token=current_token_chain->current_first_token;
            predecent=0;
            break;
        case name:
            next_chain_node=current_chain_node->next;
            next_lex_token=next_chain_node->current_first_token;
            if(*(next_lex_token->token_name)=='(')//这里对应的是一个函数
            {
                tree_node_one=get_func();
                phrase_token_stack_pointer++;
                phrase_token_stack[phrase_token_stack_pointer]=tree_node_one;
                current_chain_node=first_chain_head;
                current_lex_token=current_chain_node->current_first_token;
            }
            else
            {
                tree_node_one=malloc(sizeof(struct _phrase_tree_node));
                tree_node_one->phrase_type=2;
                tree_node_one->var_name=current_lex_token->token_name;
                free(curren_lex_token);
                first_chain_head=first_chain_head->next;
                free(current_token_chain);
                current_token_chain=first_chain_head;
                current_lex_token=current_token_chain->current_first_token;
            }
            predecent=0;
            break;
        case an_operator:
            tackle_phrase_op(current_lex_token->token_name);
            current_token_chain=first_chain_head;
            current_lex_token=current_token_chain->current_first_token;
            break;
        default:
            printf("unknown lex type is encounted
");
            exit();
            break;
        }
    }
    //现在开始清空栈
    free(current_lex_token->token_name);
    free(curren_lex_token);
    first_chain_head=first_chain_head->next;
    free(current_token_chain);
    phrase_operator_pop(13);
    return phrase_token_stack[1];
}

phrase_tree_node* get_phrase(void)
//这个函数是处理单个句型的函数,不包括定义和声明，那里我们特殊处理
//我们要确保调用者在调用这个函数的时候，已经吃掉了所有的换行符
{
    struct first_lex_token current_lex_token;
    struct _phrase_tree_node* copyto_address_node;//赋值的目标地址
    struct _phrase_tree_node* temp_node_one;
    struct _phrase_tree_node* temp_node_three;
    struct _phrase_tree_node* temp_node_two;
    struct first_token_chain* temp_first_one;
    struct first_token_chain* temp_first_two;
    copyto_address_node=NULL;
    temp_first_one=first_chain_head;
    temp_first_two=temp_first_one->next;
    current_lex_token=temp_first_one->current_first_token;
    if(current_lex_token->current_lex_type==name)//如果句子开头是名字
    {
        if(temp_first_two->current_first_token->current_lex_type==delimit)//如果紧接着的是分号，那么就是break语句
        {
            temp_node_one=malloc(sizeof(struct _phrase_tree_node));
            temp_node_one->phrase_type=0;//代表是break语句
            free(temp_first_one);
            temp_first_one=temp_first_two->next;
            free(temp_first_two);
            first_chain_head=temp_first_one;
            return temp_node_one;
        }
        else//如果不是break语句
        {
            if(*(temp_first_two->current_first_token->token_name)=='(')//这里对应的是函数调用
            {
                if(serach_avl_tree(current_lex_token->token_name)->type_type==1)//如果真是的函数名
                {
                    return get_func();//这个是专门处理函数的
                }
                else//如果是不合理的搭配，则报错
                {
                    printf("error encountered
");
                    printf("invalid match
");
                    printf("the match is %s and ( 
",current_lex_token->token_name);
                    exit();
                }
            }
            else//如果后面接的不是开括号,则一定是赋值语句，则我们需要首先获得id，然后再去处理表达式
            {
                copyto_address_node=get_id();//利用get_id来获得地址，注意这里get_id会保留=的存在，需要自己去处理
                temp_first_one=first_chain_head->next;
                free(first_chain_head);
                first_chain_head=temp_first_one;
                temp_node_two=get_expression();//利用函数来获得表达式
                temp_node_three=malloc(sizeof(struct _phrase_tree_node));//分配返回节点
                temp_node_three->phrase_type=4;
                temp_node_three->left_son=copyto_address_node;
                temp_node_three->right_son=temp_node_two;
                return temp_node_three;
            }//处理完毕
        }
    }
    else//如果开头不是名字，那么就一定是赋值运算。
    {
        copyto_address_node=get_id();
        temp_first_one=first_chain_head->next;
        free(first_chain_head);
        first_chain_head=temp_first_one;
        temp_node_two=get_expression();//利用函数来获得表达式
        temp_node_three=malloc(sizeof(struct _phrase_tree_node));//分配返回节点
        temp_node_three->phrase_type=4;
        temp_node_three->left_son=copyto_address_node;
        temp_node_three->right_son=temp_node_two;
        return temp_node_three;
    }
}