符号表的构造

/**符号表的构造过程**/


/**
解析外部声明
l:存储类型，局部的还是全局的
**/
void external_decartion(int l)
{
    Type btype,type;
    int v,has_init,r,addr;
    Symbol *sym;
    if(!type_specifier(&btype))     /**修改btype的t成员**/
    {
        expect("<类型区别符>");
    }
    if(btype.t==T_STRUCT&&token==TK_SEMICOLON)/**只有结构体类型定义的结尾加分号是合法的**/
    {
        get_token();
        return;
    }
    while(1)        /*逐个分析声明或函数定义*/
    {
        type=btype;
        declarator(&type,&v,NULL);       /**经过这个函数，v会变成token,如果是函数或数组，则type会发生变化，不然type还是原来的btype值，最后一个参数跟对齐有关**/
        if(token==TK_BEGIN)              /**函数定义**/
        {
            if(l==SC_LOCAL)
                error("不支持函数嵌套定义");
            if(type.t&T_BTYPE!=T_FUNC)
                expect("<函数定义>");
            sym=sym_search(v);
            if(sym)                     /**函数前面声明过，现在给出函数定义**/
            {
                if((sym->type.t&T_BTYPE)!=T_FUNC)/**标识符声明的时候不是函数类型，就会显示重定义错误**/
                    error("'%s'重定义",get_tkstr(v));
                sym->type=type;         /**type和sym->type的区别在于ref,type.ref经过declarator函数后有了值，sym->type.ref并没有赋值**/
            }
            else
            {
                sym=func_sym_push(v,&type);/**如果单词的identifier值还没有，就把插进去sym**/
            }
            sym->r=SC_SYM|SC_GLOBAL;        /**函数符号的r值设置为符号和全局**/
            funcbody(sym);
            break;
        }
        else                                /**声明**/
        {
            if((type.t&T_BTYPE)==T_FUNC)    //函数声明
            {
                if(sym_search(v)==NULL)
                {
                    sym=sym_push(v,&type,SC_GLOBAL|SC_SYM,0); /**函数符号的r值设置为符号和全局**/
                }
            }
            else                            //变量声明
            {
                r=0;
                if(!(type.t&T_ARRAY))       /**数组类型不能做左值**/
                    r|=SC_LVAL;
                r|=l;                       /**l表示是全局类型还是局部类型**/
                has_init=(token==TK_ASSIGN);

                if(has_init)
                {
                    get_token();
                    initializer(&type);
                }
                sym=var_sym_put(&type,r,v,addr);/**局部变量 经过这函数r不变，全局变量,r|SC_SYM**/
            }
            if(token==TK_COMMA)
            {
                get_token();
            }
            else
            {
                syntax_state=SNTX_LF_HT;
                skip(TK_SEMICOLON);
                break;
            }
        }
    }

}
/**
功能：解析类型区分符
返回值：是否发现合法的类型区分符
<type_specifier>::=<KW_INT>
    |<KW_CHAR>
    |<KW_SHORT>
    |<KW_VOID>
    |<struct_specifier>
**/
int type_specifier(Type *type)
{
    int t,type_found;
    Type type1;
    t=0;
    int type_found=0;
    switch(token)
    {
    case KW_CHAR:
        t=T_CHAR;
        type_found=1;
        syntax_state=SNTX_SP;   /**空格**/
        get_token();
        break;
    case KW_SHORT:
        t=T_SHORT;
        type_found=1;
        syntax_state=SNTX_SP;
        get_token();
        break;
    case KW_VOID:
        t=T_VOID;
        type_found=1;
        syntax_state=SNTX_SP;
        get_token();
        break;
    case KW_INT:
        t=T_INT;
        type_found=1;
        syntax_state=SNTX_SP;
        get_token();
        break;
    case KW_STRUCT:
        struct_specifier(&type1);
        type->ref=type1.ref;            /**ref改变**/
        t=T_STRUCT;
        type_found=1;
        syntax_state=SNTX_SP;
        break;
    default:
        break;

    }
    type->t=t;
    return type_found;
}

