语句，表达式

/**
语句
<statement>::=<compound_statement>
    |<if_statement>
    |<return_statement>
    |<break_statement>
    |<continue_statement>
    |<for_statement>
    |<expression_statement>
**/
void statement()
{
    switch(token)
    {
    case TK_BEGIN:
        compound_statement();
        break;
    case KW_IF:
        if_statement();
        break;
    case KW_RETURN:
        return_statement();
        break;
    case KW_BREAK:
        break_statement();
        break;
    case KW_CONTINUE:
        continue_statement();
        break;
    case KW_FOR:
        for_statement();
        break;
    default:
        expression_statement();
        break;
    }
}

/**
复合语句
<compound_statement>::=<TK_BEGIN>{<declaration>}{<statement>}<TK_END>
**/
void compound_statement()
{
    syntax_state=SNTX_LF_HT;
    syntax_level++;                     //复合语句，缩进加一级
    get_token();
    while(is_type_specifier(token))     //判断是否是声明
    {
        external_declaration(SC_LOCAL);
    }
    while(token!=TK_END)
    {
        statement();
    }
    syntax_state=SNTX_LF_HT;
    get_token();
}
/**
判断是否为类型区分符
v:      单词编号
**/
int is_type_specifier(int v)
{
    switch(v)
    {
    case KW_CHAR:
    case KW_SHORT:
    case KW_VOID:
    case KW_INT:
    case KW_STRUCT:
        return 1;
    default:
        break;
    }
    return 0;
}
/**
表达式语句
<expression_statement>::=<TK_SEMICOLON>|<expression><TK_SEMICOLON>
**/
void expression_statement()
{
    if(token!=TK_SEMICOLON)
    {
        expression();
    }
    syntax_state=SNTX_LF_HT;
    skip(TK_SEMICOLON);
}
/**
选择语句
<if_statement>::=<KW_IF><TK_OPENPA><expression>
    <TK_CLOSEPA><statement>[<KW_ELSE><statement>]
**/
void if_statement()
{
    syntax_state=SNTX_SP;
    get_token();
    skip(TK_OPENPA);
    expression();
    syntax_state=SNTX_LF_HT;
    skip(TK_CLOSEPA);
    statement();
    if(token==KW_ELSE)
    {
        syntax_state=SNTX_LF_HT;
        get_token();
        statement();
    }
}
/**
循环语句
<for_statement>::=<KW_FOR><TK_OPENPA><expression_statement>
    <expression_statement><expression><TK_CLOSEPA><statement>
**/
void for_statement()
{
    get_token();
    skip(TK_OPENPA);
    if(token!=TK_SEMICOLON)
    {
        expression();
    }
    skip(TK_SEMICOLON);
    if(token!=TK_SEMICOLON)
    {
        expression();
    }
    skip(TK_SEMICOLON);
    if(token!=TK_CLOSEPA)
    {
        expression();
    }
    syntax_state=SNTX_LF_HT;
    skip(TK_CLOSEPA);
    statement();
}
/**
continue语句
<continue_statement>::=<KW_CONTINUE><TK_SEMICOLON>
**/
void continue_statement()
{
    get_token();
    syntax_state=SNTX_LF_HT;
    skip(TK_SEMICOLON);
}
/**
break语句
<break_statement>::=<KW_BREAK><TK_SEMICOLON>
**/
void break_statement()
{
    get_token();
    syntax_state=SNTX_LF_HT;
    skip(TK_SEMICOLON);
}
/**
return 语句
<return_statement>::<KW_RETURN><TK_SEMICOLON>
    |<KW_RETURN><expression><TK_SEMICOLON>
**/
void return_statement()
{
    syntax_state=SNTX_DELAY;
    get_token();
    if(token==TK_SEMICOLON)     //适用于return
        syntax_state=SNTX_NUL;
    else                         //适用于return expression
        syntax_state=SNTX_SP;
    syntax_indent();
    if(token!=TK_SEMICOLON)
    {
        expression();
    }
    syntax_state=SNTX_LF_HT;
    skip(TK_SEMICOLON);
}
/**
表达式
<expression>::=<assignment_expression>{<TK_COMMA><assignment_expression>}
**/
void expression()
{
    while(1)
    {
        assignment_expression();
        if(token!=TK_COMMA)
            break;
        get_token();
    }
}
/**
赋值表达式
<assignment_expression>::=<equality_expression>
    |<unary_expression><TK_ASSIGN><assignment_expression>
非等价转换后文法
<assignment_expression>::=<equality_expression>
    {<TK_ASSIGN><assignment_expression>}
**/
void assignment_expression()
{
    equality_expression();
    if(token==TK_ASSIGN)
    {
        get_token();
        assignment_expression();
    }
}
/**
相等类表达式
<equality_expression>::=<relational_expression>
    {<TK_EQ><relational_expression>
    |<TK_NEQ><relational_expression>
    }
**/
void equality_expression()
{
    relational_expression();
    while(token==TK_EQ||token==TK_NEQ)
    {
        get_token();
        relational_expression();
    }
}
/**
关系表达式
<relational_expression>::=<additive_expression>{
    <TK_LT><additive_expression>
    |<TK_GT><additive_expression>
    |<TK_LEQ><additive_expression>
    |<TK_GEQ><additive_expression>
}
**/
void relational_expression()
{
    additive_expression();
    while(token==TK_LT||token==TK_LEQ||token==TK_GT||token==TK_GEQ)
    {
        get_token();
        additive_expression();
    }
}
/**
加减类表达式
<additive_expression>::=<multiplicative_expression>
    {<TK_PLUS><multiplicative_expression>
    |<TK_MINUS><multiplicative_expression>
    }
**/
void additive_expression()
{
    multiplicative_expression();
    while(token==TK_PLUS||token==TK_MINUS)
    {
        get_token();
        multiplicative_expression();
    }
}
/**
乘除类表达式
<multiplicative_expression>::=<unary_expression>
    {<TK_STAR><unary_expression>
    |<TK_DIVIDE><unary_expression>
    |<TK_MOD><unary_expression>
    }
**/
void multiplicative_expression()
{
    unary_expression();
    while(token==TK_STAR||token==TK_DIDIVE||token==TK_MOD)
    {
        get_token();
        unary_expression();
    }
}
/**
一元表达式
<unary_expression>::=
            <postfix_expression>
            |<TK_AND><unary_expression>
            |<TK_STAR><unary_expression>
            |<TK_PLUS><unary_expression>
            |<TK_MINUS><unary_expression>
            |<sizeof_expression>
**/
void unary_expression()
{
    switch(token)
    {
    case TK_AND:
    case TK_STAR:
    case TK_PLUS:
    case TK_MINUS:
        get_token();
        unary_expression();
        break;
    case KW_SIZEOF:
        sizeof_expression();
        break;
    default:
        postfix_expression();
        break;
    }
}
/**
<sizeof_expression>::=
    <KW_SIZEOF><TK_OPENPA><type_specifier><TK_CLOSEPA>
**/
void sizeof_expression()
{
    get_token();
    skip(TK_OPENPA);
    type_specifier();
    skip(TK_CLOSEPA);
}
/**
后缀表达式
<postfix_expression>::=<primary_expression>
    {<TK_OPENBR><expression><TK_CLOSEBR>
    |<TK_OPENPA><TK_CLOSEPA>
    |<TK_OPENPA><argument_expression_list><TK_CLOSEPA>
    |<TK_DOT><IDENTIFIER>
    |<TK_POINTSTO><IDENTIFIER>
    }
**/
void postfix_expression()
{
    primary_expression();
    while(1)
    {
        if(token==TK_DOT||token==TK_POINTSTO)
        {
            get_token();
            token|=SC_MEMBER;       /**?**/
            get_token();
        }
        else if(token==TK_OPENBR)
        {
            get_token();
            expression();
            skip(TK_CLOSEBR);
        }
        else if(token==TK_OPENPA)
        {
            argument_expression_list();
        }
        else
            break;
    }
}
/**
<primary_expression>::=<IDENTIFIER>
    |<TK_CINT>
    |<TK_CSTR>
    |<TK_CCHAR>
    |<TK_OPENPA><expression><TK_CLOSEPA>
**/
void primary_expression()
{
    int t;
    switch(token)
    {
    case TK_CINT:
    case TK_CCHAR:
    case TK_CSTR:
        get_token();
        break;
    case TK_OPENPA:
        get_token();
        expression();
        skip(TK_CLOSEPA);
        break;
    default:
        t=token;
        get_token();
        if(t<TK_IDENT)
            expect("标识符或常量");
        break;
    }
}
/**
<argument_expression_list>::=<assignment_expression>
        {<TK_COMMA><assignment_expression>}
**/
void argument_expression_list()
{
    get_token();
    if(token!=TK_CLOSEPA)
    {
        for(;;)
        {
            assignment_expression();
            if(token==TK_CLOSEPA)
                break;
            skip(TK_COMMA);
        }
    }
    skip(TK_CLOSEPA);
}