/**
结构区分符：
<struct_specifier>::=
<KW_STRUCT><IDENTIFIER><TK_BEGIN><struct_declaration_list><TK_END>
    |<KW_STRUCT><IDENTIFIER>
**/
void struct_specifier(Type *type)
{
    int v;
    Symbol *s;
    Type type1;

    get_token();
    v=token;

    syntax_state=SNTX_DELAY;        /**延迟到取出下个单词后确定输出格式**/

    get_token();
    if(token==TK_BEGIN)     /*适用于结构体定义*/
    syntax_state=SNTX_LF_HT;
    else if(token==TK_CLOSEPA)  /*适用于sizeof(struct struct_name)*/
    syntax_state=SNTX_NUL;
    else                        /*适用于结构变量声明*/
        syntax_state=SNTX_SP;
    syntax_indent();
    if(v<TK_IDENT)          /**关键字不能作为结构名称**/
        expect("结构体名");
    s=struct_search(v);     /**查找结构是否定义**/
    if(!s)
    {
        type1.t=KW_STRUCT;  /**是KW_STRUCT 不是T_STRUCT**/
        //-1赋值给s->c,标识结构体尚未定义
        s=sym_push(v|SC_STRUCT,&type1,0,-1);
        s->r=0;

    }
    type->ref=s;            /**ref引用**/
    if(token==TK_BEGIN)
    {
        struct_declaration_list(type);
    }
}
/**
结构声明符表
<struct_declaration_list>::=<struct_declaration>{<struct_declaration>}
**/
void struct_declaration_list(Type *type)
{
    int maxalign,offset;
    syntax_state=SNTX_LF_HT;    /**第一个结构体成员与{不写在同一行**/
    syntax_level++;             /**结构体成员变量声明，缩进增加一级**/
    Symbol *s,**ps;
    s=type->ref;
    get_token();
    if(s->c!=-1)                /**s->c记录结构体尺寸**/
        error("结构体已定义");
    maxalign=1;
    ps=&s->next;
    offset=0;
    while(token!=TK_END)
    {
        struct_declaration(&maxalign,&offset,&ps);
    }
    skip(TK_END);
    syntax_state=SNTX_LF_HT;
    s->c=calc_align(offset,maxalign);   /**结构体大小**/
    s->r=maxalgin;                      /**结构体对齐**/
}
/**
结构声明
<struct_declaration::=
    <type_specifier><declarator>{<TK_COMMA><declarator>}<TK_SEMICOLON>

maxalign(输入，输出):成员最大对齐粒度
offset(输入，输出):  偏移量
ps(输出)：            结构定义符号
**/
void struct_declaration(int* maxalign,int *offset,Symbol ***ps)
{
    int v,size,align;
    Symbol *ss;
    Type type1,btype;
    int force_align;
    type_specifier(&btype);
    while(1)        /**while循环很精妙呀**/
    {
        v=0;
        type1=btype;
        declarator(&type1,&v,&force_align);    /**force_align这个参数用来观察是否有强制对齐**/
        size=type_size(&type1,&align);

        if(force_align&ALIGN_SET)               /**如果有强制对齐就按强制对齐**/
            align=force_align&~ALIGN_SET;       /** #define ALIGN_SET 0x100**/

        *offset=calc_align(*offset,align);

        if(align>*maxalign)
            *maxalign=align;
        ss=sym_push(v|SC_MEMBER,&type1,0,*offset);
        *offset+=size;
        **ps=ss;
        *ps=&ss->next;                          /**next**/
        if(token==TK_SEMICOLON)
            break;
        skip(TK_COMMA);
    }
    syntax_state=SNTX_LF_HT;/**又来了这不明所以的东西**/
    skip(TK_SEMICOLON);
}
/**
函数调用约定
<function_calling_convention>::=<KW_CDECL>|<KW_STDCALL>
用于函数声明上，用在数据声明上忽略掉

fc(输出):调用约定
**/
void function_calling_convention(int *fc)
{
    *fc=KW_CDECL;
    if(token==KW_CDECL||token==KW_STDCALL)
    {
        syntax_state=SNTX_SP;
        *fc=token;
        get_token();
    }
}
/**
结构成员对齐
<struct_member_alignment>::=<KW_ALIGN><TK_OPENPA><TK_CINT><TK_CLOSEPA>
force_align(输出):强制对齐粒度
**/
void struct_member_alignment(int *force_align)
{
    int align=1;
    if(token==KW_ALIGN)             /**如果有强制对齐**/
    {
        get_token();
        skip(TK_OPENPA);
        if(token==TK_CINT)
        {
            get_token();
            align=tkvalue;          /**align值为（）里的数字值**/
        }
        else expect("整数常量");
        skip(TK_CLOSEPA);
        if(align!=1&&align!=2&&align!=4)
            align=1;
        align|=ALIGN_SET;           /**|=ALIGN_SET 说明要强制对齐**/
        *force_align=align;
    }
    else
        *force_align=1;
}
/**
声明符
<declarator>::={<pointer>}[<function_calling_convention>]
    [<struct_member_alignment>]<direct_declarator>
<pointer>::=<TK_STAR>

type:   数据类型
v(输出): 单词编号
force_align(输出): 强制对齐粒度
**/
void declarator(Type *type,int *v,int *force_align)
{
    int fc;
    while(token==TK_STAR)
    {
        mk_pointer(type);
        get_token();
    }
    function_calling_convention(&fc);
    if(force_align)
        struct_member_alignment(force_align);
    direct_declarator(type,v,fc);
}
/**
功能:	生成指针类型
t:		原数据类型
**/
void mk_pointer(Type *t)
{
	Symbol *s;
    s = sym_push(SC_ANOM, t, 0, -1);
    t->t = T_PTR ;
    t->ref = s;
}

/**
直接声明符
<direct_declarator>::=<IDENTIFIER><direct_declarator_postfix>

type(输入，输出):数据类型
v(输出):单词编号
func_call:函数调用约定
**/
void direct_declarator(Type *type,int *v,int func_call)
{
    if(token>=TK_IDENT)
    {
        *v=token;
        get_token();
    }
    else
    {
        expect("标识符");
    }
    direct_declarator_postfix(type,func_call);
}
/**
直接声明符后缀
<direct_declarator_postfix>::={<TK_OPENBR><TK_CINT><TK_CLOSEBR>
    |<TK_OPENBR><TK_CLOSEBR>
    |<TK_OPENPA><parameter_type_list><TK_CLOSEPA>
    |<TK_OPENPA><TK_CLOSEPA>
}
type(输入，输出):数据类型
func_call:函数调用约定
**/
void direct_declarator_postfix(Type*type,int func_call)
{
    int n;
    Symbol *s;
    if(token==TK_OPENPA)
    {
        parameter_type_list(type,func_call);/**函数需要func_call参数，变量不用**/
    }
    else if(token==TK_OPENBR)
    {
        get_token();
        n=-1;
        if(token==TK_CINT)
        {
            get_token();
            n=tkvalue;
        }
        skip(TK_CLOSEBR);
        direct_declarator_postfix(type,func_call);
        s=sym_push(SC_ANOM,type,0,n);
        type->t=T_ARRAY|T_PTR;
        type->ref=s;
    }
}
/**
形参类型表
功能：解析形参类型表
func_call:函数调用约定

<parameter_type_list>::=<parameter_list>
    |<parameter_list><TK_COMMA><TK_ELLIPSIS>
<parameter_list>::=<parameter_declaration>
    {<TK_COMMA><parameter_declaration}
<parameter_declaration>::=<type_specifier>{<declarator>}

等价转换后文法：
<parameter_type_list>::=<type_specifier>{<declarator>}
    {<TK_COMMA><type_specifier>{<declarator>}}<TK_COMMA><TK_ELLIPSIS>
**/
void parameter_type_list(Type *type,int func_call)
{
    int n;
    Symbol **plast,*s,*first;
    Type pt;
    get_token();
    first=NULL;
    plast=&first;
    while(token!=TK_CLOSEPA)
    {
        if(!type_specifier(&pt))
        {
            error("无效类型标识符");
        }
        declarator(&pt,&n,NULL);
        s=sym_push(n|SC_PARAMS,&pt,0,0);/**SC_PARAMS表函数参数**/
        *plast=s;
        plast=&s->next;                 /**next显示作用**/
        if(token==TK_CLOSEPA)
            break;
        skip(TK_COMMA);
        if(token==TK_ELLIPSIS)
        {
            func_call=KW_CDECL;
            get_token();
            break;
        }
    }
    syntax_state=SNTX_DELAY;
    skip(TK_CLOSEPA);
    if(token==TK_BEGIN)     //函数定义
        syntax_state=SNTX_LF_HT;
    else                    //函数声明
        syntax_state=SNTX_NUL;
    syntax_indent();
    /**此处将函数返回类型存储，然后指向参数，最后将type设为函数类型，引用相关信息，放在ref中**/
    s=sym_push(SC_ANOM,type,func_call,0);
    s->next=first;
    type->t=T_FUNC;
    type->ref=s;
}
/**
函数体
<funcbody>::=<compound_statement>
sym:函数符号
**/
void funcbody(Symbol *sym)
{
    /**放一匿名符号在局部符号表**/
    sym_direct_push(&local_sym_stack,SC_ANOM,&int_type,0);
    compound_statement(NULL,NULL);
    /**清空局部符号栈**/
    sym_pop(&local_sym_stack,NULL);
}
/**
初值符
<initializer>::=<assignment_expression>
**/
void initializer(Type *type)
{
    if(type->t&T_ARRAY)
        get_token();
    else
        assignment_expression();
}

/**
复合语句
<compound_statement>::=<TK_BEGIN>{<declaration>}{<statement>}<TK_END>

bsym:break跳转位置
csym:continue跳转位置
**/
void compound_statement(int *bsym,int *csym)
{
    syntax_state=SNTX_LF_HT;
    syntax_level++;         //复合语句，缩进加一级

    Symbol *s;
    s=(Symbol*)stack_get_top(&local_sym_stack);/**去局部栈顶元素为坐标**/

    get_token();
    while(is_type_specifier(token))             /**判断是否是声明**/
    {
        external_decartion(SC_LOCAL);
    }
    while(token!=TK_END)
    {
        statement(bsym,csym);
    }
    sym_pop(&local_sym_stack,s);              /**根据这个坐标把复合语句的符号清空**/
    syntax_state=SNTX_LF_HT;
    get_token();
}

/**
<sizeof_expression>::=
    <KW_SIZEOF><TK_OPENPA><type_specifier><TK_CLOSEPA>
**/
void sizeof_expression()
{
    int align,size;
    Type type;

    get_token();
    skip(TK_OPENPA);
    type_specifier(&type);
    skip(TK_CLOSEPA);

    size=type_size(&type,&align);
    if(size<0)
        error("sizeof计算类型尺寸失败")
}
/**
返回类型长度
t:数据类型指针
a:对齐值
**/
int type_size(Type *t,int *a)
{
    Symbol *s;
    int bt;
    //指针类型长度4字节
    int PTR_SIZE=4;

    bt=t->t&T_BTYPE;
    switch(bt)
    {
    case T_STRUCT:
        s=t->ref;
        *a=s->r;            /**结构体的r纪录对齐粒度**/
        return s->c;        /**结构体的c纪录结构体大小**/
    case T_PTR:             /**指针类型**/
        if(t->t&T_ARRAY)    /**数组**/
        {
            s=t->ref;
            return type_size(&s->type,a)*s->c;/**引用的大小*数量**/
        }
        else
        {
            *a=PTR_SIZE;
            return PTR_SIZE;
        }
    case T_INT:
        *a=4;
        return 4;
    case T_SHORT:
        *a=2;
        return 2;

    default:        //char ,void ,function
        *a=1;
        return 1;
    }

}
/**
初值表达式
<primary_expression>::=<IDENTIFIER>
    |<TK_CINT>
    |<TK_CSTR>
    |<TK_CCHAR>
    |<TK_OPENPA><expression><TK_CLOSEPA>
***/
void primary_expression()
{
    int t,addr;
    Type type;
    Symbol *s;
    switch(token)
    {
    case TK_CINT:
    case TK_CCHAR:
        get_token();
        break;
    case TK_CSTR:
        t=T_CHAR;
        type.t=t;
        mk_pointer(&type);                  /**常量字符串设置为一个指针类型**/
        type.t|=T_ARRAY;
        var_sym_put(&type,SC_GLOBAL,0,addr);
        initializer(&type);
        break;
    case TK_OPENPA:
        get_token();
        expression();
        skip(TK_CLOSEPA);
        break;
    default:
        t=token;
        get_token();
        if(t<TK_IDENT)
            expect("标识符或常量");
        s=sym_search(t);
        if(!s)
        {
            if(token!=TK_OPENPA)
                error("'%s'未声明\n",get_tkstr(t));

            s=func_sym_push(t,&default_func_type); //允许函数不声明，直接引用
            s->r=SC_GLOBAL|SC_SYM;
        }
        break;
    }
}